query stringlengths 9 9.05k | document stringlengths 10 222k | negatives listlengths 19 20 | metadata dict |
|---|---|---|---|
Returns a random plush gene given atom_generators and epigeneticmarkers. Returns A random Plush gene from the ``atom_generators``. | def random_plush_gene(self):
atom = random.choice(list(self.atom_generators))
return self.atom_to_plush_gene(atom) | [
"def __generate_random_gene_sequence(self):\n genes = []\n for j in range(self.chromosome_size):\n genes.append(random.choice(self.gene_pool))\n\n return genes",
"def random_gene(size=32, chars='GATC'):\n return ''.join(random.choice(chars) for x in range(size))",
"def generate_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns a random Plush genome with size ``genome_size``. | def random_plush_genome_with_size(self, genome_size):
atoms = rand.choice(list(self.atom_generators), size=genome_size)
return [self.atom_to_plush_gene(atom) for atom in atoms] | [
"def generate_random_genome (size):\n return Genome(\"\".join([str(randint(0, 3)) for i in range(size)]))",
"def random_plush_genome(self, max_genome_size):\n genome_size = random.randint(1, max_genome_size)\n return self.random_plush_genome_with_size(genome_size)",
"def generate_population(sel... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns a random Plush genome with size limited by max_genome_size. | def random_plush_genome(self, max_genome_size):
genome_size = random.randint(1, max_genome_size)
return self.random_plush_genome_with_size(genome_size) | [
"def generate_random_genome (size):\n return Genome(\"\".join([str(randint(0, 3)) for i in range(size)]))",
"def generate_genome(self, max_length: int) -> Genome:\n\t\t\n\t\treturn genome",
"def random_plush_genome_with_size(self, genome_size):\n atoms = rand.choice(list(self.atom_generators), size=ge... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns a random Push expression with size limited by max_points. | def random_push_code(self, max_points):
max_genome_size = max(int(max_points / 2), 1)
genome = self.random_plush_genome(max_genome_size)
return genome_to_program(genome) | [
"def random_plush_genome(self, max_genome_size):\n genome_size = random.randint(1, max_genome_size)\n return self.random_plush_genome_with_size(genome_size)",
"def generate(*args, **kwargs):\n return PushRandom(*args, **kwargs)",
"def gen_n_points(n):\r\n return(np.random.uniform(-1, 3, size... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return the Ground State Energies | def _get_gs_energies(self):
energy = []
for ground_state in self._ground_states:
gs_energy = 0.0
for key in ground_state["eci"].keys():
gs_energy += ground_state["eci"][key] * ground_state["cf"][key]
energy.append(len(ground_state["atoms"]) * gs_energy... | [
"def generate_state_for_ego(self):\n state = np.zeros(17)\n state[0] = 500.\n state[2] = 500.\n state[4] = 500.\n state[6] = 500.\n state[8] = 500.\n state[10] = 500.\n\n lc = self.envdict['lane_count']\n # Left\n if not (self.egovehicle.laneinde... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the integration direction. | def _set_integration_direction(self, T0, Tend):
if Tend is None:
# Use the default which is increasing from 0K
return
if T0 > Tend:
self._integration_direction = "decreasing"
else:
self._integration_direction = "increasing" | [
"def setdirection(self, *args, **kwargs):\n return _coordsys.coordsys_setdirection(self, *args, **kwargs)",
"def setRobotDirection(self, direction):\r\n self.robotDir = direction",
"def direction(self, direction):\n\n self._direction = direction",
"def set_direction(self, new_dir):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns true if we reached the temperature end point. | def _reached_temperature_end_point(self, T, Tend):
if Tend is None:
# End point not give
return False
if self._integration_direction == "increasing":
if T > Tend:
return True
elif self._integration_direction == "decreasing":
if T <... | [
"def at_end(self) -> bool:\n return self.offset >= len(self.input)",
"def is_temp_lte_25(self):\r\n return self.temp <= 25.0",
"def is_done(self) -> bool:\n return True if self.cursor >= len(self.timeseries) - 1 else False",
"def is_temp_gt_25(self):\r\n return self.temp > 25.0",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Stores backup data to hdf5 file | def _backup(self, data, dsetname="data"):
with h5.File(self._backupfile, 'a') as hfile:
grp = hfile.create_group(
dsetname +
"{}".format(
self._current_backup_indx))
for key, value in data.items():
if value is None:
... | [
"def save_as_hdf5(self, filename):",
"def save_h5(fname, keyz, valz):\n with h5py.File(fname, 'w') as hf:\n for key, val in zip(keyz, valz):\n hf.create_dataset(key,\n data=val)",
"def _save_sample_to_h5(filename, idx, vol_data, vol_labels, point... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Check if composition changes too much from one step to another | def _system_changed_phase(self, prev_comp, comp):
return np.abs(prev_comp - comp) > self._max_singlet_change | [
"def check_if_can_evolve(self):\n # This sounds similar to generate actions\n pass",
"def converged(self) -> bool:",
"def violated(self) -> bool:\n ...",
"def _while_progress(self): # for example if learning does not bring improvement return False\n specs = self._specifications\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return array of the singlet terms | def _get_singlet_array(self, thermo):
singlets = []
for entry in thermo:
singlets.append([entry[get_singlet_name(name)]
for name in self._singlet_names])
return singlets | [
"def terms(self):\n return self.keys()",
"def terms(self):\n return list(self._terms)",
"def terms(self):\n return self._terms",
"def get_terms(document):\n q = get_mapped(document)\n tokens = tockenizer(q)\n terms = analizer(tokens)\n\n return terms",
"def terms(self) -> Tu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Check if one of the systems changed phase | def _one_system_changed_phase(self, thermo, ref_values):
singlet_array = self._get_singlet_array(thermo)
for cur_array, ref_array in zip(singlet_array, ref_values):
for cur_val, ref_val in zip(cur_array, ref_array):
if self._system_changed_phase(cur_val, ref_val):
... | [
"def _system_changed_phase(self, prev_comp, comp):\n return np.abs(prev_comp - comp) > self._max_singlet_change",
"def has_state_changed(self) -> bool:\r\n ...",
"def is_provenance_triggered(self):\n return (\n self.params_changed\n or self.code_changed\n or... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks if the predicted and the computed values match | def _prediction_match(self, thermo, ref_values, eps=0.05):
singlet_array = self._get_singlet_array(thermo)
for cur_array, ref_array in zip(singlet_array, ref_values):
for cur_val, ref_val in zip(cur_array, ref_array):
if abs(cur_val - ref_val) > eps:
retur... | [
"def check_prediction(self):\n predicted_scores = self.sess.run(self.NET.output_with_relu, feed_dict={self.NET.input: self.test_image if len(self.test_image.shape)==4 else [self.test_image]})\n self.original_confidence = np.max(predicted_scores)\n if np.argmax(predicted_scores,1) != self.origin... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Initialize the SGC MC objects | def _init_sgc(self, init_temp, symbols):
self._sgc_obj = []
for ground_state in self._ground_states:
self._sgc_obj.append(
SGCMonteCarlo(
ground_state["atoms"],
init_temp,
symbols=symbols)) | [
"def __init__(self):\r\n\r\n self.Helpers = Helpers(\"Movidius\")\r\n self.confs = self.Helpers.confs\r\n\r\n self.classes = []\r\n self.ncsGraph = None\r\n self.ncsDevice = None\r\n self.reqsize = None\r\n\r\n self.mean = 128\r\n self.std = 1 / 128\r\n\r\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Check that the ground_state arguments contain the correct fields | def check_gs_argument(ground_state):
required_fields = ["bc", "cf", "eci", "atoms"]
keys = ground_state.keys()
for key in keys:
if key not in required_fields:
raise ValueError(
"The GS argument has to contain {} keys. Given {}".format(
required_fields,... | [
"def _checkstate(self, state):\n if not type(state) == dict:\n raise TypeError(state)",
"def _check_params(self):\n pass",
"def is_valid(self, state):\n pass",
"def _VerifyArgs(self) -> None:\n assert self._args.target_success_percent > 0\n assert self._args.target_succes... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the singlet name as stored in the thermodictionary | def get_singlet_name(orig_name):
return "singlet_{}".format(orig_name) | [
"def get_name(self):\n return self._get_thermostat_key(\"name\")",
"def speciesName(self,k):\n return _cantera.phase_getstring(self._phase_id,2,k)",
"def get_name(self) -> str:",
"def inlet_name(inlet) -> str:\n name = '_'.join(inlet.info().name().split())\n return name.replace('-', '_')",... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Delete a previously created rolemenu | async def rolemenu_delete(self, interaction: discord.Interaction,
name: str):
doc = await self.db.find_one({
"guild_id": interaction.guild.id,
"name": name
})
if not doc:
return await interaction.response.send_message(
... | [
"def remove_menu(self):\n\n self.logger.debug('Delete menu...')\n pm.deleteUI(self.menu)",
"async def delete_role(bot, role):\n\n role_entry = Role.get(role)\n if role_entry:\n role_entry.delete()",
"def remove_menu(menu_name):\n\n pass",
"async def rolemenu_remove_role(self, int... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Remove a role from a menu | async def rolemenu_remove_role(self, interaction: discord.Interaction,
name: str, role: str):
try:
role_id = int(role)
except ValueError:
return await interaction.response.send_message(
"The role provided "
"is no... | [
"def remove_role(self, role):\n self.roles.pop(role)",
"def remove_menu(menu_name):\n\n pass",
"async def rolemenu_delete(self, interaction: discord.Interaction,\n name: str):\n doc = await self.db.find_one({\n \"guild_id\": interaction.guild.id,\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
to evaluate a postfix expression into a value. Use the postfix_valid function described below to check the validity of the expression | def postfix_eval(postfix_expr):
s = StackArray()
expr = postfix_expr.split()
for token in expr:
if token[0] in '0123456789':
res = token
s.push(res)
else: # token is operator
op2 = s.pop()
op2 = float(op2)
if s.is_empty(): # token i... | [
"def postfix_eval(postfix_expr):\n \n #creating a stack to store operands\n operand_stack = Stack()\n token_list = postfix_expr.split()\n \n for token in token_list:\n if token in '0123456789':\n #pushing the operand to the stack\n operand_stack.push(int(token))\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
To test for an invalid postfix expression. You may assume that what is passed in is a string that only contains numbers and operators. These are separated into valid tokens by spaces so you can use split and join as necessary. | def postfix_valid(postfix_expr):
expr = postfix_expr.split()
count = 0
if postfix_expr == "":
return False
for token in expr:
if token[0] in '0123456789':
count += 1
elif token == '~':
pass
else: # all other binary operators
count -= 1
... | [
"def validate(string):\n \n tokens = string.split()\n \n # Remembers if the previous token was an operator\n opflag = True\n \n ## Highly inefficient validity checking begins here ##\n \n # List of operators as they would appear in the infix expression\n operators = ['+', '-', '*', '/'... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Handles bootstrapping of system restart for exchange resources and broker state. Ensures ExchangePoint and ExchangeSpace resources in system have a properly declared AMQP exchange Ensures ExchangeName resources in system have a properly declared queue Logs all exchanges/queues it didn't understand Purges all service qu... | def on_restart(self, process, config, **kwargs):
ex_manager = process.container.ex_manager
old_use_ems = ex_manager.use_ems
ex_manager.use_ems = False
# get list of queues from broker with full props that have to do with our sysname
all_queues = ex_manager._list_q... | [
"def configure_rabbit (ec2_conn,base_name,params ):\n print \"configuring rabbitmq exchanges and Queues\"\n app_type = 'RABBITMQ'\n \n logging.basicConfig()\n \n ## Allow security from build server to rabbitmq\n rabbit_lb_sec_grp_name = get_lb_secgrp_name( base_name, app_type )\n rabbit_lb_s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds a persistence interval as child to this along with its points | def appendChild(self, child):
self.points += child.points.copy()
self.children.append(child) | [
"def add_child(self, child: UIComponent):\n child.parent = self\n child.set_chronometer(self._chronometer)\n self.children.append(child)\n if self.props.resize_mode == ResizeMode.AUTO:\n self._reset('add_child')",
"def spawn_child(self):\n return Timer(active=self.act... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Computes the filtration of the function which values are stored in x Return a single persistence interval which is the father of all the others | def get_filtration(self, x):
n = x.shape[0]
s = sorted([(i, x[i]) for i in range(n)], key=lambda x: x[1])
selected = [False for i in range(n)]
sets = {}
ancestor = {i: i for i in range(n)}
i = 0
while False in selected:
newpoint = s[i]
... | [
"def filter(self, x):\n return (self.slice(self.blur(self.splat(x))) /\n self.slice(self.blur(self.splat(np.ones_like(x)))))",
"def input_function(given_x):\n\tkeys = signal_Assignment.keys()\n\tkeys.sort\n\n\tfor i in range(len(signal_Assignment)):\n\t\tif given_x > keys[-1]:\n\t\t\treturn ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% ageid %} with now | def test_with_now(self):
self.assertEqual(ageid(self.now), 'age1') | [
"def test_with_now_minus_1_day(self):\n self.assertEqual(ageid(self.now - timedelta(1)), 'age2')",
"def test_with_now_minus_4_days(self):\n self.assertEqual(ageid(self.now - timedelta(4)), 'age5')",
"def test_with_now_minus_2_days(self):\n self.assertEqual(ageid(self.now - timedelta(2)), 'a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% ageid %} with yesterday | def test_with_now_minus_1_day(self):
self.assertEqual(ageid(self.now - timedelta(1)), 'age2') | [
"def test_with_now_minus_2_days(self):\n self.assertEqual(ageid(self.now - timedelta(2)), 'age3')",
"def test_with_now_minus_4_days(self):\n self.assertEqual(ageid(self.now - timedelta(4)), 'age5')",
"def test_with_now_minus_3_days(self):\n self.assertEqual(ageid(self.now - timedelta(3)), '... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% ageid %} with two days ago | def test_with_now_minus_2_days(self):
self.assertEqual(ageid(self.now - timedelta(2)), 'age3') | [
"def test_with_now_minus_1_day(self):\n self.assertEqual(ageid(self.now - timedelta(1)), 'age2')",
"def test_with_now_minus_3_days(self):\n self.assertEqual(ageid(self.now - timedelta(3)), 'age4')",
"def test_with_now_minus_4_days(self):\n self.assertEqual(ageid(self.now - timedelta(4)), 'a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% ageid %} with three days ago | def test_with_now_minus_3_days(self):
self.assertEqual(ageid(self.now - timedelta(3)), 'age4') | [
"def test_with_now_minus_2_days(self):\n self.assertEqual(ageid(self.now - timedelta(2)), 'age3')",
"def test_with_now_minus_4_days(self):\n self.assertEqual(ageid(self.now - timedelta(4)), 'age5')",
"def test_with_now_minus_1_day(self):\n self.assertEqual(ageid(self.now - timedelta(1)), 'a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% ageid %} with four days ago | def test_with_now_minus_4_days(self):
self.assertEqual(ageid(self.now - timedelta(4)), 'age5') | [
"def test_with_now_minus_3_days(self):\n self.assertEqual(ageid(self.now - timedelta(3)), 'age4')",
"def test_with_now_minus_2_days(self):\n self.assertEqual(ageid(self.now - timedelta(2)), 'age3')",
"def test_with_now_minus_1_day(self):\n self.assertEqual(ageid(self.now - timedelta(1)), 'a... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% ageid %} with nondatetime object | def test_with_non_datetime(self):
class Foo:
def __init__(self, now):
self.day = now.day
self.month = now.month
self.year = now.year
self.assertEqual(ageid(Foo(self.now)), 'age1') | [
"def test_with_now(self):\n self.assertEqual(ageid(self.now), 'age1')",
"def test_with_now_minus_1_day(self):\n self.assertEqual(ageid(self.now - timedelta(1)), 'age2')",
"def test_with_now_minus_4_days(self):\n self.assertEqual(ageid(self.now - timedelta(4)), 'age5')",
"def test_with_now... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% attr %} with value | def test_with_value(self):
t = Template('{% load djblets_utils %}'
'<span{% attr "class" %}\n'
'{% if some_bool %}truthy{% endif %}\n'
'{% endattr %}>')
self.assertEqual(
t.render(Context({
'some_bool': True,
... | [
"def test_escapes_value(self):\n t = Template('{% load djblets_utils %}'\n '<span{% attr \"data-foo\" %}<hello>{% endattr %}>')\n\n self.assertEqual(\n t.render(Context()),\n '<span data-foo=\"<hello>\">')",
"def test_without_value(self):\n t = ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% attr %} with no value | def test_without_value(self):
t = Template('{% load djblets_utils %}'
'<span{% attr "class" %}\n'
'{% if some_bool %}falsy{% endif %}\n'
'{% endattr %}>')
self.assertEqual(
t.render(Context({
'some_bool': False,... | [
"def test_attr_no_value(self):\r\n self.assertIn(\r\n \"foo \", unicode(self.mtforms.attr(self.form()[\"name\"], \"foo\")))",
"def test_nonexistant_attribute_returns_invalid(self):\n Point = namedtuple('Point', ['x', 'y'])\n self.context['p'] = Point(4, 5)\n\n template_str =... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% attr %} escapes value | def test_escapes_value(self):
t = Template('{% load djblets_utils %}'
'<span{% attr "data-foo" %}<hello>{% endattr %}>')
self.assertEqual(
t.render(Context()),
'<span data-foo="<hello>">') | [
"def test_escaped(value):\r\n return hasattr(value, '__html__')",
"def escapeAttr(text):\n\treturn '\"%s\"' % escapeText(text).replace('\"', r'"')",
"def xml_esc_attr(text):\n\treturn '\"%s\"' % xml_esc_text(text).replace('\"', r'"')",
"def test_condenses_whitespace(self):\n t = Template('... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% attr %} condenses/strips extra whitespace by default | def test_condenses_whitespace(self):
t = Template('{% load djblets_utils %}'
'<span{% attr "data-foo" %}\n'
'some \n\n'
'value\n'
'{% endattr %}>')
self.assertEqual(
t.render(Context()),
'<spa... | [
"def test_with_nocondense_preserves_whitespace(self):\n t = Template('{% load djblets_utils %}'\n '<span{% attr \"data-foo\" nocondense %}\\n'\n 'some \\n\\n'\n 'value\\n'\n '{% endattr %}>')\n\n self.assertEqual(\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% attr %} with "nocondense" option preserves whitespace | def test_with_nocondense_preserves_whitespace(self):
t = Template('{% load djblets_utils %}'
'<span{% attr "data-foo" nocondense %}\n'
'some \n\n'
'value\n'
'{% endattr %}>')
self.assertEqual(
t.render(Co... | [
"def test_condenses_whitespace(self):\n t = Template('{% load djblets_utils %}'\n '<span{% attr \"data-foo\" %}\\n'\n 'some \\n\\n'\n 'value\\n'\n '{% endattr %}>')\n\n self.assertEqual(\n t.render(Context())... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% definevar %} | def test_basic_usage(self):
t = Template('{% load djblets_utils %}'
'{% definevar "myvar" %}\n'
'test{{num}}\n'
'{% enddefinevar %}'
'{{myvar}}')
self.assertEqual(
t.render(Context({
'num': 1... | [
"def test_with_global(self):\n t = Template(\n '{% load djblets_utils %}'\n '{% block main %}'\n '{% block inner %}'\n '{% definevar \"myvar\" global %}{{num}}{% enddefinevar %}'\n '{% endblock %}'\n '{% endblock %}'\n '[{{myvar... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% definevar %} with global option | def test_with_global(self):
t = Template(
'{% load djblets_utils %}'
'{% block main %}'
'{% block inner %}'
'{% definevar "myvar" global %}{{num}}{% enddefinevar %}'
'{% endblock %}'
'{% endblock %}'
'[{{myvar}}]')
... | [
"def test_basic_usage(self):\n t = Template('{% load djblets_utils %}'\n '{% definevar \"myvar\" %}\\n'\n 'test{{num}}\\n'\n '{% enddefinevar %}'\n '{{myvar}}')\n\n self.assertEqual(\n t.render(Context({\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% definevar %} with strip option | def test_with_strip(self):
t = Template('{% load djblets_utils %}'
'{% definevar "myvar" strip %}\n'
'<span>\n'
' <strong>\n'
' test{{num}}\n'
' </strong>\n'
'</span>\n'
... | [
"def test_with_spaceless(self):\n t = Template('{% load djblets_utils %}'\n '{% definevar \"myvar\" spaceless %}\\n'\n '<span>\\n'\n ' <strong>\\n'\n ' test{{num}}\\n'\n ' </strong>\\n'\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% definevar %} with spaceless option | def test_with_spaceless(self):
t = Template('{% load djblets_utils %}'
'{% definevar "myvar" spaceless %}\n'
'<span>\n'
' <strong>\n'
' test{{num}}\n'
' </strong>\n'
'</span>\n'
... | [
"def test_with_strip(self):\n t = Template('{% load djblets_utils %}'\n '{% definevar \"myvar\" strip %}\\n'\n '<span>\\n'\n ' <strong>\\n'\n ' test{{num}}\\n'\n ' </strong>\\n'\n '</span>... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% definevar %} with unsafe option | def test_with_unsafe(self):
t = Template('{% load djblets_utils %}'
'{% definevar "myvar" unsafe %}<hello>{% enddefinevar %}'
'{{myvar}}')
self.assertEqual(t.render(Context()), '<hello>') | [
"def test_with_strip(self):\n t = Template('{% load djblets_utils %}'\n '{% definevar \"myvar\" strip %}\\n'\n '<span>\\n'\n ' <strong>\\n'\n ' test{{num}}\\n'\n ' </strong>\\n'\n '</span>... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {{...|escapespaces}} with single space | def test_with_single_space(self):
self.assertEqual(escapespaces('Hi there'),
'Hi there') | [
"def test_with_spaceless(self):\n t = Template('{% load djblets_utils %}'\n '{% definevar \"myvar\" spaceless %}\\n'\n '<span>\\n'\n ' <strong>\\n'\n ' test{{num}}\\n'\n ' </strong>\\n'\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {{...|escapespaces}} with multiple consecutive spaces | def test_with_multiple_spaces(self):
self.assertEqual(escapespaces('Hi there'),
'Hi there') | [
"def test_with_single_space(self):\n self.assertEqual(escapespaces('Hi there'),\n 'Hi there')",
"def test_with_spaceless(self):\n t = Template('{% load djblets_utils %}'\n '{% definevar \"myvar\" spaceless %}\\n'\n '<span>\\n'\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {{...|escapespaces}} with newline | def test_with_newline(self):
self.assertEqual(escapespaces('Hi there\n'),
'Hi there<br />') | [
"def test_code(self):\n self.assertEquals(\"\\n\\tline1\\n\\tline2\",\n trans(\"{{{\\nline1\\nline2\\n}}}\"))",
"def test_with_multiple_lines(self):\n self.assertEqual(indent('foo\\nbar'),\n ' foo\\n bar')",
"def test_parse_simple_quote_with_n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {{...|humanize_list}} with empty list | def test_with_empty_list(self):
self.assertEqual(humanize_list([]),
'') | [
"def test_with_1_item(self):\n self.assertEqual(humanize_list(['a']),\n 'a')",
"def test_with_2_items(self):\n self.assertEqual(humanize_list(['a', 'b']),\n 'a and b')",
"def test_with_4_items(self):\n self.assertEqual(humanize_list(['a', 'b',... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {{...|humanize_list}} with 1 item | def test_with_1_item(self):
self.assertEqual(humanize_list(['a']),
'a') | [
"def test_with_4_items(self):\n self.assertEqual(humanize_list(['a', 'b', 'c', 'd']),\n 'a, b, c, and d')",
"def test_with_2_items(self):\n self.assertEqual(humanize_list(['a', 'b']),\n 'a and b')",
"def test_with_3_items(self):\n self.assertE... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {{...|humanize_list}} with 2 items | def test_with_2_items(self):
self.assertEqual(humanize_list(['a', 'b']),
'a and b') | [
"def test_with_1_item(self):\n self.assertEqual(humanize_list(['a']),\n 'a')",
"def test_with_3_items(self):\n self.assertEqual(humanize_list(['a', 'b', 'c']),\n 'a, b and c')",
"def test_with_4_items(self):\n self.assertEqual(humanize_list(['... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {{...|humanize_list}} with 3 items | def test_with_3_items(self):
self.assertEqual(humanize_list(['a', 'b', 'c']),
'a, b and c') | [
"def test_with_4_items(self):\n self.assertEqual(humanize_list(['a', 'b', 'c', 'd']),\n 'a, b, c, and d')",
"def test_with_1_item(self):\n self.assertEqual(humanize_list(['a']),\n 'a')",
"def test_with_2_items(self):\n self.assertEqual(humaniz... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {{...|humanize_list}} with 4 items | def test_with_4_items(self):
self.assertEqual(humanize_list(['a', 'b', 'c', 'd']),
'a, b, c, and d') | [
"def test_with_3_items(self):\n self.assertEqual(humanize_list(['a', 'b', 'c']),\n 'a, b and c')",
"def test_with_1_item(self):\n self.assertEqual(humanize_list(['a']),\n 'a')",
"def test_with_2_items(self):\n self.assertEqual(humanize_list(['... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% include_as_string %} | def test_basic_usage(self):
t = Template('{% load djblets_utils %}'
'{% include_as_string template_name %}')
self.assertEqual(
t.render(Context({
'template_name': 'testing/foo.html',
'foo': 1,
'bar': 2,
})),
... | [
"def include_string(parser, token):\n\tbits = token.split_contents()\n\tif len(bits) != 2:\n\t\traise TemplateSyntaxError(\"%r tag takes one argument: the template string to be included\" % bits[0])\n \tstring = parser.compile_filter(bits[1])\n\treturn IncludeStringNode(string)",
"def test_includes(self):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {{...|indent}} with default indentation level | def test_with_default_indent(self):
self.assertEqual(indent('foo'), ' foo') | [
"def test_with_custom_indent(self):\n self.assertEqual(indent('foo', 3), ' foo')",
"def test_indentOneLine(self):\n result = indent('string', 0)\n self.assertEquals(result, 'string')",
"def test_with_multiple_lines(self):\n self.assertEqual(indent('foo\\nbar'),\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {{...|indent}} with custom indentation level | def test_with_custom_indent(self):
self.assertEqual(indent('foo', 3), ' foo') | [
"def test_with_default_indent(self):\n self.assertEqual(indent('foo'), ' foo')",
"def test_indentOneLine(self):\n result = indent('string', 0)\n self.assertEquals(result, 'string')",
"def test_with_multiple_lines(self):\n self.assertEqual(indent('foo\\nbar'),\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {{...|indent}} with multiple lines | def test_with_multiple_lines(self):
self.assertEqual(indent('foo\nbar'),
' foo\n bar') | [
"def test_with_custom_indent(self):\n self.assertEqual(indent('foo', 3), ' foo')",
"def test_indentOneLine(self):\n result = indent('string', 0)\n self.assertEquals(result, 'string')",
"def test_indent():\n\n multiline_string = \"\"\"test\ntest1\ntest2\ntest3\"\"\"\n\n indented_mult... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "update" %} basic usage | def test_update_basic_usage(self):
self.assertEqual(
self._render_tag(tag='{% querystring "update" "foo=bar" %}',
query_str='foo=bar'),
'?foo=bar') | [
"def test_update_with_existing_query_override(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"update\" \"foo=bar\" %}',\n query_str='foo=foo&bar=baz')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(QueryDict(rendered_result[1:]... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "update" %} with an existing query that gets overridden | def test_update_with_existing_query_override(self):
rendered_result = self._render_tag(
tag='{% querystring "update" "foo=bar" %}',
query_str='foo=foo&bar=baz')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(QueryDict(rendered_result[1:]),
... | [
"def test_update_with_existing_query_with_two_args_override(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"update\" \"foo=bar\" \"qux=baz\" %}',\n query_str='foo=foo&bar=bar&baz=baz&qux=qux')\n\n self.assertTrue(rendered_result.startswith('?'))\n self... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "update" %} with two args that get overridden | def test_update_with_existing_query_with_two_args_override(self):
rendered_result = self._render_tag(
tag='{% querystring "update" "foo=bar" "qux=baz" %}',
query_str='foo=foo&bar=bar&baz=baz&qux=qux')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(Quer... | [
"def test_update_with_existing_query_override(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"update\" \"foo=bar\" %}',\n query_str='foo=foo&bar=baz')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(QueryDict(rendered_result[1:]... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "update" %} with no value | def test_update_with_no_value(self):
rendered_result = self._render_tag(
tag='{% querystring "update" "foo" %}',
query_str='')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(QueryDict(rendered_result[1:]), QueryDict('foo=')) | [
"def test_update_with_no_key(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"update\" \"=foo\" %}',\n query_str='')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(QueryDict(rendered_result[1:]), QueryDict('=foo'))",
"def test... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "update" %} with multiple values | def test_update_with_multiple_values(self):
rendered_result = self._render_tag(
tag='{% querystring "update" "foo=bar=baz" %}',
query_str='foo=foo')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(QueryDict(rendered_result[1:]),
... | [
"def test_with_updating_multiple_values_of_a_key(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"update\" \"a=1&a=2\" %}',\n query_str='foo=foo')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(QueryDict(rendered_result[1:]),\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "update" %} with empty value | def test_update_with_empty_value(self):
rendered_result = self._render_tag(
tag='{% querystring "update" "foo=" %}',
query_str='')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(QueryDict(rendered_result[1:]), QueryDict('foo=')) | [
"def test_update_with_no_value(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"update\" \"foo\" %}',\n query_str='')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(QueryDict(rendered_result[1:]), QueryDict('foo='))",
"def tes... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "update" %} with no key | def test_update_with_no_key(self):
rendered_result = self._render_tag(
tag='{% querystring "update" "=foo" %}',
query_str='')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(QueryDict(rendered_result[1:]), QueryDict('=foo')) | [
"def test_update_with_no_value(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"update\" \"foo\" %}',\n query_str='')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(QueryDict(rendered_result[1:]), QueryDict('foo='))",
"def tes... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "update" %} by updating multiple values of a key value | def test_with_updating_multiple_values_of_a_key(self):
rendered_result = self._render_tag(
tag='{% querystring "update" "a=1&a=2" %}',
query_str='foo=foo')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(QueryDict(rendered_result[1:]),
... | [
"def test_update_with_multiple_values(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"update\" \"foo=bar=baz\" %}',\n query_str='foo=foo')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(QueryDict(rendered_result[1:]),\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "append" %} with appending multiple values of a key | def test_append_with_multiple_values_and_same_key(self):
rendered_result = self._render_tag(
tag='{% querystring "append" "a=1&a=2&a=3" %}',
query_str='a=0&&b=2&c=3')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(QueryDict(rendered_result[1:]),
... | [
"def test_append_with_multiple_values_and_same_key_seperated(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"append\" \"a=1\" \"a=2\" \"a=3\" %}',\n query_str='a=0&&b=2&c=3')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(Query... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "append" %} with appending multiple values of a key fragment | def test_append_with_multiple_values_and_same_key_seperated(self):
rendered_result = self._render_tag(
tag='{% querystring "append" "a=1" "a=2" "a=3" %}',
query_str='a=0&&b=2&c=3')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(QueryDict(rendered_resul... | [
"def test_append_with_multiple_values_and_same_key(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"append\" \"a=1&a=2&a=3\" %}',\n query_str='a=0&&b=2&c=3')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(QueryDict(rendered_resu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "append" %} with appending new keyvalue pair | def test_append_with_new_key(self):
rendered_result = self._render_tag(
tag='{% querystring "append" "d=4" %}',
query_str='a=1&b=2&c=3')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(QueryDict(rendered_result[1:]),
QueryDict('... | [
"def test_append_with_multiple_values_and_same_key(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"append\" \"a=1&a=2&a=3\" %}',\n query_str='a=0&&b=2&c=3')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(QueryDict(rendered_resu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "remove" %} by attempting to remove a nonexisting key | def test_remove_with_key_not_in_querystring(self):
rendered_result = self._render_tag(
tag='{% querystring "remove" "baz" %}',
query_str='foo=foo&bar=bar')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(QueryDict(rendered_result[1:]),
... | [
"def test_remove_with_no_key(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"remove\" \"=foo\" %}',\n query_str='foo=foo&foo=bar&baz=baz&=foo')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(QueryDict(rendered_result[1:]),\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "remove" %} by removing all instances of a key | def test_remove_with_key_appearing_multiple_times(self):
rendered_result = self._render_tag(
tag='{% querystring "remove" "foo" %}',
query_str='foo=foo&foo=bar&bar=bar')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(QueryDict(rendered_result[1:]), Que... | [
"def test_remove_with_no_key(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"remove\" \"=foo\" %}',\n query_str='foo=foo&foo=bar&baz=baz&=foo')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(QueryDict(rendered_result[1:]),\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "remove" %} by removing a specific keyvalue pair | def test_remove_for_specific_key_value_pairs(self):
rendered_result = self._render_tag(
tag='{% querystring "remove" "a=4" %}',
query_str='a=1&a=2&a=3&a=4')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(QueryDict(rendered_result[1:]),
... | [
"def test_remove_with_key_not_in_querystring(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"remove\" \"baz\" %}',\n query_str='foo=foo&bar=bar')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(QueryDict(rendered_result[1:]),\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "remove" %} by removing a value with no key | def test_remove_with_no_key(self):
rendered_result = self._render_tag(
tag='{% querystring "remove" "=foo" %}',
query_str='foo=foo&foo=bar&baz=baz&=foo')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(QueryDict(rendered_result[1:]),
... | [
"def test_remove_with_key_not_in_querystring(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"remove\" \"baz\" %}',\n query_str='foo=foo&bar=bar')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(QueryDict(rendered_result[1:]),\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Testing {% querystring "remove" %} by removing multiple specific keyvalue pairs | def test_remove_with_multiple_specific_values(self):
rendered_result = self._render_tag(
tag='{% querystring "remove" "foo=1" "foo=2" %}',
query_str='foo=1&foo=2&foo=3')
self.assertTrue(rendered_result.startswith('?'))
self.assertEqual(QueryDict(rendered_result[1:]), Que... | [
"def test_remove_for_specific_key_value_pairs(self):\n rendered_result = self._render_tag(\n tag='{% querystring \"remove\" \"a=4\" %}',\n query_str='a=1&a=2&a=3&a=4')\n\n self.assertTrue(rendered_result.startswith('?'))\n self.assertEqual(QueryDict(rendered_result[1:]),\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returned a rendered template tag using a query string. This will render a ``querystring`` template using the provided template tag, with autoescaping turned off, and with the given query string as would be provided in a URL. | def _render_tag(self, tag, query_str):
t = Template('{%% load djblets_utils %%}'
'{%% autoescape off %%}%s{%% endautoescape %%}'
% tag)
request = HttpRequest()
if query_str:
request.GET = QueryDict(query_str)
return t.render(Contex... | [
"def template_string(template, **kwargs):\n\n temp = Template(template)\n return temp.render(**kwargs)",
"def render_string(self, template: str, **vars) -> str:",
"def query_string(context, add=None, remove=None):\n # Written as an inclusion tag to simplify getting the context.\n add = string_to_dic... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return a filter key and value if exact filter exists for name. | def get_exact_filter_by_name(self, name):
for entry in self.filters:
if (entry['type'] == 'filter' and entry['name'] == name and
entry['comparator'] == 'equals'):
return entry | [
"def filterInfo(self, name):\n return self.__filters[name] if name in self.__filters else None",
"def get_filter(self, name):\n for flter in self.get_filters():\n if flter.name == name:\n return flter",
"def get_filter(name):\n try:\n return FILTERS[name.upper()... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Set a limit to indicate the list should be truncated. | def set_limit(self, limit, truncated=False):
self.limit = {'limit': limit, 'type': 'limit', 'truncated': truncated} | [
"def set_limit(self, limit: int) -> None:",
"def limit(self, limit):\n self._limit = limit",
"def limitsize(self, limit):\n self._limitsize = limit",
"def limit(self, limit):\n self._size = limit\n return self",
"def truncation(self, truncate: int) -> None:\n self._truncat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Builds and returns a QueryStrategy using a feature extractor and a base_df | def build_query_strategy(sent_df, col_names):
# type: (DataFrame, ColumnNames) -> QueryStrategy
init_extractor = SynStateALHeuristic.build_feature_extractor(sent_df, col_names)
combined_features = init_extractor.transform(sent_df, col_names)
return HintSVM(TextDataset(sent_df, col_names,... | [
"def make_query_strategy(utility_measure: Callable, selector: Callable) -> Callable:\n def query_strategy(classifier: BaseEstimator, X: modALinput) -> Tuple:\n utility = utility_measure(classifier, X)\n query_idx = selector(utility)\n return query_idx, X[query_idx]\n\n return query_strate... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Parse a list of MAVEHGVS strings into Variant objects or error messages. | def parse_variant_strings(
variants: Iterable[str],
targetseq: Optional[str] = None,
expected_prefix: Optional[str] = None,
) -> Tuple[List[Optional[Variant]], List[Optional[str]]]:
if expected_prefix is not None and expected_prefix not in list("cgmnopr"):
raise ValueError("invalid expected pref... | [
"def parse_multivector(self, mv_string: str) -> 'MultiVector':\n # Get the names of the canonical blades\n blade_name_index_map = {name: index for index, name in enumerate(self.names)}\n\n # Clean up the input string a bit\n cleaned_string = re.sub('[()]', '', mv_string)\n\n # Cre... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generate a batch of binary masks for data. | def _generate_masks(self, data, batch_size):
height, width = data.shape[2], data.shape[3]
mask_size = (self._down_sample_size, self._down_sample_size)
up_size = (height + mask_size[0], width + mask_size[1])
mask = np.random.random((batch_size, 1) + mask_size) < self._mask_probability
... | [
"def generate_masks(self, samples):\n N_masks = self.N_masks\n N_patch = self.N_patch\n Ny = samples.shape[2]\n patch_inds = self.patch_inds\n patch_radius = self.patch_radius\n # Tile samples\n samples = np.tile(samples, [N_masks, 1, 1])\n # Add extra dimensi... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
To unify targets to be 2D numpy.ndarray. | def _unify_targets(inputs, targets):
if isinstance(targets, int):
return np.array([[targets] for _ in inputs]).astype(np.int)
if isinstance(targets, Tensor):
if not targets.shape:
return np.array([[targets.asnumpy()] for _ in inputs]).astype(np.int)
if... | [
"def convert_2d_to_target(arrays, target):\n if target == 'mask':\n return arrays[0] if len(arrays) == 1 else arrays\n elif target == 'image':\n return convert_2d_to_3d(arrays, num_channels=3)\n elif target == 'image_4_channels':\n return convert_2d_to_3d(arrays, num_channels=4)\n e... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Compiles a message that can be posted to Slack after a call has been made | def compile_slack_phone_message(phone_from, phone_to, status, location):
call_from_user = _query_user(phone_from)
call_from = _format_caller(call_from_user, phone_from)
call_to_user = _query_user(phone_to)
call_to = _format_caller(call_to_user, phone_to)
location_str = list(filter(lambda x: x[0] ... | [
"def build_message(self):\n raise NotImplementedError",
"def build_message(**kwargs: Any) -> \"Message\":\n return Message(**kwargs)",
"def construct_message(self):\n msg_type = self.msg_type\n if msg_type == \"PUBMSG\":\n msg_type = \"PRIVMSG\"\n ret = \"{} {}\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Compile a message that can be posted to Slack after a SMS has been received | def compile_slack_sms_message(_sms_from, message):
sms_from_user = _query_user(_sms_from)
sms_from = _format_caller(sms_from_user, _sms_from)
pretext = "Nytt SMS från %s" % (sms_from, )
fallback = "%s \n\"%s\"" % (pretext, message)
return {
'attachments': [
{
'p... | [
"def compile_slack_phone_message(phone_from, phone_to, status, location):\n\n call_from_user = _query_user(phone_from)\n call_from = _format_caller(call_from_user, phone_from)\n\n call_to_user = _query_user(phone_to)\n call_to = _format_caller(call_to_user, phone_to)\n\n location_str = list(filter(la... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Retrieves first name, last name and groups corresponding to a phone number from the database, if it exists. If multiple users have the same number, none will be queried | def _query_user(phone):
if not is_valid_phone_number(phone):
return None
try:
user = Profile.objects.get(mobile_phone=_remove_area_code(phone)).user
return {
'first_name': user.first_name,
'last_name': user.last_name,
'groups': [group.name if group.n... | [
"def get_user_by_fn_ln_phone(first_name, last_name, phone):\n if not any([first_name, last_name, phone]):\n return None\n\n profiles = Profile.objects.filter(\n user__first_name__iexact=first_name,\n user__last_name__iexact=last_name,\n phone__iexact=phone).... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Formats caller information into a readable string | def _format_caller(call_user, phone):
# The phone number is private or not provided
if not phone:
return 'dolt nummer'
if is_valid_phone_number(phone):
# Set the phone number as a clickable link
caller = '<tel:%s|%s>' % (phone, phone)
else:
caller = phone
if call_us... | [
"def caller():\n frame = sys._getframe(2)\n info = inspect.getframeinfo(frame)\n result = \"%s:%d (%s)\"%(info.filename,info.lineno,info.function)\n del frame\n return result",
"def format_call(func, args, kwargs, object_name=\"Memory\"):\r\n path, signature = format_signature(func, *args, **kwa... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Removes the area code (+46) from the given phone number and replaces it with 0 | def _remove_area_code(phone):
if not phone.startswith('+46'):
return phone
else:
return '0' + phone[3:] | [
"def change_area_code(tel_num: str) -> str:\n # Attempt 1:\n # is_smaller_than_five = int(tel_num.split(\"-\")[1][ 0]) <= 5\n # tel_nums = [int(num) for num in tel_num.split(\"-\")]\n # num4 = [str(num + 1) if num == tel_nums[0] and is_smaller_than_five else str(num) for num\n # in tel_nums]\n # r... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
als het regtype wijzigt moeten ook de naam ervan, de player, de editor en het filepad en de url aangepast worden (door het item op te halen) | def type(self, value):
self._type_id = value
data = RegType(value)
self.regtype = data.typenaam
## self.player = data.playernaam
## self.editor = data.readernaam
self.pad = os.path.join(data.padnaam, self._file)
self.url = '/'.join((data.htmlpadnaam, self._... | [
"def reg(request='', melding='', item='', action='', soort='', sel=''):\n ## try:\n ## incoming = request.GET\n ## except:\n ## incoming = {}\n page_data = {\"message\": \"\",\n \"crumbs\": [('/', 'Home', 'Magiokis'),\n ('/songs/', 'start', \"songs: ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
als het songid wijzigt moet ook de titel aangepast worden (door de song te raadplegen) | def song(self, value):
self._song_id = value
data = Song(value)
self.songtitel = data.songtitel if data.found else "" | [
"def getTitre(self, i):\n\t\tif -1 < i < self.getLength() :\n\t\t\treturn self.liste[i]\n\t\telse :\n\t\t\treturn \"defaut.mp3\" # ajouter une musique par défaut",
"def get_songs_title(self):\n self.browser.get(self.url)\n titles = self.browser.find_elements_by_id(\"video-title\")\n self.song... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Import the `datafile` Excel sheet to a CSV representation stored within the database that can be further processed without large filesystem operations. This also stores the original file's hash in order to skip importing unchanged data. Returns boolean (whether file was imported). | def import_datafile(db, infile):
res = stat(infile)
mtime = datetime.utcfromtimestamp(res.st_mtime)
hash = md5hash(infile)
data_file = db.model.data_file
# Should maybe make sure error is not set
rec = db.get(data_file, hash)
# We are done if we've already imported
if rec is not None:... | [
"def csv(self, file, table=None):\n\n if table:\n table.import_from_csv_file(file)\n else:\n db = self.db\n # This is the preferred method as it updates reference fields\n db.import_from_csv_file(file)\n db.commit()",
"def import_data(self):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Decorator for class functions to catch errors and display a dialog box for a success or error. Checks if method is a bound method in order to properly handle parents for dialog box. | def errorCheck(success_text=None, error_text="Error!",logging=True,show_traceback=False,skip=False):
def decorator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
if inspect.ismethod(func):
self = args[0]
else:
self = None
... | [
"def ajax_method(method):\n def decorator(fun):\n def wrapper(*args, **kwargs):\n if args[0].method.lower() != method.lower():\n return ajax_error(404, 'bad_method')\n return fun(*args, **kwargs)\n return wrapper\n\n return decorator",
"def error_handler(ca... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Normalize weight vector. Negative weights set to zero, and whole vector sums to 1.0. | def normalize_weights(self):
# Set negative weights to zero
# Normalize to sum to one.
self.new_weight=[]
for i in self._weights:
if any(i < 0 for i in self._weights):
self.new_weight = [0,1]
elif all(i == 0 for i in self._weig... | [
"def __normalize_weights(self):\n result = norm(self.weights, 1)\n self.weights = self.weights / result if not result == 0.0 else self.weights",
"def normalize_weights(self):\n total_weight = sum(self.weights)\n self.norm_weights = self.weights / float(total_weight)",
"def normalize_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the path where the .NET2 Framework SDK is installed | def _getNETSDKPath():
try:
dotNETSDK_root_key = win32api.RegOpenKeyEx(win32con.HKEY_LOCAL_MACHINE, 'SOFTWARE\\Microsoft\\Microsoft SDKs\\.NETFramework\\v2.0', 0, win32con.KEY_READ)
found = False
i = 0
try:
try:
while not found:
name, obj, ntype = win32api.RegEnumValue(d... | [
"def getDotNetFrameworkSdkDir(version='2.0'):\r\n subKey = r\"SOFTWARE\\Microsoft\\.NETFramework\"\r\n valueName = \"sdkInstallRootv\" + version\r\n return queryString(winreg.HKEY_LOCAL_MACHINE, subKey, valueName)",
"def get_windows_sdk_path():\n try:\n import _winreg as winreg\n except ImportErro... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Add Builders and construction variables for tlbimp to an Environment. | def generate(env):
if not exists(env):
return 0;
TLBImpBuilder = env.Builder(
action = SCons.Action.Action(
TLBImpGenerator
, generator = 1
#, ... | [
"def setup_build_environment(self, env):\n env.set(\"BOOSTROOT\", self.spec[\"boost\"].prefix)\n env.set(\"CBTF_ROOT\", self.spec[\"cbtf\"].prefix)\n env.set(\"CBTF_KRELL_ROOT\", self.spec[\"cbtf-krell\"].prefix)\n env.set(\"CBTF_ARGONAVIS_ROOT\", self.spec[\"cbtf-argonavis\"].prefix)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Compare two categorical histograms and return a overlap score based on RMSE b1 bin edges of hist 1 b2 bin edges of hist 2 h1 histogram values of hist 1 h2 histogram values of hist 2 Return rmsebased overlap score | def _compare_cat_hist(b1, b2, h1, h2):
cbe = list(set(b1) | set(b2))
total = len(cbe)
rmse = 0.0
if sum(h1) == 0 or sum(h2) == 0:
return 0.0
for index in range(total):
sh1 = 0.0
sh2 = 0.0
try:
sh1 = float(h1[b1.index(cbe[index])])
except Excepti... | [
"def _compare_cont_hist(b1, b2, h1, h2):\n\n b1 = copy.deepcopy(b1)\n h1 = copy.deepcopy(h1)\n b2 = copy.deepcopy(b2)\n h2 = copy.deepcopy(h2)\n\n bd1 = [float(x) for x in b1]\n bd2 = [float(x) for x in b2]\n\n inf = float('inf')\n\n if bd1[0] == -inf:\n del bd1[0]\n del h1[0]\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Compare two continuous histograms and return a overlap score based on RMSE b1 bin edges of hist 1 b2 bin edges of hist 2 h1 histogram values of hist 1 h2 histogram values of hist 2 Return rmsebased overlap score | def _compare_cont_hist(b1, b2, h1, h2):
b1 = copy.deepcopy(b1)
h1 = copy.deepcopy(h1)
b2 = copy.deepcopy(b2)
h2 = copy.deepcopy(h2)
bd1 = [float(x) for x in b1]
bd2 = [float(x) for x in b2]
inf = float('inf')
if bd1[0] == -inf:
del bd1[0]
del h1[0]
if bd1[-1] == i... | [
"def _compare_cat_hist(b1, b2, h1, h2):\n cbe = list(set(b1) | set(b2))\n\n total = len(cbe)\n rmse = 0.0\n\n if sum(h1) == 0 or sum(h2) == 0:\n return 0.0\n\n for index in range(total):\n sh1 = 0.0\n sh2 = 0.0\n try:\n sh1 = float(h1[b1.index(cbe[index])])\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Evaluates base attribute value of person based on features, age, gender, etc. | def attribute(self, attribute):
value = 3
if self.age == "child":
value -= 1
if attribute == "physique" or attribute == "phy":
if self.age == "adult":
value += 1
if self.gender == "male":
value += 1
elif self.gender ... | [
"def gender_bias(df):\n true_positive_gender = []; check = []\n for pred, fname in df[['prediction', 'fname']].values:\n if fname.startswith('non'):\n binary_truth = fname[:3]\n else:\n binary_truth = fname[2:5]\n \n check.append(fname[:5])\n if pred ==... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Permute the rows of _X_ to minimize error with Y, ignoring signs of the columns X numpy.array input matrix Y numpy.array comparison matrix numpy.array X with permuted rows | def match_rows_sign(X, Y):
n, d = X.shape
n_, d_ = Y.shape
assert n == n_ and d == d_
# Create a weight matrix to compare the two
W = zeros((n, n))
for i, j in it.product(xrange(n), xrange(n)):
# Cost of 'assigning' j to i.
W[i, j] = min(norm(X[j] - Y[i]), norm(X[j] + Y[i]) )
... | [
"def lower_triangular_solve(matrix, rhs):\n rows = [[] for i in range(matrix.rows)]\n for i, j, v in matrix.row_list():\n if i > j:\n rows[i].append((j, v))\n X = rhs.as_mutable().copy()\n for j in range(rhs.cols):\n for i in range(rhs.rows):\n for u, v in rows[i]:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Requests a new ip for the device | def request_new_ip(self, mac):
self.execute_script('new_ip', mac) | [
"def set_new_ip():\n with Controller.from_port(port=9051) as controller:\n controller.authenticate(password='tor_password')\n controller.signal(Signal.NEWNYM)",
"def ip(self, request):\n ip = get_real_ip(request) or 'undefined'\n debug_logger.debug(\"IP request from : \" + ip)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Change dhcp response time for device mac | def change_dhcp_response_time(self, mac, time):
self.execute_script('change_dhcp_response_time', mac, time) | [
"def stop_dhcp_response(self, mac):\n self.change_dhcp_response_time(mac, -1)",
"def dhcp(self, dhcp):\n\n self._dhcp = dhcp",
"def dhcp_request(_trans_id, _offered_addr, _client_mac, _server_addr):\n\n raw_socket = socket.socket(socket.PF_PACKET, socket.SOCK_RAW, socket.htons(0x0800))\n raw... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Stops DHCP response for the device | def stop_dhcp_response(self, mac):
self.change_dhcp_response_time(mac, -1) | [
"def StopDHCP():\n cmd = 'killall dhclient dhclient3 pump dhcpcd-bin'\n misc.Run(cmd)",
"def stop(self):\n\n if not self._dhcp_client_ctrl is None:\n self._dhcp_client_ctrl.exit()\n if not self._slave_dhcp_process is None:\n self._slave_dhcp_process.kill()\n lo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Change dhcp range for devices | def change_dhcp_range(self, start, end, prefix_length):
self.execute_script('change_dhcp_range', start, end, prefix_length) | [
"def get_dhcp_range(options, index):\n second_octet = 160 + index\n return \"192.%s.1.2-192.%s.255.254\" % (second_octet, second_octet)",
"def dhcp(self, dhcp):\n\n self._dhcp = dhcp",
"def configureDHCP():\n dhcpStart = config.get(\"hotspot\", \"dhcpstart\")\n dhcpEnd = config.get(\"hotspot\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Converts a single track record into m3u format. Need the normalization to fix the way Apple handles e.g. combining diacriticals. | def to_m3u_track(record: Dict[str, str]) -> str:
location = normalize(unquote(record.get("Location")))
# m3u duration in seconds, not ms
duration = int(record.get("Total Time")) // 1000
name = normalize(unquote(record.get("Name")))
artist = normalize(unquote(
record.get("Artist") or
... | [
"def create_m3u(self):\n\n m3u = \"#EXTM3U\\n\"\n for i in self.file_tag_map:\n m3u += \"#EXTINF:-1,%s - %s\\n\" % (self.tracks[i][0], \\\n self.tracks[i][1]) \n m3u += \"%s\\n\" % self.file_tag_map[i][1]\n\n return self.write_file(m3u, os.path.join... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Converts a list of serialized m3u tracks into a playlist. | def to_m3u_list(list_name: str, tracks: List[str]) -> str:
return M3U_TEMPLATE.format(name=list_name, tracks="\n".join(tracks)) | [
"def m3u2list(data):\n matches = re.compile('^#EXTINF:-?[0-9]*(.*?),(.*?)\\n(.*?)$', re.I + re.M + re.U + re.S).findall(data)\n li = []\n for params, display_name, url in matches:\n item_data = {'params': params, 'display_name': display_name, 'url': url}\n li.append(item_data)\n\n playlist... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get the value of property _Chassis | def Chassis(self):
return self._Chassis | [
"def chassis_serial(self) -> str:\n return self.__chassis_serial",
"def getCharger(self):\r\n if hasattr(self, \"charger\"):\r\n return self.charger\r\n else:\r\n return None",
"def get_chassis_and_slot(self):\r\n return self._chassis,self._slot",
"def ris_get... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get the value of property _Option | def Option(self):
return self._Option | [
"def getOption(self) :\n return self._option",
"def __getattribute__(self, name):\r\n attr = object.__getattribute__(self, name)\r\n if isinstance(attr, Option):\r\n return attr.value\r\n else:\r\n return attr",
"def option_value(self):\n return self._opt... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Draws a Run the test button on the page for a user. | def Button(request):
params = {
'mimetype': 'text/javascript',
'fn': request.GET.get('fn', '_bRunTest'),
'btn_text': request.GET.get('btn_text', 'Run the test'),
'cb_text': request.GET.get('cb_text',
'and send my results to Browserscope (anonymously)'),
}
return util.Render(request, 'user_... | [
"def make_run_button(self):\n\n run_button = Button(\n self.master, text=\"Run\", command=self.run_simulator)\n run_button.grid(row=6, column=1)\n\n return run_button",
"def test_viewer_button_click(self):\n self.browser.get('%s%s' % (self.live_server_url,\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
The User Test results table. | def Table(request, key):
test = models.user_test.Test.get_mem(key)
if not test:
msg = 'No test was found with test_key %s.' % key
return http.HttpResponseServerError(msg)
params = {
'hide_nav': True,
'hide_footer': True,
'test': test,
}
return util.GetResults(request, 'user_test_table.ht... | [
"def generate_table(self, results):\n\n # Create table of results\n self.tableHandler = application.TableHandler(self.app)\n self.tableHandler.fill_table(results)",
"def getTestResultTables(self):\n sRet = '';\n for i in range(len(self.aidStrTests)):\n sRet += ' ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Shows a table of user tests. | def Index(request):
output = request.GET.get('o')
if output == 'gviz_table_data':
return http.HttpResponse(FormatUserTestsAsGviz(request))
else:
params = {
'height': '400px',
'width': 'auto',
'page_size': 20
}
return util.Render(request, 'user_tests_index.html', params) | [
"def Table(request, key):\n test = models.user_test.Test.get_mem(key)\n if not test:\n msg = 'No test was found with test_key %s.' % key\n return http.HttpResponseServerError(msg)\n\n params = {\n 'hide_nav': True,\n 'hide_footer': True,\n 'test': test,\n }\n\n return util.GetResults(request, 'u... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |