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 |
|---|---|---|---|---|---|
7,547 | def _remove_whitespace(s, regex=_RE_WHITESPACE):
return regex.sub(' ', s.strip())
| [
"def",
"_remove_whitespace",
"(",
"s",
",",
"regex",
"=",
"_RE_WHITESPACE",
")",
":",
"return",
"regex",
".",
"sub",
"(",
"' '",
",",
"s",
".",
"strip",
"(",
")",
")"
] | replace extra whitespace inside of a string with a single space . | train | false |
7,548 | def read_gitfile(f):
cs = f.read()
if (not cs.startswith('gitdir: ')):
raise ValueError("Expected file to start with 'gitdir: '")
return cs[len('gitdir: '):].rstrip('\n')
| [
"def",
"read_gitfile",
"(",
"f",
")",
":",
"cs",
"=",
"f",
".",
"read",
"(",
")",
"if",
"(",
"not",
"cs",
".",
"startswith",
"(",
"'gitdir: '",
")",
")",
":",
"raise",
"ValueError",
"(",
"\"Expected file to start with 'gitdir: '\"",
")",
"return",
"cs",
... | read a . | train | false |
7,549 | def set_project_type_handler(project_type, project_type_handler):
global PROJECT_TYPES
PROJECT_TYPES[project_type] = project_type_handler
| [
"def",
"set_project_type_handler",
"(",
"project_type",
",",
"project_type_handler",
")",
":",
"global",
"PROJECT_TYPES",
"PROJECT_TYPES",
"[",
"project_type",
"]",
"=",
"project_type_handler"
] | set a project type handler for the given project_type . | train | false |
7,550 | @not_implemented_for('directed')
@not_implemented_for('multigraph')
def modularity_matrix(G, nodelist=None, weight=None):
if (nodelist is None):
nodelist = list(G)
A = nx.to_scipy_sparse_matrix(G, nodelist=nodelist, weight=weight, format='csr')
k = A.sum(axis=1)
m = (k.sum() * 0.5)
X = ((k * k.transpose()) / (2 * m))
return (A - X)
| [
"@",
"not_implemented_for",
"(",
"'directed'",
")",
"@",
"not_implemented_for",
"(",
"'multigraph'",
")",
"def",
"modularity_matrix",
"(",
"G",
",",
"nodelist",
"=",
"None",
",",
"weight",
"=",
"None",
")",
":",
"if",
"(",
"nodelist",
"is",
"None",
")",
":... | return the modularity matrix of g . | train | false |
7,551 | def temp_install(html=False, del_module=None):
if html:
Checker = LHTMLOutputChecker
else:
Checker = LXMLOutputChecker
frame = _find_doctest_frame()
dt_self = frame.f_locals['self']
checker = Checker()
old_checker = dt_self._checker
dt_self._checker = checker
if _IS_PYTHON_3:
check_func = frame.f_locals['check'].__func__
checker_check_func = checker.check_output.__func__
else:
check_func = frame.f_locals['check'].im_func
checker_check_func = checker.check_output.im_func
doctest.etree = etree
_RestoreChecker(dt_self, old_checker, checker, check_func, checker_check_func, del_module)
| [
"def",
"temp_install",
"(",
"html",
"=",
"False",
",",
"del_module",
"=",
"None",
")",
":",
"if",
"html",
":",
"Checker",
"=",
"LHTMLOutputChecker",
"else",
":",
"Checker",
"=",
"LXMLOutputChecker",
"frame",
"=",
"_find_doctest_frame",
"(",
")",
"dt_self",
"... | temporary install for convenience . | train | false |
7,552 | @register.filter()
def getlist(value, arg):
return value.getlist(arg)
| [
"@",
"register",
".",
"filter",
"(",
")",
"def",
"getlist",
"(",
"value",
",",
"arg",
")",
":",
"return",
"value",
".",
"getlist",
"(",
"arg",
")"
] | return all values of a querydict key . | train | false |
7,554 | def _gf_pow_pnm1d2(f, n, g, b, p, K):
f = gf_rem(f, g, p, K)
h = f
r = f
for i in range(1, n):
h = gf_frobenius_map(h, g, b, p, K)
r = gf_mul(r, h, p, K)
r = gf_rem(r, g, p, K)
res = gf_pow_mod(r, ((p - 1) // 2), g, p, K)
return res
| [
"def",
"_gf_pow_pnm1d2",
"(",
"f",
",",
"n",
",",
"g",
",",
"b",
",",
"p",
",",
"K",
")",
":",
"f",
"=",
"gf_rem",
"(",
"f",
",",
"g",
",",
"p",
",",
"K",
")",
"h",
"=",
"f",
"r",
"=",
"f",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"n... | utility function for gf_edf_zassenhaus compute f**( // 2) in gf(p)[x]/(g) f**( // 2) = (f*f**p* . | train | false |
7,556 | def asanyarray(a, dtype=None):
return cupy.asarray(a, dtype)
| [
"def",
"asanyarray",
"(",
"a",
",",
"dtype",
"=",
"None",
")",
":",
"return",
"cupy",
".",
"asarray",
"(",
"a",
",",
"dtype",
")"
] | converts an object to array . | train | false |
7,558 | def _concatenate_coils(coils):
rmags = np.concatenate([coil['rmag'] for coil in coils])
cosmags = np.concatenate([coil['cosmag'] for coil in coils])
ws = np.concatenate([coil['w'] for coil in coils])
n_int = np.array([len(coil['rmag']) for coil in coils])
if (n_int[(-1)] == 0):
raise RuntimeError('not supported')
bins = np.repeat(np.arange(len(n_int)), n_int)
return (rmags, cosmags, ws, bins)
| [
"def",
"_concatenate_coils",
"(",
"coils",
")",
":",
"rmags",
"=",
"np",
".",
"concatenate",
"(",
"[",
"coil",
"[",
"'rmag'",
"]",
"for",
"coil",
"in",
"coils",
"]",
")",
"cosmags",
"=",
"np",
".",
"concatenate",
"(",
"[",
"coil",
"[",
"'cosmag'",
"]... | helper to concatenate meg coil parameters . | train | false |
7,559 | def bulk_upload():
s3.stylesheets.append('plugins/fileuploader.css')
return dict()
| [
"def",
"bulk_upload",
"(",
")",
":",
"s3",
".",
"stylesheets",
".",
"append",
"(",
"'plugins/fileuploader.css'",
")",
"return",
"dict",
"(",
")"
] | custom view to allow bulk uploading of photos @todo: allow creation of a gis feature layer to view on the map @todo: allow uploading of associated gpx track for timestamp correlation . | train | false |
7,560 | def MakeFreshResponse():
reference = json.loads(kVerifyResponseRenewedExpired)
new = {'status': 0, 'receipt': reference['receipt']}
new['receipt']['expires_date'] = (1000.0 * (time.time() + datetime.timedelta(days=28).total_seconds()))
return json.dumps(new)
| [
"def",
"MakeFreshResponse",
"(",
")",
":",
"reference",
"=",
"json",
".",
"loads",
"(",
"kVerifyResponseRenewedExpired",
")",
"new",
"=",
"{",
"'status'",
":",
"0",
",",
"'receipt'",
":",
"reference",
"[",
"'receipt'",
"]",
"}",
"new",
"[",
"'receipt'",
"]... | returns a response for a subscription which has an expiration date in the future . | train | false |
7,561 | @ckan.logic.validate(ckan.logic.schema.job_clear_schema)
def job_clear(context, data_dict):
_check_access(u'job_clear', context, data_dict)
queues = data_dict.get(u'queues')
if queues:
queues = [jobs.get_queue(q) for q in queues]
else:
queues = jobs.get_all_queues()
names = [jobs.remove_queue_name_prefix(queue.name) for queue in queues]
for (queue, name) in zip(queues, names):
queue.empty()
log.info(u'Cleared background job queue "{}"'.format(name))
return names
| [
"@",
"ckan",
".",
"logic",
".",
"validate",
"(",
"ckan",
".",
"logic",
".",
"schema",
".",
"job_clear_schema",
")",
"def",
"job_clear",
"(",
"context",
",",
"data_dict",
")",
":",
"_check_access",
"(",
"u'job_clear'",
",",
"context",
",",
"data_dict",
")",... | clear background jobs . | train | false |
7,562 | @snippet
def sink_pubsub(client, to_delete):
topic = _sink_pubsub_setup(client)
to_delete.append(topic)
SINK_NAME = ('robots-pubsub-%d' % (_millis(),))
FILTER = 'logName:apache-access AND textPayload:robot'
UPDATED_FILTER = 'textPayload:robot'
DESTINATION = ('pubsub.googleapis.com/%s' % (topic.full_name,))
sink = client.sink(SINK_NAME, filter_=FILTER, destination=DESTINATION)
assert (not sink.exists())
sink.create()
assert sink.exists()
to_delete.insert(0, sink)
for sink in client.list_sinks():
do_something_with(sink)
existing_sink = client.sink(SINK_NAME)
existing_sink.reload()
assert (existing_sink.filter_ == FILTER)
assert (existing_sink.destination == DESTINATION)
existing_sink.filter_ = UPDATED_FILTER
existing_sink.update()
existing_sink.reload()
assert (existing_sink.filter_ == UPDATED_FILTER)
sink.delete()
to_delete.pop(0)
| [
"@",
"snippet",
"def",
"sink_pubsub",
"(",
"client",
",",
"to_delete",
")",
":",
"topic",
"=",
"_sink_pubsub_setup",
"(",
"client",
")",
"to_delete",
".",
"append",
"(",
"topic",
")",
"SINK_NAME",
"=",
"(",
"'robots-pubsub-%d'",
"%",
"(",
"_millis",
"(",
"... | sink log entries to pubsub . | train | true |
7,563 | @gen.engine
def _Run(callback):
job_set = options.options.job_set
assert (job_set in kJobSets.keys()), ('--job_set must be one of %r' % kJobSets.keys())
jobs = kJobSets[job_set]
client = db_client.DBClient.Instance()
job = Job(client, job_set)
got_lock = (yield gen.Task(job.AcquireLock))
if (not got_lock):
logging.warning('Failed to acquire job lock: exiting.')
callback()
return
try:
for (title, args) in jobs:
logging.info(('[%s] running %s' % (title, ' '.join(args))))
proc = process.Subprocess(args, io_loop=ioloop.IOLoop.instance())
code = (yield gen.Task(proc.set_exit_callback))
logging.info(('[%s] finished with code: %r' % (title, code)))
except:
logging.error(traceback.format_exc())
finally:
(yield gen.Task(job.ReleaseLock))
callback()
| [
"@",
"gen",
".",
"engine",
"def",
"_Run",
"(",
"callback",
")",
":",
"job_set",
"=",
"options",
".",
"options",
".",
"job_set",
"assert",
"(",
"job_set",
"in",
"kJobSets",
".",
"keys",
"(",
")",
")",
",",
"(",
"'--job_set must be one of %r'",
"%",
"kJobS... | grab the lock and run all commands an subprocesess . | train | false |
7,567 | @synchronized(DIR_LOCK)
def get_unique_path(dirpath, n=0, create_dir=True):
if (not check_mount(dirpath)):
return dirpath
path = dirpath
if n:
path = ('%s.%s' % (dirpath, n))
if (not os.path.exists(path)):
if create_dir:
return create_dirs(path)
else:
return path
else:
return get_unique_path(dirpath, n=(n + 1), create_dir=create_dir)
| [
"@",
"synchronized",
"(",
"DIR_LOCK",
")",
"def",
"get_unique_path",
"(",
"dirpath",
",",
"n",
"=",
"0",
",",
"create_dir",
"=",
"True",
")",
":",
"if",
"(",
"not",
"check_mount",
"(",
"dirpath",
")",
")",
":",
"return",
"dirpath",
"path",
"=",
"dirpat... | determine a unique folder or filename . | train | false |
7,568 | def process_args(args, defaults, description):
parser = argparse.ArgumentParser(description=description)
parser.add_argument('-r', '--rom', dest='rom', default=defaults.ROM, help='ROM to run (default: %(default)s)')
parser.add_argument('-e', '--epochs', dest='epochs', type=int, default=defaults.EPOCHS, help='Number of training epochs (default: %(default)s)')
parser.add_argument('-s', '--steps-per-epoch', dest='steps_per_epoch', type=int, default=defaults.STEPS_PER_EPOCH, help='Number of steps per epoch (default: %(default)s)')
parser.add_argument('-t', '--test-length', dest='steps_per_test', type=int, default=defaults.STEPS_PER_TEST, help='Number of steps per test (default: %(default)s)')
parser.add_argument('--display-screen', dest='display_screen', action='store_true', default=False, help='Show the game screen.')
parser.add_argument('--experiment-prefix', dest='experiment_prefix', default=None, help='Experiment name prefix (default is the name of the game)')
parser.add_argument('--frame-skip', dest='frame_skip', default=defaults.FRAME_SKIP, type=int, help='Every how many frames to process (default: %(default)s)')
parser.add_argument('--repeat-action-probability', dest='repeat_action_probability', default=defaults.REPEAT_ACTION_PROBABILITY, type=float, help=('Probability that action choice will be ' + 'ignored (default: %(default)s)'))
parser.add_argument('--update-rule', dest='update_rule', type=str, default=defaults.UPDATE_RULE, help=('deepmind_rmsprop|rmsprop|sgd ' + '(default: %(default)s)'))
parser.add_argument('--batch-accumulator', dest='batch_accumulator', type=str, default=defaults.BATCH_ACCUMULATOR, help='sum|mean (default: %(default)s)')
parser.add_argument('--learning-rate', dest='learning_rate', type=float, default=defaults.LEARNING_RATE, help='Learning rate (default: %(default)s)')
parser.add_argument('--rms-decay', dest='rms_decay', type=float, default=defaults.RMS_DECAY, help='Decay rate for rms_prop (default: %(default)s)')
parser.add_argument('--rms-epsilon', dest='rms_epsilon', type=float, default=defaults.RMS_EPSILON, help=('Denominator epsilson for rms_prop ' + '(default: %(default)s)'))
parser.add_argument('--momentum', type=float, default=defaults.MOMENTUM, help=('Momentum term for Nesterov momentum. ' + '(default: %(default)s)'))
parser.add_argument('--clip-delta', dest='clip_delta', type=float, default=defaults.CLIP_DELTA, help=('Max absolute value for Q-update delta value. ' + '(default: %(default)s)'))
parser.add_argument('--discount', type=float, default=defaults.DISCOUNT, help='Discount rate')
parser.add_argument('--epsilon-start', dest='epsilon_start', type=float, default=defaults.EPSILON_START, help=('Starting value for epsilon. ' + '(default: %(default)s)'))
parser.add_argument('--epsilon-min', dest='epsilon_min', type=float, default=defaults.EPSILON_MIN, help='Minimum epsilon. (default: %(default)s)')
parser.add_argument('--epsilon-decay', dest='epsilon_decay', type=float, default=defaults.EPSILON_DECAY, help=('Number of steps to minimum epsilon. ' + '(default: %(default)s)'))
parser.add_argument('--phi-length', dest='phi_length', type=int, default=defaults.PHI_LENGTH, help=('Number of recent frames used to represent ' + 'state. (default: %(default)s)'))
parser.add_argument('--max-history', dest='replay_memory_size', type=int, default=defaults.REPLAY_MEMORY_SIZE, help=('Maximum number of steps stored in replay ' + 'memory. (default: %(default)s)'))
parser.add_argument('--batch-size', dest='batch_size', type=int, default=defaults.BATCH_SIZE, help='Batch size. (default: %(default)s)')
parser.add_argument('--network-type', dest='network_type', type=str, default=defaults.NETWORK_TYPE, help=('nips_cuda|nips_dnn|nature_cuda|nature_dnn' + '|linear (default: %(default)s)'))
parser.add_argument('--freeze-interval', dest='freeze_interval', type=int, default=defaults.FREEZE_INTERVAL, help=('Interval between target freezes. ' + '(default: %(default)s)'))
parser.add_argument('--update-frequency', dest='update_frequency', type=int, default=defaults.UPDATE_FREQUENCY, help=('Number of actions before each SGD update. ' + '(default: %(default)s)'))
parser.add_argument('--replay-start-size', dest='replay_start_size', type=int, default=defaults.REPLAY_START_SIZE, help=('Number of random steps before training. ' + '(default: %(default)s)'))
parser.add_argument('--resize-method', dest='resize_method', type=str, default=defaults.RESIZE_METHOD, help='crop|scale (default: %(default)s)')
parser.add_argument('--nn-file', dest='nn_file', type=str, default=None, help='Pickle file containing trained net.')
parser.add_argument('--death-ends-episode', dest='death_ends_episode', type=str, default=defaults.DEATH_ENDS_EPISODE, help='true|false (default: %(default)s)')
parser.add_argument('--max-start-nullops', dest='max_start_nullops', type=int, default=defaults.MAX_START_NULLOPS, help=('Maximum number of null-ops at the start ' + 'of games. (default: %(default)s)'))
parser.add_argument('--deterministic', dest='deterministic', type=bool, default=defaults.DETERMINISTIC, help=('Whether to use deterministic parameters ' + 'for learning. (default: %(default)s)'))
parser.add_argument('--cudnn_deterministic', dest='cudnn_deterministic', type=bool, default=defaults.CUDNN_DETERMINISTIC, help=('Whether to use deterministic backprop. ' + '(default: %(default)s)'))
parameters = parser.parse_args(args)
if (parameters.experiment_prefix is None):
name = os.path.splitext(os.path.basename(parameters.rom))[0]
parameters.experiment_prefix = name
if (parameters.death_ends_episode == 'true'):
parameters.death_ends_episode = True
elif (parameters.death_ends_episode == 'false'):
parameters.death_ends_episode = False
else:
raise ValueError('--death-ends-episode must be true or false')
if (parameters.freeze_interval > 0):
parameters.freeze_interval = (parameters.freeze_interval // parameters.update_frequency)
return parameters
| [
"def",
"process_args",
"(",
"args",
",",
"defaults",
",",
"description",
")",
":",
"parser",
"=",
"argparse",
".",
"ArgumentParser",
"(",
"description",
"=",
"description",
")",
"parser",
".",
"add_argument",
"(",
"'-r'",
",",
"'--rom'",
",",
"dest",
"=",
... | take a list of string arguments parsed via pyparsing and evaluate the special variables . | train | false |
7,569 | def take_action(name=None, call=None, command=None, data=None, method='GET', location=DEFAULT_LOCATION):
caller = inspect.stack()[1][3]
if (call != 'action'):
raise SaltCloudSystemExit('This action must be called with -a or --action.')
if data:
data = json.dumps(data)
ret = []
try:
ret = query(command=command, data=data, method=method, location=location)
log.info('Success {0} for node {1}'.format(caller, name))
except Exception as exc:
if ('InvalidState' in str(exc)):
ret = [200, {}]
else:
log.error('Failed to invoke {0} node {1}: {2}'.format(caller, name, exc), exc_info_on_loglevel=logging.DEBUG)
ret = [100, {}]
return ret
| [
"def",
"take_action",
"(",
"name",
"=",
"None",
",",
"call",
"=",
"None",
",",
"command",
"=",
"None",
",",
"data",
"=",
"None",
",",
"method",
"=",
"'GET'",
",",
"location",
"=",
"DEFAULT_LOCATION",
")",
":",
"caller",
"=",
"inspect",
".",
"stack",
... | take action call used by start . | train | true |
7,571 | def decomposeGlyph(font, glyphName):
glyph = font[glyphName]
deepCopyContours(font, glyph, glyph, (0, 0), (1, 1))
glyph.clearComponents()
| [
"def",
"decomposeGlyph",
"(",
"font",
",",
"glyphName",
")",
":",
"glyph",
"=",
"font",
"[",
"glyphName",
"]",
"deepCopyContours",
"(",
"font",
",",
"glyph",
",",
"glyph",
",",
"(",
"0",
",",
"0",
")",
",",
"(",
"1",
",",
"1",
")",
")",
"glyph",
... | moves the components of a glyph to its outline . | train | false |
7,572 | def cross_entropy_bernoulli(mat, p, target=None, tiny=1e-10):
if (not target):
target = mat
if isinstance(p, CUDAMatrix):
err_code = _cudamat.compute_cross_entropy_bernoulli(mat.p_mat, p.p_mat, target.p_mat, ct.c_float(tiny))
else:
raise ValueError, 'Value must be of type CUDAMatrix.'
if err_code:
raise generate_exception(err_code)
return target
| [
"def",
"cross_entropy_bernoulli",
"(",
"mat",
",",
"p",
",",
"target",
"=",
"None",
",",
"tiny",
"=",
"1e-10",
")",
":",
"if",
"(",
"not",
"target",
")",
":",
"target",
"=",
"mat",
"if",
"isinstance",
"(",
"p",
",",
"CUDAMatrix",
")",
":",
"err_code"... | compute -mat*log(p) - . | train | false |
7,573 | def patch(target, new=DEFAULT, spec=None, create=False, spec_set=None, autospec=None, new_callable=None, **kwargs):
(getter, attribute) = _get_target(target)
return _patch(getter, attribute, new, spec, create, spec_set, autospec, new_callable, kwargs)
| [
"def",
"patch",
"(",
"target",
",",
"new",
"=",
"DEFAULT",
",",
"spec",
"=",
"None",
",",
"create",
"=",
"False",
",",
"spec_set",
"=",
"None",
",",
"autospec",
"=",
"None",
",",
"new_callable",
"=",
"None",
",",
"**",
"kwargs",
")",
":",
"(",
"get... | monkey-patch the djangousermixin class . | train | true |
7,574 | def load_module_sections(trans):
module_sections = {}
module_sections['inputs'] = {'name': 'inputs', 'title': 'Inputs', 'modules': [{'name': 'data_input', 'title': 'Input Dataset', 'description': 'Input dataset'}, {'name': 'data_collection_input', 'title': 'Input Dataset Collection', 'description': 'Input dataset collection'}]}
if trans.app.config.enable_beta_workflow_modules:
module_sections['experimental'] = {'name': 'experimental', 'title': 'Experimental', 'modules': [{'name': 'pause', 'title': 'Pause Workflow for Dataset Review', 'description': 'Pause for Review'}, {'name': 'parameter_input', 'title': 'Parameter Input', 'description': 'Simple inputs used for workflow logic'}]}
return module_sections
| [
"def",
"load_module_sections",
"(",
"trans",
")",
":",
"module_sections",
"=",
"{",
"}",
"module_sections",
"[",
"'inputs'",
"]",
"=",
"{",
"'name'",
":",
"'inputs'",
",",
"'title'",
":",
"'Inputs'",
",",
"'modules'",
":",
"[",
"{",
"'name'",
":",
"'data_i... | get abstract description of the workflow modules this galaxy instance is configured with . | train | false |
7,575 | @register.tag
def ifhasperm(parser, token):
return PermissionComparisonNode.handle_token(parser, token)
| [
"@",
"register",
".",
"tag",
"def",
"ifhasperm",
"(",
"parser",
",",
"token",
")",
":",
"return",
"PermissionComparisonNode",
".",
"handle_token",
"(",
"parser",
",",
"token",
")"
] | this function provides functionality for the ifhasperm template tag syntax:: {% ifhasperm permission_label . | train | false |
7,576 | def geocode_r():
vars = request.post_vars
lat = vars.get('lat', None)
lon = vars.get('lon', None)
results = gis.geocode_r(lat, lon)
results = json.dumps(results, separators=SEPARATORS)
response.headers['Content-Type'] = 'application/json'
return results
| [
"def",
"geocode_r",
"(",
")",
":",
"vars",
"=",
"request",
".",
"post_vars",
"lat",
"=",
"vars",
".",
"get",
"(",
"'lat'",
",",
"None",
")",
"lon",
"=",
"vars",
".",
"get",
"(",
"'lon'",
",",
"None",
")",
"results",
"=",
"gis",
".",
"geocode_r",
... | reverse-geocode a location - designed to be called via ajax post looks up lx in our own database @todo: if not found then calls out to 3rd party services . | train | false |
7,577 | def network_entry(is_metal, interface, bridge=None, net_type=None, net_mtu=None):
if is_metal:
_network = dict()
else:
_network = {'interface': interface}
if bridge:
_network['bridge'] = bridge
if net_type:
_network['type'] = net_type
if net_mtu:
_network['mtu'] = net_mtu
return _network
| [
"def",
"network_entry",
"(",
"is_metal",
",",
"interface",
",",
"bridge",
"=",
"None",
",",
"net_type",
"=",
"None",
",",
"net_mtu",
"=",
"None",
")",
":",
"if",
"is_metal",
":",
"_network",
"=",
"dict",
"(",
")",
"else",
":",
"_network",
"=",
"{",
"... | return a network entry for a container . | train | false |
7,578 | def prepare_path_for_serialization(path):
return [(unicode(path_item.usage_key), path_item.display_name) for path_item in path]
| [
"def",
"prepare_path_for_serialization",
"(",
"path",
")",
":",
"return",
"[",
"(",
"unicode",
"(",
"path_item",
".",
"usage_key",
")",
",",
"path_item",
".",
"display_name",
")",
"for",
"path_item",
"in",
"path",
"]"
] | return the data from a list of pathitems ready for serialization to json . | train | false |
7,579 | @transaction.atomic
def override_field_for_ccx(ccx, block, name, value):
field = block.fields[name]
value_json = field.to_json(value)
serialized_value = json.dumps(value_json)
override_has_changes = False
clean_ccx_key = _clean_ccx_key(block.location)
override = get_override_for_ccx(ccx, block, (name + '_instance'))
if override:
override_has_changes = (serialized_value != override.value)
if (not override):
(override, created) = CcxFieldOverride.objects.get_or_create(ccx=ccx, location=block.location, field=name, defaults={'value': serialized_value})
if created:
_get_overrides_for_ccx(ccx).setdefault(clean_ccx_key, {})[(name + '_id')] = override.id
else:
override_has_changes = (serialized_value != override.value)
if override_has_changes:
override.value = serialized_value
override.save()
_get_overrides_for_ccx(ccx).setdefault(clean_ccx_key, {})[name] = value_json
_get_overrides_for_ccx(ccx).setdefault(clean_ccx_key, {})[(name + '_instance')] = override
| [
"@",
"transaction",
".",
"atomic",
"def",
"override_field_for_ccx",
"(",
"ccx",
",",
"block",
",",
"name",
",",
"value",
")",
":",
"field",
"=",
"block",
".",
"fields",
"[",
"name",
"]",
"value_json",
"=",
"field",
".",
"to_json",
"(",
"value",
")",
"s... | overrides a field for the ccx . | train | false |
7,580 | def test_uninstall_as_egg(script, data):
to_install = data.packages.join('FSPkg')
result = script.pip('install', to_install, '--egg', expect_error=True)
fspkg_folder = (script.site_packages / 'fspkg')
egg_folder = ((script.site_packages / 'FSPkg-0.1.dev0-py%s.egg') % pyversion)
assert (fspkg_folder not in result.files_created), str(result.stdout)
assert (egg_folder in result.files_created), str(result)
result2 = script.pip('uninstall', 'FSPkg', '-y')
assert_all_changes(result, result2, [(script.venv / 'build'), 'cache', (script.site_packages / 'easy-install.pth')])
| [
"def",
"test_uninstall_as_egg",
"(",
"script",
",",
"data",
")",
":",
"to_install",
"=",
"data",
".",
"packages",
".",
"join",
"(",
"'FSPkg'",
")",
"result",
"=",
"script",
".",
"pip",
"(",
"'install'",
",",
"to_install",
",",
"'--egg'",
",",
"expect_error... | test uninstall package installed as egg . | train | false |
7,581 | def multinomial_logpmf(x, n, p):
return ((gammaln((n + 1.0)) - np.sum(gammaln((x + 1.0)))) + np.sum((x * np.log(p))))
| [
"def",
"multinomial_logpmf",
"(",
"x",
",",
"n",
",",
"p",
")",
":",
"return",
"(",
"(",
"gammaln",
"(",
"(",
"n",
"+",
"1.0",
")",
")",
"-",
"np",
".",
"sum",
"(",
"gammaln",
"(",
"(",
"x",
"+",
"1.0",
")",
")",
")",
")",
"+",
"np",
".",
... | log pmf of multinomial . | train | false |
7,582 | @status('Fixing whitespace', info=(lambda x: ('%s files' % x)))
def normalize_whitespace(file_paths):
reindent.makebackup = False
result = map(reindent.check, (x for x in file_paths if x.endswith('.py')))
return sum(result)
| [
"@",
"status",
"(",
"'Fixing whitespace'",
",",
"info",
"=",
"(",
"lambda",
"x",
":",
"(",
"'%s files'",
"%",
"x",
")",
")",
")",
"def",
"normalize_whitespace",
"(",
"file_paths",
")",
":",
"reindent",
".",
"makebackup",
"=",
"False",
"result",
"=",
"map... | make sure that the whitespace for . | train | false |
7,585 | @library.filter
def selector_content_find(document, selector):
content = ''
try:
page = pq(document.rendered_html)
except ValueError:
pass
try:
content = page.find(selector).text()
except SelectorSyntaxError:
pass
return content
| [
"@",
"library",
".",
"filter",
"def",
"selector_content_find",
"(",
"document",
",",
"selector",
")",
":",
"content",
"=",
"''",
"try",
":",
"page",
"=",
"pq",
"(",
"document",
".",
"rendered_html",
")",
"except",
"ValueError",
":",
"pass",
"try",
":",
"... | provided a selector . | train | false |
7,587 | def check_or_raise_extra(value, message=u'WAMP message invalid'):
if (type(value) != dict):
raise ProtocolError(u'{0}: invalid type {1}'.format(message, type(value)))
for k in value.keys():
if (type(k) != six.text_type):
raise ProtocolError(u"{0}: invalid type {1} for key '{2}'".format(message, type(k), k))
return value
| [
"def",
"check_or_raise_extra",
"(",
"value",
",",
"message",
"=",
"u'WAMP message invalid'",
")",
":",
"if",
"(",
"type",
"(",
"value",
")",
"!=",
"dict",
")",
":",
"raise",
"ProtocolError",
"(",
"u'{0}: invalid type {1}'",
".",
"format",
"(",
"message",
",",
... | check a value for being a valid wamp extra dictionary . | train | false |
7,589 | def enable_pretty_logging(options=None, logger=None):
if (options is None):
import tornado.options
options = tornado.options.options
if ((options.logging is None) or (options.logging.lower() == 'none')):
return
if (logger is None):
logger = logging.getLogger()
logger.setLevel(getattr(logging, options.logging.upper()))
if options.log_file_prefix:
rotate_mode = options.log_rotate_mode
if (rotate_mode == 'size'):
channel = logging.handlers.RotatingFileHandler(filename=options.log_file_prefix, maxBytes=options.log_file_max_size, backupCount=options.log_file_num_backups)
elif (rotate_mode == 'time'):
channel = logging.handlers.TimedRotatingFileHandler(filename=options.log_file_prefix, when=options.log_rotate_when, interval=options.log_rotate_interval, backupCount=options.log_file_num_backups)
else:
error_message = ('The value of log_rotate_mode option should be ' + ('"size" or "time", not "%s".' % rotate_mode))
raise ValueError(error_message)
channel.setFormatter(LogFormatter(color=False))
logger.addHandler(channel)
if (options.log_to_stderr or ((options.log_to_stderr is None) and (not logger.handlers))):
channel = logging.StreamHandler()
channel.setFormatter(LogFormatter())
logger.addHandler(channel)
| [
"def",
"enable_pretty_logging",
"(",
"options",
"=",
"None",
",",
"logger",
"=",
"None",
")",
":",
"if",
"(",
"options",
"is",
"None",
")",
":",
"import",
"tornado",
".",
"options",
"options",
"=",
"tornado",
".",
"options",
".",
"options",
"if",
"(",
... | turns on formatted logging output as configured . | train | true |
7,590 | def memoize_in_request_cache(request_cache_attr_name=None):
def _decorator(func):
'Outer method decorator.'
@functools.wraps(func)
def _wrapper(self, *args, **kwargs):
'\n Wraps a method to memoize results.\n '
request_cache = getattr(self, request_cache_attr_name, None)
if request_cache:
cache_key = '&'.join([hashvalue(arg) for arg in args])
if (cache_key in request_cache.data.setdefault(func.__name__, {})):
return request_cache.data[func.__name__][cache_key]
result = func(self, *args, **kwargs)
request_cache.data[func.__name__][cache_key] = result
return result
else:
return func(self, *args, **kwargs)
return _wrapper
return _decorator
| [
"def",
"memoize_in_request_cache",
"(",
"request_cache_attr_name",
"=",
"None",
")",
":",
"def",
"_decorator",
"(",
"func",
")",
":",
"@",
"functools",
".",
"wraps",
"(",
"func",
")",
"def",
"_wrapper",
"(",
"self",
",",
"*",
"args",
",",
"**",
"kwargs",
... | memoize a method calls results in the request_cache if theres one . | train | false |
7,591 | def StartTcpServer(context, identity=None, address=None, console=False, **kwargs):
from twisted.internet import reactor
address = (address or ('', Defaults.Port))
framer = ModbusSocketFramer
factory = ModbusServerFactory(context, framer, identity, **kwargs)
if console:
from pymodbus.internal.ptwisted import InstallManagementConsole
InstallManagementConsole({'factory': factory})
_logger.info(('Starting Modbus TCP Server on %s:%s' % address))
reactor.listenTCP(address[1], factory, interface=address[0])
reactor.run()
| [
"def",
"StartTcpServer",
"(",
"context",
",",
"identity",
"=",
"None",
",",
"address",
"=",
"None",
",",
"console",
"=",
"False",
",",
"**",
"kwargs",
")",
":",
"from",
"twisted",
".",
"internet",
"import",
"reactor",
"address",
"=",
"(",
"address",
"or"... | a factory to start and run a tcp modbus server . | train | false |
7,592 | def number_for_course_location(location):
return location.course
| [
"def",
"number_for_course_location",
"(",
"location",
")",
":",
"return",
"location",
".",
"course"
] | given a courses block usage locator . | train | false |
7,593 | def attr_le(accessing_obj, accessed_obj, *args, **kwargs):
return attr(accessing_obj, accessed_obj, *args, **{'compare': 'le'})
| [
"def",
"attr_le",
"(",
"accessing_obj",
",",
"accessed_obj",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"return",
"attr",
"(",
"accessing_obj",
",",
"accessed_obj",
",",
"*",
"args",
",",
"**",
"{",
"'compare'",
":",
"'le'",
"}",
")"
] | usage: attr_gt only true if access_objs attribute <= the value given . | train | false |
7,595 | def grad_undefined(op, x_pos, x, comment=''):
return NullType(('This variable is Null because the grad method for input %s (%s) of the %s op is mathematically undefined. %s' % (x_pos, x, op, comment)))()
| [
"def",
"grad_undefined",
"(",
"op",
",",
"x_pos",
",",
"x",
",",
"comment",
"=",
"''",
")",
":",
"return",
"NullType",
"(",
"(",
"'This variable is Null because the grad method for input %s (%s) of the %s op is mathematically undefined. %s'",
"%",
"(",
"x_pos",
",",
"x"... | return an un-computable symbolic variable of type x . | train | false |
7,596 | def show_main(path=MAIN_CF):
(pairs, conf_list) = _parse_main(path)
return pairs
| [
"def",
"show_main",
"(",
"path",
"=",
"MAIN_CF",
")",
":",
"(",
"pairs",
",",
"conf_list",
")",
"=",
"_parse_main",
"(",
"path",
")",
"return",
"pairs"
] | return a dict of active config values . | train | false |
7,597 | @task(queue='web')
def update_static_metadata(project_pk, path=None):
project = Project.objects.get(pk=project_pk)
if (not path):
path = project.static_metadata_path()
log.info(LOG_TEMPLATE.format(project=project.slug, version='', msg='Updating static metadata'))
translations = [trans.language for trans in project.translations.all()]
languages = set(translations)
metadata = {'version': project.default_version, 'language': project.language, 'languages': list(languages), 'single_version': project.single_version}
try:
fh = open(path, 'w+')
json.dump(metadata, fh)
fh.close()
Syncer.copy(path, path, host=socket.gethostname(), file=True)
except (AttributeError, IOError) as e:
log.debug(LOG_TEMPLATE.format(project=project.slug, version='', msg='Cannot write to metadata.json: {0}'.format(e)))
| [
"@",
"task",
"(",
"queue",
"=",
"'web'",
")",
"def",
"update_static_metadata",
"(",
"project_pk",
",",
"path",
"=",
"None",
")",
":",
"project",
"=",
"Project",
".",
"objects",
".",
"get",
"(",
"pk",
"=",
"project_pk",
")",
"if",
"(",
"not",
"path",
... | this is here to avoid circular imports in models . | train | false |
7,599 | def _launchd_paths():
return ['/Library/LaunchAgents', '/Library/LaunchDaemons', '/System/Library/LaunchAgents', '/System/Library/LaunchDaemons']
| [
"def",
"_launchd_paths",
"(",
")",
":",
"return",
"[",
"'/Library/LaunchAgents'",
",",
"'/Library/LaunchDaemons'",
",",
"'/System/Library/LaunchAgents'",
",",
"'/System/Library/LaunchDaemons'",
"]"
] | paths where launchd services can be found . | train | false |
7,601 | def _check_h5py():
try:
import h5py
except ImportError:
raise ImportError('the h5py module is required to use HDF5 I/O')
return h5py
| [
"def",
"_check_h5py",
"(",
")",
":",
"try",
":",
"import",
"h5py",
"except",
"ImportError",
":",
"raise",
"ImportError",
"(",
"'the h5py module is required to use HDF5 I/O'",
")",
"return",
"h5py"
] | helper to check if h5py is installed . | train | false |
7,603 | def _convert_between_ucsc_and_ensemble_naming(chrom):
if chrom.startswith('chr'):
return chrom[3:]
else:
return ('chr' + chrom)
| [
"def",
"_convert_between_ucsc_and_ensemble_naming",
"(",
"chrom",
")",
":",
"if",
"chrom",
".",
"startswith",
"(",
"'chr'",
")",
":",
"return",
"chrom",
"[",
"3",
":",
"]",
"else",
":",
"return",
"(",
"'chr'",
"+",
"chrom",
")"
] | convert between ucsc chromosome naming conventions and ensembl naming conventions (1) . | train | false |
7,604 | def _unmount(path, idempotent=False):
try:
run_process(['umount', '-l', path.path])
except CalledProcessError as e:
if (idempotent and (e.returncode in (1, 32))):
pass
else:
raise UnmountError(blockdevice=path.path, source_message=e.output)
| [
"def",
"_unmount",
"(",
"path",
",",
"idempotent",
"=",
"False",
")",
":",
"try",
":",
"run_process",
"(",
"[",
"'umount'",
",",
"'-l'",
",",
"path",
".",
"path",
"]",
")",
"except",
"CalledProcessError",
"as",
"e",
":",
"if",
"(",
"idempotent",
"and",... | unmount the path . | train | false |
7,605 | def iter_bad_values():
for (ctype, values) in sorted(BAD_VALUES.items()):
for (value, repl) in values:
(yield (ctype, value, repl))
| [
"def",
"iter_bad_values",
"(",
")",
":",
"for",
"(",
"ctype",
",",
"values",
")",
"in",
"sorted",
"(",
"BAD_VALUES",
".",
"items",
"(",
")",
")",
":",
"for",
"(",
"value",
",",
"repl",
")",
"in",
"values",
":",
"(",
"yield",
"(",
"ctype",
",",
"v... | yield pairs of "bad" tuples . | train | false |
7,606 | def write_error_summary(error):
fullpath = request.environ.get('FULLPATH', request.path)
uid = (c.user._id if c.user_is_loggedin else '-')
g.log.error('E: %s U: %s FP: %s', error, uid, fullpath)
| [
"def",
"write_error_summary",
"(",
"error",
")",
":",
"fullpath",
"=",
"request",
".",
"environ",
".",
"get",
"(",
"'FULLPATH'",
",",
"request",
".",
"path",
")",
"uid",
"=",
"(",
"c",
".",
"user",
".",
"_id",
"if",
"c",
".",
"user_is_loggedin",
"else"... | log a single-line summary of the error for easy log grepping . | train | false |
7,608 | @register.inclusion_tag(u'generic/includes/comments.html', takes_context=True)
def comments_for(context, obj):
form_class = import_dotted_path(settings.COMMENT_FORM_CLASS)
form = form_class(context[u'request'], obj)
context_form = context.get(u'posted_comment_form', form)
context.update({u'posted_comment_form': (context_form if (context_form.target_object == obj) else form), u'unposted_comment_form': form, u'comment_url': reverse(u'comment'), u'object_for_comments': obj})
return context
| [
"@",
"register",
".",
"inclusion_tag",
"(",
"u'generic/includes/comments.html'",
",",
"takes_context",
"=",
"True",
")",
"def",
"comments_for",
"(",
"context",
",",
"obj",
")",
":",
"form_class",
"=",
"import_dotted_path",
"(",
"settings",
".",
"COMMENT_FORM_CLASS",... | provides a generic context variable name for the object that comments are being rendered for . | train | false |
7,609 | def get_diff_chunk_generator(*args, **kwargs):
return _generator(*args, **kwargs)
| [
"def",
"get_diff_chunk_generator",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"return",
"_generator",
"(",
"*",
"args",
",",
"**",
"kwargs",
")"
] | returns a diffchunkgenerator instance used for generating chunks . | train | false |
7,610 | def task_pull_docker_images(images=ACCEPTANCE_IMAGES):
return sequence([run_from_args(['docker', 'pull', image]) for image in images])
| [
"def",
"task_pull_docker_images",
"(",
"images",
"=",
"ACCEPTANCE_IMAGES",
")",
":",
"return",
"sequence",
"(",
"[",
"run_from_args",
"(",
"[",
"'docker'",
",",
"'pull'",
",",
"image",
"]",
")",
"for",
"image",
"in",
"images",
"]",
")"
] | pull docker images . | train | false |
7,611 | def transform_old_to_new(line, old_module, new_module, ignore_import_from=False):
if (not ignore_import_from):
import_from_statement = (IMPORT_FROM_TEMPLATE % (old_module,))
if line.startswith(import_from_statement):
new_import_from_statement = (IMPORT_FROM_TEMPLATE % (new_module,))
return line.replace(import_from_statement, new_import_from_statement, 1)
import_statement = (IMPORT_TEMPLATE % (old_module,))
if (import_statement in line):
new_import_statement = (IMPORT_TEMPLATE % (new_module,))
return line.replace(import_statement, new_import_statement, 1)
if line.lstrip().startswith(old_module):
return line.replace(old_module, new_module, 1)
if ((': ' + old_module) in line):
return line.replace((': ' + old_module), (': ' + new_module), 1)
| [
"def",
"transform_old_to_new",
"(",
"line",
",",
"old_module",
",",
"new_module",
",",
"ignore_import_from",
"=",
"False",
")",
":",
"if",
"(",
"not",
"ignore_import_from",
")",
":",
"import_from_statement",
"=",
"(",
"IMPORT_FROM_TEMPLATE",
"%",
"(",
"old_module"... | transforms from an old module to a new one . | train | false |
7,613 | def _theano_leapfrog_integrator(H, q, p, **theano_kwargs):
epsilon = tt.dscalar('epsilon')
epsilon.tag.test_value = 1
n_steps = tt.iscalar('n_steps')
n_steps.tag.test_value = 2
(q_new, p_new) = leapfrog(H, q, p, epsilon, n_steps)
energy_new = energy(H, q_new, p_new)
f = theano.function([q, p, epsilon, n_steps], [q_new, p_new, energy_new], **theano_kwargs)
f.trust_input = True
return f
| [
"def",
"_theano_leapfrog_integrator",
"(",
"H",
",",
"q",
",",
"p",
",",
"**",
"theano_kwargs",
")",
":",
"epsilon",
"=",
"tt",
".",
"dscalar",
"(",
"'epsilon'",
")",
"epsilon",
".",
"tag",
".",
"test_value",
"=",
"1",
"n_steps",
"=",
"tt",
".",
"iscal... | computes a theano function that computes one leapfrog step and the energy at the end of the trajectory . | train | false |
7,615 | def port_standard(standard_annotations, sel, sample, extractors):
new_annotations = []
for annotation in standard_annotations:
if (not annotation.get('tagid')):
continue
element = find_element(annotation, sel)
if (element is None):
continue
selector = find_generalized_css_selector(element, sel)
if (not selector):
continue
annotation['accept_selectors'] = [selector]
annotation['selector'] = selector
annotation['reject_selectors'] = []
annotation = _add_annotation_data(annotation, sample, extractors)
for (_id, data) in annotation.get('data', {}).items():
a = copy.deepcopy(annotation)
a['id'] = gen_predictable_id(_id, a['id'])
a['data'] = {gen_predictable_id(a['id'], 1): data}
new_annotations.append(a)
return new_annotations
| [
"def",
"port_standard",
"(",
"standard_annotations",
",",
"sel",
",",
"sample",
",",
"extractors",
")",
":",
"new_annotations",
"=",
"[",
"]",
"for",
"annotation",
"in",
"standard_annotations",
":",
"if",
"(",
"not",
"annotation",
".",
"get",
"(",
"'tagid'",
... | add accept selectors for existing annotations . | train | false |
7,622 | def set_vif_bandwidth_config(conf, inst_type):
bandwidth_items = ['vif_inbound_average', 'vif_inbound_peak', 'vif_inbound_burst', 'vif_outbound_average', 'vif_outbound_peak', 'vif_outbound_burst']
for (key, value) in inst_type.get('extra_specs', {}).items():
scope = key.split(':')
if ((len(scope) > 1) and (scope[0] == 'quota')):
if (scope[1] in bandwidth_items):
setattr(conf, scope[1], value)
| [
"def",
"set_vif_bandwidth_config",
"(",
"conf",
",",
"inst_type",
")",
":",
"bandwidth_items",
"=",
"[",
"'vif_inbound_average'",
",",
"'vif_inbound_peak'",
",",
"'vif_inbound_burst'",
",",
"'vif_outbound_average'",
",",
"'vif_outbound_peak'",
",",
"'vif_outbound_burst'",
... | config vif inbound/outbound bandwidth limit . | train | false |
7,624 | def generate_oauth_authorization_url(token, next=None, hd=DEFAULT_DOMAIN, hl=None, btmpl=None, auth_server=OAUTH_AUTHORIZE_URL):
uri = atom.http_core.Uri.parse_uri(auth_server)
uri.query['oauth_token'] = token
uri.query['hd'] = hd
if (next is not None):
uri.query['oauth_callback'] = str(next)
if (hl is not None):
uri.query['hl'] = hl
if (btmpl is not None):
uri.query['btmpl'] = btmpl
return uri
| [
"def",
"generate_oauth_authorization_url",
"(",
"token",
",",
"next",
"=",
"None",
",",
"hd",
"=",
"DEFAULT_DOMAIN",
",",
"hl",
"=",
"None",
",",
"btmpl",
"=",
"None",
",",
"auth_server",
"=",
"OAUTH_AUTHORIZE_URL",
")",
":",
"uri",
"=",
"atom",
".",
"http... | creates a url for the page where the request token can be authorized . | train | false |
7,626 | def disk_partition_usage(all=False):
result = disk_partitions(all)
for partition in result:
partition.update(disk_usage(partition['mountpoint']))
return result
| [
"def",
"disk_partition_usage",
"(",
"all",
"=",
"False",
")",
":",
"result",
"=",
"disk_partitions",
"(",
"all",
")",
"for",
"partition",
"in",
"result",
":",
"partition",
".",
"update",
"(",
"disk_usage",
"(",
"partition",
"[",
"'mountpoint'",
"]",
")",
"... | return a list of disk partitions plus the mount point . | train | true |
7,628 | @local_optimizer([GpuSparseBlockOuter], inplace=True)
def local_inplace_gpu_sparse_block_outer(node):
if (isinstance(node.op, GpuSparseBlockOuter) and (not node.op.inplace)):
new_node = gpu_sparse_block_outer_inplace(*node.inputs)
return [new_node]
return False
| [
"@",
"local_optimizer",
"(",
"[",
"GpuSparseBlockOuter",
"]",
",",
"inplace",
"=",
"True",
")",
"def",
"local_inplace_gpu_sparse_block_outer",
"(",
"node",
")",
":",
"if",
"(",
"isinstance",
"(",
"node",
".",
"op",
",",
"GpuSparseBlockOuter",
")",
"and",
"(",
... | gpusparseblockouter -> gpusparseblockouter . | train | false |
7,629 | def setCacheCapacity(capacity=DEFAULT_CACHE_CAPACITY):
enableCache()
_entityCache.setCapacity(capacity)
| [
"def",
"setCacheCapacity",
"(",
"capacity",
"=",
"DEFAULT_CACHE_CAPACITY",
")",
":",
"enableCache",
"(",
")",
"_entityCache",
".",
"setCapacity",
"(",
"capacity",
")"
] | set the capacity of the entity cache . | train | false |
7,631 | def parse_grid_id_args(grid, grid_url):
if (grid is not None):
id_from_grid = grid.id
else:
id_from_grid = None
args = [id_from_grid, grid_url]
arg_names = ('grid', 'grid_url')
supplied_arg_names = [arg_name for (arg_name, arg) in zip(arg_names, args) if (arg is not None)]
if (not supplied_arg_names):
raise exceptions.InputError("One of the two keyword arguments is required:\n `grid` or `grid_url`\n\ngrid: a plotly.graph_objs.Grid object that has already\n been uploaded to Plotly.\n\ngrid_url: the url where the grid can be accessed on\n Plotly, e.g. 'https://plot.ly/~chris/3043'\n\n")
elif (len(supplied_arg_names) > 1):
raise exceptions.InputError('Only one of `grid` or `grid_url` is required. \nYou supplied both. \n')
else:
supplied_arg_name = supplied_arg_names.pop()
if (supplied_arg_name == 'grid_url'):
path = six.moves.urllib.parse.urlparse(grid_url).path
(file_owner, file_id) = path.replace('/~', '').split('/')[0:2]
return '{0}:{1}'.format(file_owner, file_id)
else:
return grid.id
| [
"def",
"parse_grid_id_args",
"(",
"grid",
",",
"grid_url",
")",
":",
"if",
"(",
"grid",
"is",
"not",
"None",
")",
":",
"id_from_grid",
"=",
"grid",
".",
"id",
"else",
":",
"id_from_grid",
"=",
"None",
"args",
"=",
"[",
"id_from_grid",
",",
"grid_url",
... | return the grid_id from the non-none input argument . | train | false |
7,633 | @pytest.mark.parametrize('console_scripts', ['test_ = distutils_install', 'test_:test_ = distutils_install'])
def test_uninstall_entry_point(script, console_scripts):
pkg_name = 'ep_install'
pkg_path = create_test_package_with_setup(script, name=pkg_name, version='0.1', entry_points={'console_scripts': [console_scripts], 'pip_test.ep': ['ep:name1 = distutils_install', 'ep:name2 = distutils_install']})
script_name = script.bin_path.join(console_scripts.split('=')[0].strip())
result = script.pip('install', pkg_path)
assert script_name.exists
result = script.pip('list', '--format=legacy')
assert ('ep-install (0.1)' in result.stdout)
script.pip('uninstall', 'ep_install', '-y')
assert (not script_name.exists)
result2 = script.pip('list', '--format=legacy')
assert ('ep-install (0.1)' not in result2.stdout)
| [
"@",
"pytest",
".",
"mark",
".",
"parametrize",
"(",
"'console_scripts'",
",",
"[",
"'test_ = distutils_install'",
",",
"'test_:test_ = distutils_install'",
"]",
")",
"def",
"test_uninstall_entry_point",
"(",
"script",
",",
"console_scripts",
")",
":",
"pkg_name",
"="... | test uninstall package with two or more entry points in the same section . | train | false |
7,635 | def repeat_last_axis(array, count):
return as_strided(array, (array.shape + (count,)), (array.strides + (0,)))
| [
"def",
"repeat_last_axis",
"(",
"array",
",",
"count",
")",
":",
"return",
"as_strided",
"(",
"array",
",",
"(",
"array",
".",
"shape",
"+",
"(",
"count",
",",
")",
")",
",",
"(",
"array",
".",
"strides",
"+",
"(",
"0",
",",
")",
")",
")"
] | restride array to repeat count times along the last axis . | train | true |
7,637 | def get_language_name(lang_code, native=None, error_on_missing=False):
lang_code = lcode_to_ietf(lang_code)
language_entry = get_code2lang_map(lang_code)
if (not language_entry):
if error_on_missing:
raise LanguageNotFoundError(("We don't have language code '%s' saved in our lookup dictionary (location: %s). Please manually add it before re-running this command." % (lang_code, settings.LANG_LOOKUP_FILEPATH)))
else:
language_entry = {'name': lang_code, 'native_name': lang_code}
if (not isinstance(language_entry, dict)):
return language_entry
elif (native is None):
return (language_entry.get('native_name') or language_entry.get('ka_name') or language_entry.get('name'))
elif (not native):
return language_entry.get('name')
else:
return language_entry.get('native_name')
| [
"def",
"get_language_name",
"(",
"lang_code",
",",
"native",
"=",
"None",
",",
"error_on_missing",
"=",
"False",
")",
":",
"lang_code",
"=",
"lcode_to_ietf",
"(",
"lang_code",
")",
"language_entry",
"=",
"get_code2lang_map",
"(",
"lang_code",
")",
"if",
"(",
"... | get a languages name in the currently active locale . | train | false |
7,638 | def get_suggestions(request, user, project_ids):
base = Translation.objects.prefetch().filter(subproject__project_id__in=project_ids).exclude(total=F('translated')).order_by('-translated')
all_matching = base.none()
if (user.is_authenticated() and user.profile.languages.exists()):
all_matching = base.filter(language__in=user.profile.languages.all()).exclude(subproject__project__in=user.profile.subscriptions.all())
else:
session_lang = translation.get_language()
if (session_lang and (session_lang != 'en')):
all_matching = base.filter(language__code=session_lang)
if (not all_matching):
all_matching = base.exclude(language__code='en')
return all_matching[:10]
| [
"def",
"get_suggestions",
"(",
"request",
",",
"user",
",",
"project_ids",
")",
":",
"base",
"=",
"Translation",
".",
"objects",
".",
"prefetch",
"(",
")",
".",
"filter",
"(",
"subproject__project_id__in",
"=",
"project_ids",
")",
".",
"exclude",
"(",
"total... | filter a list of folders with a given search path . | train | false |
7,639 | def get_dir_time_suffix():
dirfmt = '%4d-%02d-%02d_%02d%02d%02d'
now = time.localtime()[0:6]
dirname = (dirfmt % now)
return dirname
| [
"def",
"get_dir_time_suffix",
"(",
")",
":",
"dirfmt",
"=",
"'%4d-%02d-%02d_%02d%02d%02d'",
"now",
"=",
"time",
".",
"localtime",
"(",
")",
"[",
"0",
":",
"6",
"]",
"dirname",
"=",
"(",
"dirfmt",
"%",
"now",
")",
"return",
"dirname"
] | returns the name of a folder with the now time as suffix . | train | false |
7,640 | @event(u'manager.before_config_validate')
def process_variables(config, manager):
env_params = {u'block_start_string': u'^^disabled^^', u'block_end_string': u'^^disabled^^', u'variable_start_string': u'{?', u'variable_end_string': u'?}'}
if ((u'variables' not in config) or (config.get(u'variables') is False)):
return
env = Environment(**env_params)
if isinstance(config[u'variables'], bool):
log.debug(u'trying to load variables from DB')
variables = variables_from_db()
else:
log.debug(u'trying to load variables from file')
variables = variables_from_file(manager.config_base, config[u'variables'])
log.debug(u'updating DB with variable file contents')
variables_to_db(variables)
env.globals = variables
_process(config, env)
return config
| [
"@",
"event",
"(",
"u'manager.before_config_validate'",
")",
"def",
"process_variables",
"(",
"config",
",",
"manager",
")",
":",
"env_params",
"=",
"{",
"u'block_start_string'",
":",
"u'^^disabled^^'",
",",
"u'block_end_string'",
":",
"u'^^disabled^^'",
",",
"u'varia... | render all string elements of the config against defined variables . | train | false |
7,642 | def drop_missing(Y, X=None, axis=1):
Y = np.asarray(Y)
if (Y.ndim == 1):
Y = Y[:, None]
if (X is not None):
X = np.array(X)
if (X.ndim == 1):
X = X[:, None]
keepidx = np.logical_and((~ np.isnan(Y).any(axis)), (~ np.isnan(X).any(axis)))
return (Y[keepidx], X[keepidx])
else:
keepidx = (~ np.isnan(Y).any(axis))
return Y[keepidx]
| [
"def",
"drop_missing",
"(",
"Y",
",",
"X",
"=",
"None",
",",
"axis",
"=",
"1",
")",
":",
"Y",
"=",
"np",
".",
"asarray",
"(",
"Y",
")",
"if",
"(",
"Y",
".",
"ndim",
"==",
"1",
")",
":",
"Y",
"=",
"Y",
"[",
":",
",",
"None",
"]",
"if",
"... | returns views on the arrays y and x where missing observations are dropped . | train | false |
7,644 | def _diff_replication_group(current, desired):
if (current.get('AutomaticFailover') is not None):
current['AutomaticFailoverEnabled'] = (True if (current['AutomaticFailover'] in ('enabled', 'enabling')) else False)
modifiable = {'AutomaticFailoverEnabled': 'AutomaticFailoverEnabled', 'AutoMinorVersionUpgrade': None, 'CacheNodeType': None, 'CacheParameterGroupName': None, 'CacheSecurityGroupNames': None, 'EngineVersion': None, 'NotificationTopicArn': None, 'NotificationTopicStatus': None, 'PreferredMaintenanceWindow': None, 'PrimaryClusterId': None, 'ReplicationGroupDescription': 'Description', 'SecurityGroupIds': None, 'SnapshotRetentionLimit': 'SnapshotRetentionLimit', 'SnapshottingClusterId': 'SnapshottingClusterId', 'SnapshotWindow': 'SnapshotWindow'}
need_update = {}
for (m, o) in modifiable.items():
if (m in desired):
if (not o):
need_update[m] = desired[m]
elif (m in current):
if (current[m] != desired[m]):
need_update[m] = desired[m]
return need_update
| [
"def",
"_diff_replication_group",
"(",
"current",
",",
"desired",
")",
":",
"if",
"(",
"current",
".",
"get",
"(",
"'AutomaticFailover'",
")",
"is",
"not",
"None",
")",
":",
"current",
"[",
"'AutomaticFailoverEnabled'",
"]",
"=",
"(",
"True",
"if",
"(",
"c... | if you need to enhance what modify_replication_group() considers when deciding what is to be updated . | train | true |
7,645 | def service_present(name, service_type, description=None, profile=None, **connection_args):
ret = {'name': name, 'changes': {}, 'result': True, 'comment': 'Service "{0}" already exists'.format(name)}
role = __salt__['keystone.service_get'](name=name, profile=profile, **connection_args)
if ('Error' not in role):
return ret
else:
if __opts__.get('test'):
ret['result'] = None
ret['comment'] = 'Service "{0}" will be added'.format(name)
return ret
__salt__['keystone.service_create'](name, service_type, description, profile=profile, **connection_args)
ret['comment'] = 'Service "{0}" has been added'.format(name)
ret['changes']['Service'] = 'Created'
return ret
| [
"def",
"service_present",
"(",
"name",
",",
"service_type",
",",
"description",
"=",
"None",
",",
"profile",
"=",
"None",
",",
"**",
"connection_args",
")",
":",
"ret",
"=",
"{",
"'name'",
":",
"name",
",",
"'changes'",
":",
"{",
"}",
",",
"'result'",
... | ensure service present in keystone catalog name the name of the service service_type the type of openstack service description description of the service . | train | true |
7,646 | def strip_quotes(table_name):
has_quotes = (table_name.startswith('"') and table_name.endswith('"'))
return (table_name[1:(-1)] if has_quotes else table_name)
| [
"def",
"strip_quotes",
"(",
"table_name",
")",
":",
"has_quotes",
"=",
"(",
"table_name",
".",
"startswith",
"(",
"'\"'",
")",
"and",
"table_name",
".",
"endswith",
"(",
"'\"'",
")",
")",
"return",
"(",
"table_name",
"[",
"1",
":",
"(",
"-",
"1",
")",
... | strip quotes of doctests output values: . | train | false |
7,647 | def notify_errors(request_id, error):
try:
_REQUESTS[request_id].notify_errors(request_id, error)
except KeyError:
pass
| [
"def",
"notify_errors",
"(",
"request_id",
",",
"error",
")",
":",
"try",
":",
"_REQUESTS",
"[",
"request_id",
"]",
".",
"notify_errors",
"(",
"request_id",
",",
"error",
")",
"except",
"KeyError",
":",
"pass"
] | add errors to a config request . | train | false |
7,650 | @skip_if_on_windows
@pytest.mark.parametrize('cmd, fmt, exp', [('pwd', None, (lambda : (os.getcwd() + '\n'))), ('echo WORKING', None, 'WORKING\n'), ('ls -f', (lambda out: out.splitlines().sort()), os.listdir().sort())])
def test_single_command(cmd, fmt, exp):
(out, err, rtn) = run_xonsh(cmd, stderr=sp.DEVNULL)
if callable(fmt):
out = fmt(out)
if callable(exp):
exp = exp()
assert (out == exp)
assert (rtn == 0)
| [
"@",
"skip_if_on_windows",
"@",
"pytest",
".",
"mark",
".",
"parametrize",
"(",
"'cmd, fmt, exp'",
",",
"[",
"(",
"'pwd'",
",",
"None",
",",
"(",
"lambda",
":",
"(",
"os",
".",
"getcwd",
"(",
")",
"+",
"'\\n'",
")",
")",
")",
",",
"(",
"'echo WORKING... | the fmt parameter is a function that formats the output of cmd . | train | false |
7,652 | def _load_provider_feature(feature, providers):
features = []
for provider in providers:
mod = __import__(provider, fromlist=[feature])
features = getattr(mod, feature)(features)
return features
| [
"def",
"_load_provider_feature",
"(",
"feature",
",",
"providers",
")",
":",
"features",
"=",
"[",
"]",
"for",
"provider",
"in",
"providers",
":",
"mod",
"=",
"__import__",
"(",
"provider",
",",
"fromlist",
"=",
"[",
"feature",
"]",
")",
"features",
"=",
... | load the named feature from an ordered list of dotted-notation modules which each implements the feature . | train | false |
7,653 | @utils.arg('backup', metavar='<backup>', help='ID of the backup.')
@utils.service_type('monitor')
def do_backup_show(cs, args):
backup = _find_backup(cs, args.backup)
info = dict()
info.update(backup._info)
if ('links' in info):
info.pop('links')
utils.print_dict(info)
| [
"@",
"utils",
".",
"arg",
"(",
"'backup'",
",",
"metavar",
"=",
"'<backup>'",
",",
"help",
"=",
"'ID of the backup.'",
")",
"@",
"utils",
".",
"service_type",
"(",
"'monitor'",
")",
"def",
"do_backup_show",
"(",
"cs",
",",
"args",
")",
":",
"backup",
"="... | show details about a backup . | train | false |
7,654 | def _load_encryption(proxy_conf_file, **kwargs):
_debug('Setting configuration for encryption')
conf = ConfigParser()
conf.read(proxy_conf_file)
try:
section = 'pipeline:main'
pipeline = conf.get(section, 'pipeline')
pipeline = pipeline.replace('proxy-logging proxy-server', 'keymaster encryption proxy-logging proxy-server')
conf.set(section, 'pipeline', pipeline)
root_secret = os.urandom(32).encode('base64')
conf.set('filter:keymaster', 'encryption_root_secret', root_secret)
except NoSectionError as err:
msg = ('Error problem with proxy conf file %s: %s' % (proxy_conf_file, err))
raise InProcessException(msg)
test_conf_file = os.path.join(_testdir, 'proxy-server.conf')
with open(test_conf_file, 'w') as fp:
conf.write(fp)
return test_conf_file
| [
"def",
"_load_encryption",
"(",
"proxy_conf_file",
",",
"**",
"kwargs",
")",
":",
"_debug",
"(",
"'Setting configuration for encryption'",
")",
"conf",
"=",
"ConfigParser",
"(",
")",
"conf",
".",
"read",
"(",
"proxy_conf_file",
")",
"try",
":",
"section",
"=",
... | load encryption configuration and override proxy-server . | train | false |
7,656 | @task()
@timeit
def measure_queue_lag(queued_time):
lag = (datetime.now() - queued_time)
lag = (((lag.days * 3600) * 24) + lag.seconds)
statsd.gauge('rabbitmq.lag', max(lag, 0))
| [
"@",
"task",
"(",
")",
"@",
"timeit",
"def",
"measure_queue_lag",
"(",
"queued_time",
")",
":",
"lag",
"=",
"(",
"datetime",
".",
"now",
"(",
")",
"-",
"queued_time",
")",
"lag",
"=",
"(",
"(",
"(",
"lag",
".",
"days",
"*",
"3600",
")",
"*",
"24"... | a task that measures the time it was sitting in the queue . | train | false |
7,657 | @task
@needs('pavelib.i18n.i18n_validate_transifex_config', 'pavelib.i18n.i18n_generate')
@timed
def i18n_release_push():
resources = find_release_resources()
sh(('i18n_tool transifex push ' + ' '.join(resources)))
| [
"@",
"task",
"@",
"needs",
"(",
"'pavelib.i18n.i18n_validate_transifex_config'",
",",
"'pavelib.i18n.i18n_generate'",
")",
"@",
"timed",
"def",
"i18n_release_push",
"(",
")",
":",
"resources",
"=",
"find_release_resources",
"(",
")",
"sh",
"(",
"(",
"'i18n_tool transi... | push release-specific resources to transifex . | train | false |
7,658 | def yearly_activity(request, project=None, subproject=None, lang=None, user=None):
activity = get_json_stats(request, 364, 7, project, subproject, lang, user)
serie = []
labels = []
month = (-1)
for item in activity:
serie.append(item[1])
if (month != item[0].month):
labels.append(pgettext('Format string for yearly activity chart', '{month}/{year}').format(month=item[0].month, year=item[0].year))
month = item[0].month
else:
labels.append('')
return JsonResponse(data={'series': [serie], 'labels': labels})
| [
"def",
"yearly_activity",
"(",
"request",
",",
"project",
"=",
"None",
",",
"subproject",
"=",
"None",
",",
"lang",
"=",
"None",
",",
"user",
"=",
"None",
")",
":",
"activity",
"=",
"get_json_stats",
"(",
"request",
",",
"364",
",",
"7",
",",
"project"... | returns yearly activity for matching changes as json . | train | false |
7,659 | def projective_transform_by_points(x, src, dst, map_args={}, output_shape=None, order=1, mode='constant', cval=0.0, clip=True, preserve_range=False):
if (type(src) is list):
src = np.array(src)
if (type(dst) is list):
dst = np.array(dst)
if (np.max(x) > 1):
x = (x / 255)
m = transform.ProjectiveTransform()
m.estimate(dst, src)
warped = transform.warp(x, m, map_args=map_args, output_shape=output_shape, order=order, mode=mode, cval=cval, clip=clip, preserve_range=preserve_range)
return warped
| [
"def",
"projective_transform_by_points",
"(",
"x",
",",
"src",
",",
"dst",
",",
"map_args",
"=",
"{",
"}",
",",
"output_shape",
"=",
"None",
",",
"order",
"=",
"1",
",",
"mode",
"=",
"'constant'",
",",
"cval",
"=",
"0.0",
",",
"clip",
"=",
"True",
",... | projective transform by given coordinates . | train | true |
7,661 | def _allmsgs(obj):
if isinstance(obj, MultiMessage):
return obj.messages
elif (obj == BUBBLE):
return []
else:
return [obj]
| [
"def",
"_allmsgs",
"(",
"obj",
")",
":",
"if",
"isinstance",
"(",
"obj",
",",
"MultiMessage",
")",
":",
"return",
"obj",
".",
"messages",
"elif",
"(",
"obj",
"==",
"BUBBLE",
")",
":",
"return",
"[",
"]",
"else",
":",
"return",
"[",
"obj",
"]"
] | returns a list of all the messages encapsulated in obj . | train | false |
7,662 | def safechardecode(value, binary=False):
retVal = value
if isinstance(value, basestring):
retVal = retVal.replace('\\\\', SLASH_MARKER)
while True:
match = re.search(HEX_ENCODED_CHAR_REGEX, retVal)
if match:
retVal = retVal.replace(match.group('result'), (unichr if isinstance(value, unicode) else chr)(ord(binascii.unhexlify(match.group('result').lstrip('\\x')))))
else:
break
for char in SAFE_ENCODE_SLASH_REPLACEMENTS[::(-1)]:
retVal = retVal.replace(repr(char).strip("'"), char)
retVal = retVal.replace(SLASH_MARKER, '\\')
if binary:
if isinstance(retVal, unicode):
retVal = retVal.encode('utf8')
while True:
match = re.search(INVALID_UNICODE_CHAR_REGEX, retVal)
if match:
retVal = retVal.replace(match.group('result'), chr(ord(binascii.unhexlify(match.group('result').lstrip('\\?')))))
else:
break
elif isinstance(value, (list, tuple)):
for i in xrange(len(value)):
retVal[i] = safechardecode(value[i])
return retVal
| [
"def",
"safechardecode",
"(",
"value",
",",
"binary",
"=",
"False",
")",
":",
"retVal",
"=",
"value",
"if",
"isinstance",
"(",
"value",
",",
"basestring",
")",
":",
"retVal",
"=",
"retVal",
".",
"replace",
"(",
"'\\\\\\\\'",
",",
"SLASH_MARKER",
")",
"wh... | reverse function to safecharencode . | train | false |
7,663 | def xtext_decode(s, errors=None):
r = []
i = 0
while (i < len(s)):
if (s[i] == '+'):
try:
r.append(chr(int(s[(i + 1):(i + 3)], 16)))
except ValueError:
r.append(s[i:(i + 3)])
i += 3
else:
r.append(s[i])
i += 1
return (''.join(r), len(s))
| [
"def",
"xtext_decode",
"(",
"s",
",",
"errors",
"=",
"None",
")",
":",
"r",
"=",
"[",
"]",
"i",
"=",
"0",
"while",
"(",
"i",
"<",
"len",
"(",
"s",
")",
")",
":",
"if",
"(",
"s",
"[",
"i",
"]",
"==",
"'+'",
")",
":",
"try",
":",
"r",
"."... | decode the xtext-encoded string c{s} . | train | false |
7,664 | def view_config_changes(config, num=None):
rev = reverter.Reverter(config)
rev.recovery_routine()
rev.view_config_changes(num)
| [
"def",
"view_config_changes",
"(",
"config",
",",
"num",
"=",
"None",
")",
":",
"rev",
"=",
"reverter",
".",
"Reverter",
"(",
"config",
")",
"rev",
".",
"recovery_routine",
"(",
")",
"rev",
".",
"view_config_changes",
"(",
"num",
")"
] | view checkpoints and associated configuration changes . | train | false |
7,665 | def translate_jobconf(variable, version):
if (version is None):
raise TypeError
if (variable in _JOBCONF_MAP):
return map_version(version, _JOBCONF_MAP[variable])
else:
return variable
| [
"def",
"translate_jobconf",
"(",
"variable",
",",
"version",
")",
":",
"if",
"(",
"version",
"is",
"None",
")",
":",
"raise",
"TypeError",
"if",
"(",
"variable",
"in",
"_JOBCONF_MAP",
")",
":",
"return",
"map_version",
"(",
"version",
",",
"_JOBCONF_MAP",
... | translate *variable* to hadoop version *version* . | train | false |
7,666 | def get_qos(tenant_id, qos_id):
LOG.debug(_('get_qos() called'))
session = db.get_session()
try:
qos = session.query(l2network_models.QoS).filter_by(tenant_id=tenant_id).filter_by(qos_id=qos_id).one()
return qos
except exc.NoResultFound:
raise c_exc.QosNotFound(qos_id=qos_id, tenant_id=tenant_id)
| [
"def",
"get_qos",
"(",
"tenant_id",
",",
"qos_id",
")",
":",
"LOG",
".",
"debug",
"(",
"_",
"(",
"'get_qos() called'",
")",
")",
"session",
"=",
"db",
".",
"get_session",
"(",
")",
"try",
":",
"qos",
"=",
"session",
".",
"query",
"(",
"l2network_models... | lists the qos given a tenant_id and qos_id . | train | false |
7,667 | def l(path):
if (path and path.startswith('/')):
base_url = getattr(settings, 'SCRIPT_NAME', '')
return (base_url + path)
return path
| [
"def",
"l",
"(",
"path",
")",
":",
"if",
"(",
"path",
"and",
"path",
".",
"startswith",
"(",
"'/'",
")",
")",
":",
"base_url",
"=",
"getattr",
"(",
"settings",
",",
"'SCRIPT_NAME'",
",",
"''",
")",
"return",
"(",
"base_url",
"+",
"path",
")",
"retu... | filter urls adding base_path prefix if required . | train | false |
7,668 | def strip_formatted_string(str):
return re.sub('\\s\\s+', ' ', str).strip()
| [
"def",
"strip_formatted_string",
"(",
"str",
")",
":",
"return",
"re",
".",
"sub",
"(",
"'\\\\s\\\\s+'",
",",
"' '",
",",
"str",
")",
".",
"strip",
"(",
")"
] | remove multiple whitespaces and whitespaces at the beginning and end of the given string . | train | false |
7,669 | @conf.commands.register
def fragment(pkt, fragsize=1480):
fragsize = (((fragsize + 7) / 8) * 8)
lst = []
for p in pkt:
s = str(p[IP].payload)
nb = (((len(s) + fragsize) - 1) / fragsize)
for i in range(nb):
q = p.copy()
del q[IP].payload
del q[IP].chksum
del q[IP].len
if (i == (nb - 1)):
q[IP].flags &= (~ 1)
else:
q[IP].flags |= 1
q[IP].frag = ((i * fragsize) / 8)
r = Raw(load=s[(i * fragsize):((i + 1) * fragsize)])
r.overload_fields = p[IP].payload.overload_fields.copy()
q.add_payload(r)
lst.append(q)
return lst
| [
"@",
"conf",
".",
"commands",
".",
"register",
"def",
"fragment",
"(",
"pkt",
",",
"fragsize",
"=",
"1480",
")",
":",
"fragsize",
"=",
"(",
"(",
"(",
"fragsize",
"+",
"7",
")",
"/",
"8",
")",
"*",
"8",
")",
"lst",
"=",
"[",
"]",
"for",
"p",
"... | appends the given content to the fragment . | train | false |
7,670 | def _common_bytes(blocks1, blocks2):
if (len(blocks1) > len(blocks2)):
(blocks1, blocks2) = (blocks2, blocks1)
score = 0
for (block, count1) in blocks1.items():
count2 = blocks2.get(block)
if count2:
score += min(count1, count2)
return score
| [
"def",
"_common_bytes",
"(",
"blocks1",
",",
"blocks2",
")",
":",
"if",
"(",
"len",
"(",
"blocks1",
")",
">",
"len",
"(",
"blocks2",
")",
")",
":",
"(",
"blocks1",
",",
"blocks2",
")",
"=",
"(",
"blocks2",
",",
"blocks1",
")",
"score",
"=",
"0",
... | count the number of common bytes in two block count dicts . | train | false |
7,671 | def _get_image_properties(image):
(immin, immax) = (np.min(image), np.max(image))
imtype = image.dtype.type
try:
(lo, hi) = dtypes.dtype_range[imtype]
except KeyError:
(lo, hi) = (immin, immax)
signed = (immin < 0)
out_of_range_float = (np.issubdtype(image.dtype, np.float) and ((immin < lo) or (immax > hi)))
low_data_range = ((immin != immax) and is_low_contrast(image))
unsupported_dtype = (image.dtype not in dtypes._supported_types)
return ImageProperties(signed, out_of_range_float, low_data_range, unsupported_dtype)
| [
"def",
"_get_image_properties",
"(",
"image",
")",
":",
"(",
"immin",
",",
"immax",
")",
"=",
"(",
"np",
".",
"min",
"(",
"image",
")",
",",
"np",
".",
"max",
"(",
"image",
")",
")",
"imtype",
"=",
"image",
".",
"dtype",
".",
"type",
"try",
":",
... | determine nonstandard properties of an input image . | train | false |
7,672 | def contracted_nodes(G, u, v, self_loops=True):
H = G.copy()
if H.is_directed():
in_edges = ((w, u, d) for (w, x, d) in G.in_edges(v, data=True) if (self_loops or (w != u)))
out_edges = ((u, w, d) for (x, w, d) in G.out_edges(v, data=True) if (self_loops or (w != u)))
new_edges = chain(in_edges, out_edges)
else:
new_edges = ((u, w, d) for (x, w, d) in G.edges(v, data=True) if (self_loops or (w != u)))
v_data = H.node[v]
H.remove_node(v)
H.add_edges_from(new_edges)
if ('contraction' in H.node[u]):
H.node[u]['contraction'][v] = v_data
else:
H.node[u]['contraction'] = {v: v_data}
return H
| [
"def",
"contracted_nodes",
"(",
"G",
",",
"u",
",",
"v",
",",
"self_loops",
"=",
"True",
")",
":",
"H",
"=",
"G",
".",
"copy",
"(",
")",
"if",
"H",
".",
"is_directed",
"(",
")",
":",
"in_edges",
"=",
"(",
"(",
"w",
",",
"u",
",",
"d",
")",
... | returns the graph that results from contracting u and v . | train | false |
7,676 | def _dep_eeg_ref(add_eeg_ref):
add_eeg_ref = bool(add_eeg_ref)
if add_eeg_ref:
warn('add_eeg_ref will be removed in 0.15, use set_eeg_reference() instead', DeprecationWarning)
return add_eeg_ref
| [
"def",
"_dep_eeg_ref",
"(",
"add_eeg_ref",
")",
":",
"add_eeg_ref",
"=",
"bool",
"(",
"add_eeg_ref",
")",
"if",
"add_eeg_ref",
":",
"warn",
"(",
"'add_eeg_ref will be removed in 0.15, use set_eeg_reference() instead'",
",",
"DeprecationWarning",
")",
"return",
"add_eeg_re... | helper for deprecation add_eeg_ref -> false . | train | false |
7,677 | @with_setup(prepare_stdout)
def test_commented_scenario():
runner = Runner(feature_name('commented_feature'), verbosity=1)
runner.run()
assert_stdout_lines('.\n1 feature (1 passed)\n1 scenario (1 passed)\n1 step (1 passed)\n')
| [
"@",
"with_setup",
"(",
"prepare_stdout",
")",
"def",
"test_commented_scenario",
"(",
")",
":",
"runner",
"=",
"Runner",
"(",
"feature_name",
"(",
"'commented_feature'",
")",
",",
"verbosity",
"=",
"1",
")",
"runner",
".",
"run",
"(",
")",
"assert_stdout_lines... | test one commented scenario . | train | false |
7,678 | def parse_host_port(address, default_port=None):
if (address[0] == '['):
(_host, _port) = address[1:].split(']')
host = _host
if (':' in _port):
port = _port.split(':')[1]
else:
port = default_port
elif (address.count(':') == 1):
(host, port) = address.split(':')
else:
host = address
port = default_port
return (host, (None if (port is None) else int(port)))
| [
"def",
"parse_host_port",
"(",
"address",
",",
"default_port",
"=",
"None",
")",
":",
"if",
"(",
"address",
"[",
"0",
"]",
"==",
"'['",
")",
":",
"(",
"_host",
",",
"_port",
")",
"=",
"address",
"[",
"1",
":",
"]",
".",
"split",
"(",
"']'",
")",
... | interpret a string as a host:port pair . | train | false |
7,679 | @register.inclusion_tag('utilities/render_custom_fields.html')
def render_custom_fields(form):
return {'form': form}
| [
"@",
"register",
".",
"inclusion_tag",
"(",
"'utilities/render_custom_fields.html'",
")",
"def",
"render_custom_fields",
"(",
"form",
")",
":",
"return",
"{",
"'form'",
":",
"form",
"}"
] | render all custom fields in a form . | train | false |
7,680 | def axapi_enabled_disabled(flag):
if (flag == 'enabled'):
return 1
else:
return 0
| [
"def",
"axapi_enabled_disabled",
"(",
"flag",
")",
":",
"if",
"(",
"flag",
"==",
"'enabled'",
")",
":",
"return",
"1",
"else",
":",
"return",
"0"
] | the axapi uses 0/1 integer values for flags . | train | false |
7,681 | def processtime():
(user, system) = systimes()
return (user + system)
| [
"def",
"processtime",
"(",
")",
":",
"(",
"user",
",",
"system",
")",
"=",
"systimes",
"(",
")",
"return",
"(",
"user",
"+",
"system",
")"
] | return the total time spent on the process . | train | false |
7,682 | def RetryWithBackoff(callable_func, retry_notify_func, initial_delay=1, backoff_factor=2, max_delay=60, max_tries=20):
delay = initial_delay
num_tries = 0
while True:
(done, opaque_value) = callable_func()
num_tries += 1
if done:
return (True, opaque_value)
if (num_tries >= max_tries):
return (False, opaque_value)
retry_notify_func(opaque_value, delay)
time.sleep(delay)
delay = min((delay * backoff_factor), max_delay)
| [
"def",
"RetryWithBackoff",
"(",
"callable_func",
",",
"retry_notify_func",
",",
"initial_delay",
"=",
"1",
",",
"backoff_factor",
"=",
"2",
",",
"max_delay",
"=",
"60",
",",
"max_tries",
"=",
"20",
")",
":",
"delay",
"=",
"initial_delay",
"num_tries",
"=",
"... | calls a function multiple times . | train | false |
7,684 | def _get_source_sum(source_hash, file_path, saltenv):
ret = dict()
schemes = (u'salt', u'http', u'https', u'ftp', u'swift', u's3', u'file')
invalid_hash_msg = u"Source hash '{0}' format is invalid. It must be in the format <hash type>=<hash>".format(source_hash)
source_hash = str(source_hash)
source_hash_scheme = _urlparse(source_hash).scheme
if (source_hash_scheme in schemes):
cached_hash_file = __salt__[u'cp.cache_file'](source_hash, saltenv)
if (not cached_hash_file):
raise CommandExecutionError(u'Source hash file {0} not found'.format(source_hash))
ret = __salt__[u'file.extract_hash'](cached_hash_file, u'', file_path)
if (ret is None):
raise SaltInvocationError(invalid_hash_msg)
else:
items = source_hash.split(u'=', 1)
if (len(items) != 2):
invalid_hash_msg = u'{0}, or it must be a supported protocol: {1}'.format(invalid_hash_msg, u', '.join(schemes))
raise SaltInvocationError(invalid_hash_msg)
(ret[u'hash_type'], ret[u'hsum']) = [item.strip().lower() for item in items]
return ret
| [
"def",
"_get_source_sum",
"(",
"source_hash",
",",
"file_path",
",",
"saltenv",
")",
":",
"ret",
"=",
"dict",
"(",
")",
"schemes",
"=",
"(",
"u'salt'",
",",
"u'http'",
",",
"u'https'",
",",
"u'ftp'",
",",
"u'swift'",
",",
"u's3'",
",",
"u'file'",
")",
... | extract the hash sum . | train | false |
7,685 | def rgb2rgbcie(rgb):
return _convert(rgbcie_from_rgb, rgb)
| [
"def",
"rgb2rgbcie",
"(",
"rgb",
")",
":",
"return",
"_convert",
"(",
"rgbcie_from_rgb",
",",
"rgb",
")"
] | rgb to rgb cie color space conversion . | train | false |
7,686 | def _valid_method_call_check_resources(resource, method):
for name in resource.keys():
_valid_method_call_check_resource(name, method)
| [
"def",
"_valid_method_call_check_resources",
"(",
"resource",
",",
"method",
")",
":",
"for",
"name",
"in",
"resource",
".",
"keys",
"(",
")",
":",
"_valid_method_call_check_resource",
"(",
"name",
",",
"method",
")"
] | a method to check whether the resource can use the quota method . | train | false |
7,689 | def action_peek_xml(body):
dom = utils.safe_minidom_parse_string(body)
action_node = dom.childNodes[0]
return action_node.tagName
| [
"def",
"action_peek_xml",
"(",
"body",
")",
":",
"dom",
"=",
"utils",
".",
"safe_minidom_parse_string",
"(",
"body",
")",
"action_node",
"=",
"dom",
".",
"childNodes",
"[",
"0",
"]",
"return",
"action_node",
".",
"tagName"
] | determine action to invoke . | train | false |
7,690 | def list_firewalls(profile=None):
conn = _auth(profile)
return conn.list_firewalls()
| [
"def",
"list_firewalls",
"(",
"profile",
"=",
"None",
")",
":",
"conn",
"=",
"_auth",
"(",
"profile",
")",
"return",
"conn",
".",
"list_firewalls",
"(",
")"
] | fetches a list of all firewalls for a tenant cli example: . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.