query stringlengths 9 9.05k | document stringlengths 10 222k | negatives listlengths 19 20 | metadata dict |
|---|---|---|---|
Merges metric data from a snapshot. This is used both when merging data from a single transaction into the main stats engine, and for performing a rollback merge. In either case, the merge is done the exact same way. | def merge_metric_stats(self, snapshot):
if not self.__settings:
return
for key, other in six.iteritems(snapshot.__stats_table):
stats = self.__stats_table.get(key)
if not stats:
self.__stats_table[key] = other
else:
stats.... | [
"def merge(self, snapshot):\n\n if not self.__settings:\n return\n\n self.merge_metric_stats(snapshot)\n self._merge_transaction_events(snapshot)\n self._merge_synthetics_events(snapshot)\n self._merge_error_events(snapshot)\n self._merge_error_traces(snapshot)\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Merges in a set of custom metrics. The metrics should be provide as an iterable where each item is a tuple of the metric name and the accumulated stats for the metric. | def merge_custom_metrics(self, metrics):
if not self.__settings:
return
for name, other in metrics:
key = (name, '')
stats = self.__stats_table.get(key)
if not stats:
self.__stats_table[key] = other
else:
stats... | [
"def add_metrics(self, metrics: List[Tuple]):\n for metric in metrics:\n metric_name, metric_function = metric\n self[metric_name] = metric_function\n return self",
"def add_metrics(self, metrics):\n for i,metric in enumerate(self.config.metrics):\n tf.summary... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks if player ready to be rendered on the character sheet | def is_player_ready(self):
player = self.base.game_instance['player_ref']
if (player
and base.player_states["is_alive"]
and base.player_states["is_idle"]
and not base.player_states["is_moving"]
and not base.player_states["is_running"]
... | [
"def is_ready(self):\n if self.game.has_started():\n return True\n return self.status == self.PLAYER_READY",
"def ready(self):\n return self.shader is not None and self.texturesReady()",
"def ready(self):\n return self.shader is not None and self.textureReady()",
"def ch... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Run the script at given path catching exceptions. This function should only be used internally by Pyto. | def runScriptAtPath(path):
sys.argv = [path]
for arg in PytoClasses.Python.shared.args:
sys.argv.append(str(arg))
def run() -> None:
os.system = PytoClasses.Python.shared.system
directory = os.path.expanduser(os.path.dirname(path))
sys.path.insert(0, directory)
... | [
"def run_file(file_path, globals_, script_dir=SCRIPT_DIR):\n fix_sys_path()\n script_name = os.path.basename(file_path)\n script_name = SCRIPT_EXCEPTIONS.get(script_name, script_name)\n script_path = os.path.join(script_dir, script_name)\n execfile(script_path, globals_)",
"def script(self, path):\n e... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Expected defaults when no project exists | def test_no_project_defaults(self):
ep = exposed.ExposedProject()
self.assertIsNone(ep.display)
self.assertIsNone(ep.shared)
self.assertIsNone(ep.settings)
self.assertIsNone(ep.title)
self.assertIsNone(ep.id)
self.assertIsNone(ep.path())
with self.assertR... | [
"def test_get_project(self):\n pass",
"def _determine_default_project(project=None):\n if project is None:\n project = _get_gcd_project()\n\n if project is None:\n project = _helpers._determine_default_project(project=project)\n\n return project",
"def test_project(self):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Should abort stopping and not raise an error when no internal step is available to stop. | def test_step_stop_aborted(self, _step: PropertyMock):
_step.return_value = None
es = exposed.ExposedStep()
es.stop() | [
"def abort(self):\n self.__stop()",
"def _force_stop(self):\n if self.force_stop_func(instance=self.instance):\n self.force_stop_func(instance=self.instance, _set=True)\n raise StoppedException",
"def _gracefully_stop(self):\n pass",
"def test_v1_stop(self):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Should abort stopping and not raise an error when no internal project is available to stop. | def test_project_stop_aborted(self, get_internal_project: MagicMock):
get_internal_project.return_value = None
ep = exposed.ExposedProject()
ep.stop() | [
"def stopBuild(reason=\"<no reason given>\"):",
"def _gracefully_stop(self):\n pass",
"def abort(self):\n self.__stop()",
"def test_provider_project_development_stop(self):\n pass",
"def stopSolution(self):\n raise NotImplementedError",
"def test_v1_stop(self):\n pass",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Should fail to get internal project and return None after eventually timing out. | def test_get_internal_project_fail(
self,
sleep: MagicMock,
time_time: MagicMock,
internal_project: PropertyMock
):
project = exposed.ExposedProject()
time_time.side_effect = range(20)
internal_project.return_value = None
result = proje... | [
"def test_get_project(self):\n pass",
"def get_project(con):\n try:\n return con.project_read(fq_name=conf.get('default_project', 'UNEXPECTED_VALUE'))\n except:\n log.debug('Unable to find project default-domain, admin:', exc_info=True)\n return None",
"def Project(self):\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Should write to the console using a write_source function call on the internal step report's stdout_interceptor. | def test_write_to_console(self, _step: PropertyMock):
trials = [2, True, None, 'This is a test', b'hello']
for message in trials:
_step_mock = MagicMock()
write_source = MagicMock()
_step_mock.report.stdout_interceptor.write_source = write_source
_step.re... | [
"def test_render_to_console(self, _step: PropertyMock):\n message = ' {{ a }} is not {{ b }}.'\n\n _step_mock = MagicMock()\n write_source = MagicMock()\n _step_mock.report.stdout_interceptor.write_source = write_source\n _step.return_value = _step_mock\n step = exposed.E... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Should render to the console using a write_source function call on the internal step report's stdout_interceptor. | def test_render_to_console(self, _step: PropertyMock):
message = ' {{ a }} is not {{ b }}.'
_step_mock = MagicMock()
write_source = MagicMock()
_step_mock.report.stdout_interceptor.write_source = write_source
_step.return_value = _step_mock
step = exposed.ExposedStep()... | [
"def test_write_to_console(self, _step: PropertyMock):\n trials = [2, True, None, 'This is a test', b'hello']\n\n for message in trials:\n _step_mock = MagicMock()\n write_source = MagicMock()\n _step_mock.report.stdout_interceptor.write_source = write_source\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Should raise a ValueError when there is no current step to operate upon by the write function call. | def test_write_to_console_fail(self, _step: PropertyMock):
_step.return_value = None
step = exposed.ExposedStep()
with self.assertRaises(ValueError):
step.write_to_console('hello') | [
"def save_step(self, step: 'BaseTransformer', context: 'CX') -> 'BaseTransformer':\n raise NotImplementedError()",
"def bad_step(self):\n assert False, \"This step is meant to fail.\"",
"def save_to_file(self, iter_num, iter_step):\n if iter_num%iter_step==0:\n current_date = datetim... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Should render an empty stack frame when the stack data is invalid. | def test_render_stop_display_error(
self,
get_formatted_stack_frame: MagicMock,
render_template: MagicMock
):
get_formatted_stack_frame.return_value = None
step = MagicMock()
exposed.render_stop_display(step, 'FAKE')
self.assertEqual({}, render_tem... | [
"def stack_bad(self):\n self.dyn_stack_current_state = STACK_STATE_BAD",
"def is_stack_empty(self):\n if self.stack.__len__() == 0:\n return True\n else:\n return False",
"def test_empty_stack() -> None:\n with raises(GrammarParseError):\n grammar_parser.pars... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Calculates % of alphanumeric characters in string. | def _alnum_percent(line):
total = len(line)
test_set = set()
for letter in string.ascii_letters:
test_set.add(letter)
test_set.add(' ')
# Return a failure (no good characters) if there are no characters
if total < 1:
return 0
alnum_count = 0
star_count = 0
bar_count = 0
for letter in line... | [
"def letter_percent(s):\r\n\r\n alpha = 'abcdefghijklmnopqrstuvwxyz'\r\n s_lower = s.lower()\r\n s_length = 0\r\n letter_count = {} # empty dictionary\r\n keys = letter_count.keys()\r\n\r\n for char in s_lower:\r\n if char in alpha:\r\n s_length = s_length + 1\r\n if ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Analyzes text lines, in order read from OCR processing. Populates the MailFields object with information gathered from OCR. Uses information from each of the lines to best figure out who is the main addresssee and which box it is trying to reach. | def parse_text_lines(self, text_lines):
self.__fields = mail_fields.MailFields()
alphanum_threshold = 0.5
# Only evaluate lines that are predominantly alphanumeric
for line in text_lines:
if _alnum_percent(line) > alphanum_threshold:
try:
parsed = usaddress.tag(line)[0]
... | [
"def readFile(self):\n \n doc = self.__openFile() #Get opened file from __openFile()\n readDoc = doc.read() #Read document contents\n message = email.message_from_string(readDoc) #Get message object from string\n\n #Get the body of the message\n mBody = message.get_payload(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test the clear method works for posixbased systems | def test_clear_posix(self):
with mock.patch("hangman.cli.screen.os.system") as mock_system:
hangman.cli.screen.Screen.clear()
mock_system.assert_called_with("clear") | [
"def clearscreen():\n if os.name == 'nt':\n os.system('cls')\n elif os.name == 'posix':\n os.system('clear')\n else:\n print \"Untested OS. Please tell the developer you're on: %s\" % os.name \n sys.exit(0)",
"def clear_screen():\n if sys.platform == \"linux\" or sys.platf... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test the goodbye method | def test_goodbye(self):
with mock.patch("builtins.print") as mock_print:
hangman.cli.screen.Screen.goodbye()
output = ",".join([str(x) for x in mock_print.call_args_list])
self.assertTrue("Goodbye" in output) | [
"def test_program_quit(self):\n d = CommandLineInterface(donors_test)\n with self.assertRaises(SystemExit):\n d.quit_the_program()\n del d",
"def test_stop(self):\n pass",
"def test_quit_game(run):\n out, _ = run(dork.cli.quit_game)\n assert \"Thank you\" in out",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the total number of hives in this apiary. | def hives_count(self) -> int:
return self.hives.count() | [
"def total_number_of_animals(self):\n animals = self.animal()\n print 'Total number of animals on island: {:4}'.format(\n animals[\"Herbivores\"] + animals[\"Carnivores\"])",
"def count_hp(self):\n print(self.character_class.hp, count_att_bonus(self.constitution))\n return s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Convenience method which overrides the call method to call the getExpansion function | def __call__(self, data):
return self.getExpansion(data) | [
"def applyExpansion(self, coem):\n pass",
"def expand(self) -> Callable[\n [gs_echo.ExpandRequest],\n gs_echo.EchoResponse]:\n # Generate a \"stub function\" on-the-fly which will actually make\n # the request.\n # gRPC handles serialization and deserialization, s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Imports a database from the tmp directory. Use very carefully! (or just to remind yourself how to import mysql data) Modify this code directly if needed, as it hardwires the username, db name and filename. | def mysql_import():
# first make another copy of the db
run("mysqldump -u database_user database_name -p > ~/tmp/exported_db_temp.sql")
# then import from the backup
run("mysql -u database_user -p -D database_name < ~/tmp/exported_db.sql") | [
"def import_remote_db():\n run_export_db()\n run_download_db()\n drop_db()\n create_db()\n import_db()\n reset_passwords()",
"def import_database(filename):\n local('pg_restore -O -c -U pyconsg -d pyconsg {0}'.format(filename))",
"def import_db(self, mysql_dump):\n print('Importing m... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Set up an ssh shortcut. Called by setup_ssh_keys. You can call it separately if desired. | def update_ssh_shortcut(output_keyfile, quickname=None):
if quickname:
with settings(warn_only=True):
local("touch $HOME/.ssh/config")
local(r"echo '' >> $HOME/.ssh/config")
local(r"echo 'Host %s' >> $HOME/.ssh/config" % quickname)
local(r"echo '' >> $HOME/.ssh/config")
... | [
"def setup_ssh(public_key: Union[str, List[str]], mattermost_webhook_address: Optional[str] = None):\n public_key = parse_public_key(public_key)\n\n if not check_gpu_available():\n return # pragma: no cover\n\n # Config password for root user\n msg = \"\"\n msg = config_root_password(msg)\n\n... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generate a new SSH key and deliver it to the server. If quickname is provided, also set up an ssh shortcut. Use this to enable passwordless access to webfaction. | def setup_ssh_keys(output_keyfile="id_rsa", ssh_type="rsa", quickname=None):
with settings(warn_only=True):
local("mkdir -p $HOME/.ssh")
with cd("$HOME/.ssh"):
local("ssh-keygen -t %s -f %s" % (ssh_type, output_keyfile))
for host in env.hosts:
local("scp %s.pub %s:temp_id_key... | [
"def update_ssh_shortcut(output_keyfile, quickname=None):\n if quickname:\n with settings(warn_only=True):\n local(\"touch $HOME/.ssh/config\")\n local(r\"echo '' >> $HOME/.ssh/config\")\n local(r\"echo 'Host %s' >> $HOME/.ssh/config\" % quickname)\n local(r\"echo '' >> $HO... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Installs pip itself if needed. | def install_pip():
with settings(warn_only=True):
run('mkdir $HOME/lib/python2.7')
run('easy_install-2.7 pip') | [
"def install_pip():\n if sys.version_info[0] < 3: # We are running python 2.x\n cmd = ['python -m easy_install pip']\n process = subprocess.Popen(cmd, shell=True)\n process.wait()\n process.poll()\n if process.returncode is 0:\n print('Successfully installed pip')\n return 0\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a new git repo on the server (do not include the .git ending in git_repo_name) | def create_prod_git_repo(git_repo_name):
with cd(git_dir):
run("git init --bare %s.git && cd %s.git && git config http.receivepack true" %
(git_repo_name,git_repo_name)) | [
"def cmd_create(self):\n self.repo.create()\n\n # Add .gitignore.\n self.repo.add_files({'.gitignore': '.swp\\n'}, FIRST_COMMIT_MSG)\n\n # Create the etc and timestamps branches.\n self.repo.checkout('etc', create=True)\n self.repo.checkout('timestamps', create=True)\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds the git repo on the server as the local .git repo's origin, and pushes master to it. (do not include the .git ending in git_repo_name) | def add_prod_repo_as_origin_and_push(git_repo_name):
local("""echo '[remote "origin"]' >> .git/config""")
local(r"echo ' fetch = +refs/heads/*:refs/remotes/origin/*' >> .git/config")
local(r"echo ' url = %s:webapps/git/repos/%s.git' >> .git/config" % (env.hosts[0], git_repo_name))
local(r"... | [
"def push(self):\n origin = self.git_repo.remotes.origin\n origin.push()",
"def push(self):\n pass # push will happen at workspace level\n # actions.call_subprocess([GIT_EXE_PATH, 'push', 'origin', 'master'],\n # cwd=self.local_path, verbose=self.verbose... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Updates the apache httpd.conf file to point to the new project instead of the default 'myproject'. This is called as part of clone_into_project, or you can call | def update_conf_file():
filepath = remote_dir + "/apache2/conf/httpd.conf"
fabric.contrib.files.sed(filepath, 'myproject', project_name) | [
"def set_apache_config():\n # Delete the existing default config file.\n if exists(\"/etc/apache2/sites-enabled/000-default.conf\"):\n run(\"rm /etc/apache2/sites-enabled/000-default.conf\")\n\n with cd(\"/etc/apache2/sites-enabled/\"):\n run(\"ln -sf /app/workshop-php-bootstrap/support/apach... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Clones the git repo into the new webapp, deleting the default myproject project and updating the config file to point to the new project. Also adds a site_settings.py file to the project/project folder. | def clone_into_project(git_repo_name):
repo_dir = git_dir + "/%s.git" % git_repo_name
with cd(remote_dir):
run('rm -rf myproject')
run("git clone %s %s" % (repo_dir, project_name))
run("echo 'MY_ENV=\"prod\"' > %s/%s/site_settings.py" % (project_name,project_name))
update_conf_file() | [
"def newproject():\n log('Criando novo projeto', yellow)\n log('Cria a conta no bitbucket com o nome do projeto vázio que o script se encarregará do resto', red)\n\n conta = raw_input('Digite o nome do projeto: ')\n\n local('echo \"clonando projeto %s\"' % bitbucket_repository)\n local('git clone {0}... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds the "/static" and "/media" directories to the static webapp if needed, and deletes the default index.html. Also adds a project/project/static directory if there isn't one. | def add_dirs_to_static(static_webapp_name):
static_dir = '$HOME/webapps/%s' % static_webapp_name
with settings(warn_only=True):
with cd(static_dir):
run("mkdir static && mkdir media")
run("rm index.html")
run("touch index.html")
with cd(code_dir):
... | [
"def ensure_static_exists():\n for entry in html_static_path:\n static_path = os.path.join(__repo_docs__, entry)\n if not os.path.isdir(static_path):\n os.makedirs(static_path)",
"def setup_statics(project, frontend):\n # Create JS Static structure\n static_path = '{}/static/js'.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Initialises the database to contain the tables required for DjangoCMS with South. Runs syncdb all and migrate fake. | def initialise_database():
with cd(code_dir):
run(python_add_str + "python manage.py syncdb --all")
run(python_add_str + "python manage.py migrate --fake") | [
"def setup_database():\n from django.core.management import call_command\n from django import setup\n setup()\n call_command('migrate', verbosity=0, interactive=False)\n call_command('loaddata', data('initial_data.json'), verbosity=0, interactive=False)",
"def initialize_test_db(self):\n # C... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Binary mask from cv2 styled contour (gets filled) | def make_mask(shape, contour):
mask = np.zeros(shape, np.int32)
cv2.drawContours(mask, [contour], 0, (255), -1)
return mask | [
"def get_contour_features(mask,selectcell=\"centered\"):\r\n \r\n #binarize image (everything above 0 becomes 1)\r\n mask = np.clip(mask,a_min=0,a_max=1)\r\n\r\n #for contours, dont use RETR_TREE, but RETR_EXTERNAL as we are not interested in internal objects\r\n contours, _ = cv2.findContours(mask, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Converts either bytes or unicode to `bytes`, using utf8 encoding for text. | def as_bytes(bytes_or_text, encoding='utf-8'):
if isinstance(bytes_or_text, _six.text_type):
return bytes_or_text.encode(encoding)
elif isinstance(bytes_or_text, bytes):
return bytes_or_text
else:
raise TypeError('Expected binary or unicode string, got %r' %
(... | [
"def utf8_bytes(text):\n if not isinstance(text, bytes):\n return text.encode('utf-8')\n return text",
"def _to_bytes(value: Union[str, bytes]) -> bytes:\n return value if isinstance(value, bytes) else value.encode(\"utf-8\")",
"def ensure_utf8_bytes(v: Union[str, bytes]) -> bytes:\n if isins... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the file system path representation of a `PathLike` object. | def path_to_str(path):
if hasattr(path, '__fspath__'):
path = as_str_any(path.__fspath__())
return path | [
"def stringify_pathlike(pathlike):\n maybe_pathlike_str = (\n pathlike.__fspath__() if hasattr(pathlike, \"__fspath__\") else pathlike\n )\n\n return maybe_pathlike_str",
"def as_path(path: PathLike) -> Path:\n msg = py_utils.dedent(\"\"\"\n `tfds.core.as_path` is deprecated. Pathlib API has... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds a node to the front of the list with value 'val' | def push_front(self, val):
new_node = Node(val, self.head)
if self.is_empty():
self.tail = new_node
self.head = new_node
self.size += 1 | [
"def insert_before(self, val, new_value):\n\n current = self.head\n\n if current.val is val:\n self.insert(new_value)\n else:\n while current.next.val is not val:\n current = current.next\n\n new_node = Node(new_value, current.next)\n #... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds a node to the back of the list with value 'val' | def push_back(self, val):
new_node = Node(val)
# Update current head and tail, if necessary
if self.is_empty():
self.head = new_node
else:
self.tail.next_node = new_node
# new_node is now the tail
self.tail = new_node
self.size += 1 | [
"def push_back(self, val: Generic[T]) -> None:\n return insert(self,self.node.next,val)",
"def addAtTail(self, val):\n if self.head is None:\n self.addAtHead(val)\n else:\n new_node = Node(val)\n curr = self.head\n while (curr.next is not None):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
get a post given its title | def get(self, title):
post = get_a_post(title)
if not post:
api.abort(404)
else:
return post | [
"def getPost(title):\n try:\n path = os.path.join(\"data\",title)\n if not os.path.isfile(path):\n raise PostDoesNotExist(title)\n \n except PostDoesNotExist:\n print \"PostDoesNotExist\"\n pass\n \n else:\n datafile = open(path, mode=\"rb\")\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Reinvite an already invited user. | def reinvite_user(self, user, email):
if self.is_moderator and self.has_perm('accounts.invite_user'):
# Reset email, set a new token and update decision datetime
user.email = email
user.auth_token = generate_unique_id()
user.decision_datetime = timezone.now()
... | [
"def invited_user(self, invited_user):\n self._invited_user = invited_user",
"def resend_invite(id):\n invite = s.query(Invites). \\\n filter(Invites.id==id). \\\n first()\n\n send_mail_unknown(invite.email, \"Register for CompetenceDB\",\n 'You are invited to regis... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Approve a user's application | def approve_user_application(self, user):
if self.is_moderator and \
self.has_perm('accounts.approve_user_application'):
user.moderator = self
user.moderator_decision = user.APPROVED
user.decision_datetime = timezone.now()
user.auth_token = generate_uni... | [
"def approve_application(request, application_pk):\n application = get_object_or_404(\n teambuilder_models.Application, pk=application_pk)\n developer = application.applicant\n application.approve()\n email.send_email(\n 'Your application was approved!',\n '''Hello {}!\n Than... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Reject a user's application | def reject_user_application(self, user):
if self.is_moderator \
and self.has_perm('accounts.reject_user_application'):
user.moderator = self
user.moderator_decision = user.REJECTED
user.decision_datetime = timezone.now()
user.save()
return ... | [
"def reject_application(request, application_pk):\n application = get_object_or_404(\n teambuilder_models.Application, pk=application_pk)\n developer = application.applicant\n application.reject()\n email.send_email(\n 'Your application was rejected!',\n '''Hello {}!\n Thank ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return a user's profiency in a particular skill as a percentage, based on the position of the proficiency in PROFICIENCY_CHOICES. | def get_proficiency_percentage(self):
choice_values = [choice[0] for choice in self.PROFICIENCY_CHOICES]
if '' in choice_values:
choice_values.remove('') # Remove the empty proficiency choice
choice_values.sort() # Ensure values are in the correct order
value = choice_valu... | [
"def get_opinion_percent(self):\n return (self.get_percent()+100)/2",
"def female_pct(self) -> float:\n return sum([p.sex_female for p in self.pop]) / self.starting_population",
"def setup_proficiencies(self):\n Proficiency.objects.create(name='starter', needed_percentage=0)\n Profic... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Generate the preparation files for the projects in a run | def format_preparation_files(run_dir, sample_sheet, output_dir, pipeline,
verbose):
sample_sheet = KLSampleSheet(sample_sheet)
df_sheet = sample_sheet_to_dataframe(sample_sheet)
if pipeline == 'atropos-and-bowtie2':
click.echo('Stats collection is not supported for pipe... | [
"def newproject(self):\n \n self.path = os.path.join(self.base, self.name)\n subpath = os.path.join(self.path, self.lowname)\n check_build_path(subpath)\n \n for filename, content in self.files.items():\n self.buildfile(filename, content, self.path)\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return tokenized list of strings from raw text input using keras functionality | def tokenize_keras(raw_data):
from keras.preprocessing.text import text_to_word_sequence
return [text_to_word_sequence(d) for d in raw_data] | [
"def _text_tokenize(input_data: Mapping[str, tf.Tensor]) -> tf.Tensor:\n input_str = tf.reshape(input_data['translation'], shape=[1])\n standard_text = _text_standardization(input_str)\n return tf.strings.split(standard_text)",
"def _batch_tokenize(self, text: List[str]) -> List[List[str]]:\n return sel... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return True if word passes filter | def filter1(word):
if not word: return False
w = word.lower()
if w in STOPWORDS: return False
return True | [
"async def wordfilter(self, ctx):\n pass",
"async def wordfilter_test(self, ctx, *, message):\n found = self.test_sentence(message)\n if found:\n await ctx.send(f\"Message contains `{found}`\")\n else:\n await ctx.send(\"Couldn't detect any filtered words\")",
"... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return dict of wordtoid from raw text data If max_size is specified, vocab is truncated to set of highest frequency words within size. | def build_vocab(raw_data, max_size=None):
data = [w for doc in tokenize_keras(raw_data) for w in doc]
counter = collections.Counter(data)
count_pairs = sorted(counter.items(),
key=lambda x: (-x[1], x[0]))
if max_size: count_pairs = count_pairs[:max_size]
words, _ = list(zip(... | [
"def embeddings_to_dict(path, max_words=None):\n w2v = {} \n with codecs.open(path,\"r\",\"utf-8\") as fid:\n #ignore first line\n fid.readline() \n #avoid extra comparisons if we want load all the words\n if max_words is None:\n for line in fid:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Convert raw text data into integer ids | def raw_to_ids(raw_data, word_to_id):
docs = tokenize_keras(raw_data)
uid = word_to_id[UNKNOWN_WORD]
return [[word_to_id.get(w, uid) for w in doc] for doc in docs] | [
"def map_text_to_id(self, text: str) -> List[int]:\n return self.map_token_to_id(self.map_text_to_token(text))",
"def text_to_ids(source_text, target_text, source_vocab_to_int, target_vocab_to_int):\n source_id_text = []\n target_id_text = []\n for text in source_text.split('\\n'):\n source... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
callback for when the detector has found a stop sign. Note that a distance of 0 can mean that the lidar did not pickup the stop sign at all | def stop_sign_detected_callback(self, msg):
# distance of the stop sign
corners = msg.corners
dx = corners[3] - corners[1]
dy = corners[2] - corners[0]
r = dx/dy # aspect ratio
rdist = np.array([.15, .20, .25, .30,.35, .40, .45, .50])
pixelheight = np.array([13... | [
"def stop_sign_detected_callback(self, msg):\n\n # distance of the stop sign\n # print \"Stop Sign Destected\"\n dist = msg.distance\n # if self.mode==Mode.TRACK:\n # if close enough and in nav mode, stop\n if dist > 0 and dist < self.stop_min_dist and self.mode == Mode.TRA... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Custom collate_fn that is called with list of multivariate samples to yield a minibatch It preserves the data structure, e.g., if each sample is a dictionary, it outputs a dictionary with the same set of keys but batched Tensors as values (or lists if the values can not be converted into Tensors). | def collate_fn(sample_list):
x_ref_batch = []
x_pos_batch = []
x_negs_batch = []
label_batch = []
for sample in sample_list:
x_ref_batch.append(sample["x_ref"])
x_pos_batch.append(sample["x_pos"])
x_negs_batch.append(sample["x_negs"])
label_batch.append(sample["label... | [
"def collate_fn(batch):\n metadata = []\n for el in batch:\n metadata.append(el[\"metadata\"])\n del el[\"metadata\"]\n\n batch = default_collate(batch)\n\n batch[\"metadata\"] = metadata\n\n return batch",
"def collate_fn(batch):\n data = [item[0] for item in batch]\n target = ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Import a function from a full module path | def import_from(full_name):
module_name, function_name = full_name.rsplit('.', 1)
mod = import_module(module_name)
return getattr(mod, function_name) | [
"def import_function(func_ref):\n module_name, _, func_name = func_ref.rpartition('.')\n module = importlib.import_module(module_name)\n return getattr(module, func_name)",
"def import_function(name):\n module_name, function_name = name.rsplit(\".\", 1)\n module = importlib.import_module(module_nam... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a new Bloom Filter ``key`` with desired probability of false positives ``errorRate`` expected entries to be inserted as ``capacity``. Default expansion value is 2. By default, filter is autoscaling. | def bfCreate(self, key, errorRate, capacity, expansion=None, noScale=None):
params = [key, errorRate, capacity]
self.appendExpansion(params, expansion)
self.appendNoScale(params, noScale)
return self.execute_command(self.BF_RESERVE, *params) | [
"def cfCreate(self, key, capacity, expansion=None, bucket_size=None, max_iterations=None):\n params = [key, capacity]\n self.appendExpansion(params, expansion)\n self.appendBucketSize(params, bucket_size)\n self.appendMaxIterations(params, max_iterations)\n\n return self.execute_c... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds to a Bloom Filter ``key`` an ``item``. | def bfAdd(self, key, item):
params = [key, item]
return self.execute_command(self.BF_ADD, *params) | [
"def add(key, item):\n hash_key = hash_function(key)\n hash_table[hash_key - 1] = item",
"def cfAdd(self, key, item):\n params = [key, item]\n \n return self.execute_command(self.CF_ADD, *params)",
"def add_item(self, key, item):\n self.dict[key] = item\n self.is_empty =... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds to a Bloom Filter ``key`` multiple ``items``. If ``nocreate`` remain ``None`` and ``key does not exist, a new Bloom Filter ``key`` will be created with desired probability of false positives ``errorRate`` and expected entries to be inserted as ``size``. | def bfInsert(self, key, items, capacity=None, error=None, noCreate=None, expansion=None, noScale=None):
params = [key]
self.appendCapacity(params, capacity)
self.appendError(params, error)
self.appendExpansion(params, expansion)
self.appendNoCreate(params, noCreate)
self.... | [
"def bfAdd(self, key, item):\n params = [key, item]\n \n return self.execute_command(self.BF_ADD, *params)",
"def add(self, key):\n\t\t#super(CountingBloomFilter, self).add(key)\n\t\t#super(CountingBloomFilter, self).generateStats()\n\t\tfor i in self.getBitArrayIndices(key):\n\t\t\tself.ba[i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks whether an ``item`` exists in Bloom Filter ``key``. | def bfExists(self, key, item):
params = [key, item]
return self.execute_command(self.BF_EXISTS, *params) | [
"def item_has_key(self, item, key):\n if key in self._reverse_store[item]:\n return True\n else:\n return False",
"def has_item(self, item):\n return item in self.set",
"def cfExists(self, key, item):\n params = [key, item]\n \n return self.execute... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks whether ``items`` exist in Bloom Filter ``key``. | def bfMExists(self, key, *items):
params = [key]
params += items
return self.execute_command(self.BF_MEXISTS, *params) | [
"def bfExists(self, key, item):\n params = [key, item]\n \n return self.execute_command(self.BF_EXISTS, *params)",
"def item_has_key(self, item, key):\n if key in self._reverse_store[item]:\n return True\n else:\n return False",
"def has_item(self, item):... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Begins an incremental save of the bloom filter ``key``. This is useful for large bloom filters which cannot fit into the normal SAVE and RESTORE model. The first time this command is called, the value of ``iter`` should be 0. This command will return successive (iter, data) pairs until (0, NULL) to indicate completion. | def bfScandump(self, key, iter):
params = [key, iter]
return self.execute_command(self.BF_SCANDUMP, *params) | [
"def cfScandump(self, key, iter):\n params = [key, iter]\n \n return self.execute_command(self.CF_SCANDUMP, *params)",
"def flush(self, key=None):\n raise NotImplementedError",
"def save(self) -> dict:\n for pair in self._buffer:\n yield pair.save()",
"def _iter(s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a new Cuckoo Filter ``key`` an initial ``capacity`` items. | def cfCreate(self, key, capacity, expansion=None, bucket_size=None, max_iterations=None):
params = [key, capacity]
self.appendExpansion(params, expansion)
self.appendBucketSize(params, bucket_size)
self.appendMaxIterations(params, max_iterations)
return self.execute_command(self... | [
"def from_key(cls, key, quantity=1):\n\n return cls(key[0], key[1], quantity)",
"def bfCreate(self, key, errorRate, capacity, expansion=None, noScale=None):\n params = [key, errorRate, capacity]\n self.appendExpansion(params, expansion)\n self.appendNoScale(params, noScale)\n\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds an ``item`` to a Cuckoo Filter ``key``. | def cfAdd(self, key, item):
params = [key, item]
return self.execute_command(self.CF_ADD, *params) | [
"def bfAdd(self, key, item):\n params = [key, item]\n \n return self.execute_command(self.BF_ADD, *params)",
"def add_item(self, key, item):\n self.dict[key] = item\n self.is_empty = False",
"def _m_add_items_filter(filter):",
"def add_item(self, key, item):\n self[ke... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds multiple ``items`` to a Cuckoo Filter ``key``, allowing the filter to be created with a custom ``capacity` if it does not yet exist. ``items`` must be provided as a list. | def cfInsert(self, key, items, capacity=None, nocreate=None):
params = [key]
self.appendCapacity(params, capacity)
self.appendNoCreate(params, nocreate)
self.appendItems(params, items)
return self.execute_command(self.CF_INSERT, *params) | [
"def _m_add_items_filter(filter):",
"def add_items(self, *items):\n self.items.extend(items)",
"def append_items(params, items):\n params.extend([\"ITEMS\"])\n params += items",
"def cfAdd(self, key, item):\n params = [key, item]\n \n return self.execute_command(self.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Checks whether an ``item`` exists in Cuckoo Filter ``key``. | def cfExists(self, key, item):
params = [key, item]
return self.execute_command(self.CF_EXISTS, *params) | [
"def bfExists(self, key, item):\n params = [key, item]\n \n return self.execute_command(self.BF_EXISTS, *params)",
"def item_has_key(self, item, key):\n if key in self._reverse_store[item]:\n return True\n else:\n return False",
"def has_item(self, item):... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Deletes ``item`` from ``key``. | def cfDel(self, key, item):
params = [key, item]
return self.execute_command(self.CF_DEL, *params) | [
"def delete_item(self, item_id):\n pass",
"def delete_item(self, item):\r\n item.delete_item_from_room(self)",
"def __delitem__(self, key):\r\n self.client.delete(id=key, ignore=[404], **self.kwargs)",
"def delete_dynamo_item(dynamo_client, *, table_name, key):\n dynamo_client.delete_i... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Begins an incremental save of the Cuckoo filter ``key``. This is useful for large Cuckoo filters which cannot fit into the normal SAVE and RESTORE model. The first time this command is called, the value of ``iter`` should be 0. This command will return successive (iter, data) pairs until (0, NULL) to indicate completio... | def cfScandump(self, key, iter):
params = [key, iter]
return self.execute_command(self.CF_SCANDUMP, *params) | [
"def bfScandump(self, key, iter):\n params = [key, iter]\n \n return self.execute_command(self.BF_SCANDUMP, *params)",
"def flush(self, key=None):\n raise NotImplementedError",
"def save(self) -> dict:\n for pair in self._buffer:\n yield pair.save()",
"def _iter(s... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Initializes a CountMin Sketch ``key`` to dimensions (``width``, ``depth``) specified by user. | def cmsInitByDim(self, key, width, depth):
params = [key, width, depth]
return self.execute_command(self.CMS_INITBYDIM, *params) | [
"def __init__(self, ks=None):\n self.ks = ks\n self.N = ks.N if ks is not None else None\n self.L = ks.d if ks is not None else None\n # pass",
"def __init__(self, size, fill = 0):\n dict.__init__(self)\n\n if fill != -1:\n for x in xrange(size):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Initializes a CountMin Sketch ``key`` to characteristics (``error``, ``probability``) specified by user. | def cmsInitByProb(self, key, error, probability):
params = [key, error, probability]
return self.execute_command(self.CMS_INITBYPROB, *params) | [
"def __init__(self, probability, nodeKeys):\n self.probability = float(probability)\n self.nodeKeys = nodeKeys",
"def set_min_prob(self, disease, probability):\n self.min_probs[disease] = probability",
"def __init__(self, ks=None):\n self.ks = ks\n self.N = ks.N if ks is not N... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Adds/increases ``items`` to a CountMin Sketch ``key`` by ''increments''. Both ``items`` and ``increments`` are lists. Example cmsIncrBy('A', ['foo'], [1]) | def cmsIncrBy(self, key, items, increments):
params = [key]
self.appendItemsAndIncrements(params, items, increments)
return self.execute_command(self.CMS_INCRBY, *params) | [
"def append_items_and_increments(params, items, increments):\n for i in range(len(items)):\n params.append(items[i])\n params.append(increments[i])",
"def inc(self, key, value=1):\n return self.increment({key:value})[key]",
"def incr(x_c, x, inc=1):\n x_c[x] = x_c.get(x, 0... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Merges ``numKeys`` of sketches into ``destKey``. Sketches specified in ``srcKeys``. All sketches must have identical width and depth. ``Weights`` can be used to multiply certain sketches. Default weight is 1. Both ``srcKeys`` and ``weights`` are lists. | def cmsMerge(self, destKey, numKeys, srcKeys, weights=[]):
params = [destKey, numKeys]
params += srcKeys
self.appendWeights(params, weights)
return self.execute_command(self.CMS_MERGE, *params) | [
"def __merge_keys(\n self, kv_src_bucket, kv_dest_bucket, kvs_num=1, filter_exp=None):\n valid_keys_src, deleted_keys_src = kv_src_bucket[\n kvs_num].key_set()\n valid_keys_dest, deleted_keys_dest = kv_dest_bucket[\n kvs_num].key_set()\n\n self.log.info(\"src_kv... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return full list of items in TopK list of ``key```. | def topkList(self, key):
return self.execute_command(self.TOPK_LIST, key) | [
"def sub_key_list(self, keyword, filter = False):\n\n assert keyword in self.key_list(), 'keyword not present: ' + keyword\n sub_head_place = self.pointers[self.keywords.index(keyword)]\n sub_kp = KP(self.fp, sub_head_place)\n return sub_kp.key_list(filter = filter)",
"def get_list(key):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return a new pipeline object that can queue multiple commands for later execution. ``transaction`` indicates whether all commands should be executed atomically. Apart from making a group of operations atomic, pipelines are useful for reducing the backandforth overhead between the client and server. Overridden in order ... | def pipeline(self, transaction=True, shard_hint=None):
p = Pipeline(
connection_pool=self.connection_pool,
response_callbacks=self.response_callbacks,
transaction=transaction,
shard_hint=shard_hint)
return p | [
"def pipeline(self, transaction=True, shard_hint=None):\r\n return AsyncStrictPipeline(\r\n self.connection_pool,\r\n self.response_callbacks,\r\n transaction,\r\n shard_hint)",
"def createPipe(self, transaction):\n pipe = detectPipeClass(transaction.dev, ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
This will return the graph data for the outage module | def get_outage(self):
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR}
if self.equipment == COKE_DRUM_VALUE and self.module == OUTAGE_VALUE:
"""
This will return ... | [
"def get_graph(self) -> dict:\n response = requests.get(self.channel, params=\"get_graph\")\n return json_to_graph(response.content)",
"def get_graph_summary(self):\n\n pass",
"def export_graph(self, graph):\n pass",
"def _graph(self):\n return self._anm.overlay_nx_graphs[se... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return a mock component of a general model. | def mock_component():
component = Mock()
component.free_parameters = flex.double([1.0])
component.free_parameter_esds = None
component.n_params = 1
component.var_cov_matrix = sparse.matrix(1, 1)
return component | [
"def get_mock(self):\n return self.mock",
"def test_get_model_method(self):\n # arrange\n model_manager = ModelManager()\n\n model_manager.load_model(\"tests.mocks.MLModelMock\")\n\n # act\n exception_raised = False\n model = None\n try:\n model =... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Return a mock data manager of a general model. | def mock_data_manager(components):
dm = Mock()
dm.components = components
dm.fixed_components = []
return dm | [
"def setup_dummy_data_manager():\n import repoze.filesafe\n repoze.filesafe._local.manager = mgr = DummyDataManager()\n return mgr",
"def _get_data_manager(self):\n\n ftype = self.conf['General']['save_as']\n if ftype == 'npz':\n return NPZDataManager(self.conf, self.log)\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test for the general multi_active_parameter_manage class. | def test_multi_apm():
components_1 = {
"scale": mock_component(),
"decay": mock_component(),
"absorption": mock_component(),
}
components_2 = {"scale": mock_component(), "decay": mock_component()}
multi_apm = multi_active_parameter_manager(
ScalingTarget(),
[com... | [
"def test_scaling_active_parameter_manager():\n components_2 = {\"1\": mock_scaling_component(2), \"2\": mock_scaling_component(2)}\n scaling_apm = scaling_active_parameter_manager(components_2, [\"1\"])\n assert list(scaling_apm.constant_g_values[0]) == list(\n components_2[\"2\"].calculate_scales(... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test the apm factory for concurrent refinement. | def test_ParameterManagerGenerator_concurrent():
components_1 = {
"scale": mock_component(),
"decay": mock_component(),
"absorption": mock_component(),
}
data_manager = mock_data_manager(components_1)
pmg = ParameterManagerGenerator(
[data_manager],
apm_type=acti... | [
"def test_multiple_factories(self, mocker):\n sdk_ready_flag = threading.Event()\n\n def _init(self, ready_flag, some, auth_api, streaming_enabled, telemetry_runtime_producer, telemetry_init_consumer, sse_url=None):\n self._ready_flag = ready_flag\n self._synchronizer = mocker.Mo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test the apm factory for consecutive refinement. | def test_ParameterManagerGenerator_consecutive():
components_1 = {
"scale": mock_component(),
"decay": mock_component(),
"absorption": mock_component(),
}
data_manager = mock_data_manager(components_1)
data_manager.consecutive_refinement_order = [["scale", "decay"], ["absorption... | [
"def test_multi_apm():\n\n components_1 = {\n \"scale\": mock_component(),\n \"decay\": mock_component(),\n \"absorption\": mock_component(),\n }\n components_2 = {\"scale\": mock_component(), \"decay\": mock_component()}\n\n multi_apm = multi_active_parameter_manager(\n Scal... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Test the scalingspecific parameter manager. | def test_scaling_active_parameter_manager():
components_2 = {"1": mock_scaling_component(2), "2": mock_scaling_component(2)}
scaling_apm = scaling_active_parameter_manager(components_2, ["1"])
assert list(scaling_apm.constant_g_values[0]) == list(
components_2["2"].calculate_scales()
)
asser... | [
"def test_get_measure_parameters(self):\n pass",
"def test_parameters(self):\n self.assert_initialize_driver()\n #reply = self.driver_client.cmd_dvr('get_resource', Parameter.ALL)\n #self.assert_driver_parameters(reply, verify_sample_interval=True)",
"def testingParameters(cal_file =... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Receive a request from the worker work_socket receive a request on this socket timeout if request isn't received by the timeout, raise six.moves.queue.Empty default = blocks forever This polls on both the worker and up_queue sockets and will throw an exception if there is anything available on the upqueue as this indic... | def recv(self, work_socket, timeout=None):
poller = zmq.Poller()
poller.register(self.up_queue_recv_socket, zmq.POLLIN)
poller.register(work_socket, zmq.POLLIN)
for socket, state in poller.poll(timeout):
if socket == self.up_queue_recv_socket and state == ... | [
"def handle_request(self):\n # Support people who used socket.settimeout() to escape\n # handle_request before self.timeout was available.\n timeout = self.socket.gettimeout()\n if timeout is None:\n timeout = self.timeout\n elif self.timeout is not None:\n t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Artificially set up the worker's work socket This sets self.aw.work_socket so that methods other than "run" can be tested in the worker. | def set_work_socket(self):
self.analysis_id = uuid.uuid4().hex
def do_set_work_socket(aw):
aw.work_socket = cellprofiler_core.constants.worker.the_zmq_context.socket(
zmq.REQ
)
aw.work_socket.connect(self.work_addr)
aw.work_request_address... | [
"def setup(self) -> None:\n self.running = True\n self.listen()\n self.start_workers()\n\n # Send server socket to workers.\n assert self.socket is not None\n for work_queue in self.work_queues:\n work_queue[0].send(self.family)\n send_handle(work_queu... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Announce the work address until we get some sort of a request | def send_announcement_get_work_request(self):
self.analysis_id = uuid.uuid4().hex
while True:
self.announce_socket.send_json(((self.analysis_id, self.work_addr),))
try:
return self.awthread.recv(self.work_socket, 250)
except six.moves.queue.Empty:
... | [
"def announceWork(self):\n if self.queens:\n for q in self.queens:\n try:\n q.proxyAnnounceWork(self.name, self.cobraname, self.cobrad.port)\n except Exception as e:\n logger.warning('Queen Error: %s', e)\n\n else:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns the X window id of the window whose title matches regex `title_regex` | def get_window_id(title_regex):
cmd = "wmctrl -l"
logit(cmd)
output = subprocess.check_output(cmd.split()).decode("utf-8").splitlines()
logit(output)
for line in output:
w_id = line.split()[0]
title = line.split(" ", 3)[3]
if re.match(title_regex, title):
return w... | [
"def find_window(title):\n return FindWindow(None, title)",
"def _getWindowsByTitle(title, exact=False):\n matched = []\n windows = Quartz.CGWindowListCopyWindowInfo(Quartz.kCGWindowListExcludeDesktopElements | Quartz.kCGWindowListOptionOnScreenOnly, Quartz.kCGNullWindowID)\n for win in windows:\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure we can't create a student user without academic_ fields. | def test_create_new_student_user_missing_field(self):
data = {
'email': 'John@mailinator.com',
'password': 'test123!',
}
response = self.client.post(
reverse('user-list'),
data,
format='json',
)
self.assertEqual(respon... | [
"def test_create_user_with_missing_attribute(self):\n pass",
"def test_create_user_without_role(self):\n\n role = None\n self.user_data[\"role_id\"] = role\n\n with self.assertRaises(IntegrityError):\n User.objects.create_user(**self.user_data)",
"def test_careers_invalid_... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure we can't create a new user with an invalid phone number | def test_create_new_user_invalid_phone(self):
data = {
'username': 'John',
'email': 'John@mailinator.com',
'password': '1fasd6dq#$%',
'phone': '12345',
'other_phone': '23445dfg',
'first_name': 'Chuck',
'last_name': 'Norris',
... | [
"def test_new_user_invalid_phonenumber(self):\n phonenumber = None\n with self.assertRaises(ValueError):\n get_user_model().objects.create_user(\n 'TestFirstName',\n 'TestMiddleName',\n 'TestLastName',\n phonenumber,\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure we can't list users without authentication. | def test_list_users_without_authenticate(self):
response = self.client.get(reverse('user-list'))
content = {"detail": "Authentication credentials were not provided."}
self.assertEqual(json.loads(response.content), content)
self.assertEqual(response.status_code, status.HTTP_401_UNAUTHOR... | [
"def test_list_users_without_permissions(self):\n self.client.force_authenticate(user=self.user)\n\n response = self.client.get(reverse('user-list'))\n\n content = {\n 'detail': 'You do not have permission to perform this action.'\n }\n self.assertEqual(json.loads(respo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure we can't list users without permissions. | def test_list_users_without_permissions(self):
self.client.force_authenticate(user=self.user)
response = self.client.get(reverse('user-list'))
content = {
'detail': 'You do not have permission to perform this action.'
}
self.assertEqual(json.loads(response.content),... | [
"def test_admin_user_list_all_users_permission_denied(self):\n self.client.logout()\n self.client.login(\n username=self.invalid_user.username,\n password=self.invalid_user.password\n )\n response = self.client.get(CONSTS.USER_ADMIN_LIST)\n self.assertEqual(r... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure we can send notification for membership end | def test_send_notification_end_membership(self):
fixed_time = timezone.now()
end_time_membership = fixed_time + relativedelta(days=28)
self.user.membership = self.membership
self.user.membership_end = end_time_membership
self.user.save()
with mock.patch(
... | [
"def test_admin_approval_complete_email(self):\n new_user = UserModel().objects.create_user(**self.user_info)\n profile = self.registration_profile.objects.create_profile(new_user)\n profile.send_admin_approve_complete_email(Site.objects.get_current())\n self.assertEqual(len(mail.outbox)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure admin can credit tickets to a user | def test_credit_ticket_as_admin(self):
user = UserFactory()
self.assertEqual(user.tickets, 1)
nb_tickets_to_add = 5
data = {
'nb_tickets': nb_tickets_to_add,
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
re... | [
"def test_credit_ticket_as_user(self):\n user = UserFactory()\n self.assertEqual(user.tickets, 1)\n nb_tickets_to_add = 5\n data = {\n 'nb_tickets': nb_tickets_to_add,\n }\n\n self.client.force_authenticate(user=self.user)\n response = self.client.post(\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure user can't credit tickets to a user | def test_credit_ticket_as_user(self):
user = UserFactory()
self.assertEqual(user.tickets, 1)
nb_tickets_to_add = 5
data = {
'nb_tickets': nb_tickets_to_add,
}
self.client.force_authenticate(user=self.user)
response = self.client.post(
reve... | [
"def test_credit_ticket_negative_int(self):\n user = UserFactory()\n self.assertEqual(user.tickets, 1)\n nb_tickets_to_add = -5\n data = {\n 'nb_tickets': nb_tickets_to_add,\n }\n\n self.client.force_authenticate(user=self.admin)\n response = self.client.p... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Ensure admin can't credit negative tickets to a user | def test_credit_ticket_negative_int(self):
user = UserFactory()
self.assertEqual(user.tickets, 1)
nb_tickets_to_add = -5
data = {
'nb_tickets': nb_tickets_to_add,
}
self.client.force_authenticate(user=self.admin)
response = self.client.post(
... | [
"def test_credit_ticket_as_admin(self):\n user = UserFactory()\n self.assertEqual(user.tickets, 1)\n nb_tickets_to_add = 5\n data = {\n 'nb_tickets': nb_tickets_to_add,\n }\n\n self.client.force_authenticate(user=self.admin)\n response = self.client.post(\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Used to generate the beta s for stimulation tests num_part1 + num_part2 = the number of beta s to be nonzero | def gen_beta(self,num_part1=54, num_part2=25,intercept=None):
#intercept
if intercept is not None:
self.intercept = intercept
#part1
num_p1_1 = num_part1 // 8
num_p2_2 = num_part1 - num_p1_1
sep_point = int(num_p2_2 * 0.8)
tmp1 = np.sin([np.pi/(num_p2_... | [
"def evo_blanket(self,beta,alpha): \n evo_blanket = np.zeros(self.state_no)\n for i in range(evo_blanket.shape[0]):\n evo_blanket[i] = self.state_likelihood_markov_blanket(beta,alpha,i).sum()\n\n if self.dist in ['t']:\n evo_blanket = np.append([self.m_likelihood_markov_bl... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns a value in a nested associative structure, where `ks` is a sequence of keys. Returns `None`, if the key is not present, or the `default` value, if supplied. | def get_in(d, ks, default=None):
*ks_, last = ks
d_ = d
for k in ks_:
if type(d_) != dict or k not in d_:
return default
d_ = d_[k]
if type(d_) == dict:
return d_.get(last, default)
return default | [
"def get(\n self, k: SeqStrType, default: Optional[T] = None\n ) -> Union[T, \"NestedDict[T]\"]:\n k = _flatten_index(k)\n\n if k not in self:\n if default is not None:\n return default\n else:\n raise KeyError(k)\n\n data_ptr = self... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Associates a value in a nested associative structure, where `ks` is a sequence of keys and `v` is the new value, and returns a nested structure. If any levels do not exist, `dict`s will be created. | def assoc_in(d, ks, v):
*ks_, last = ks
d_ = d
for k in ks_:
if k not in d_:
d_[k] = {}
d_ = d_[k]
d_[last] = v
return d | [
"def createNestedDict(self, myDict, value, *path):\n for level in path[:-1]:\n myDict = myDict.setdefault(level, {})\n #for level -ends\n dict[path[-1]]=value\n return myDict",
"def _set_nested(self, d, keys, value):\n if len(keys) > 1 and isinstance(d, dict):\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Print a `middleware_name` with a right arrow if `_VERBOSE_MODE` is on. | def _print_inwards(middleware_name):
if _VERBOSE_MODE:
print('{}--->'.format(middleware_name)) | [
"def _print_outwards(middleware_name):\n if _VERBOSE_MODE:\n print('<---{}'.format(middleware_name))",
"def _verboseHeader(self):\n\n if verbose:\n name = self._getName()\n methodName = self._getMethodName()\n\n title = f\"Running {name}.{methodName}\"\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Print a `middleware_name` with a left arrow if `_VERBOSE_MODE` is on. | def _print_outwards(middleware_name):
if _VERBOSE_MODE:
print('<---{}'.format(middleware_name)) | [
"def _print_inwards(middleware_name):\n if _VERBOSE_MODE:\n print('{}--->'.format(middleware_name))",
"def _verboseHeader(self):\n\n if verbose:\n name = self._getName()\n methodName = self._getMethodName()\n\n title = f\"Running {name}.{methodName}\"\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
This function is used to decorate generators with exactly two `yield` statements and turn them into middleware. For examples see documentation to this module and tests. Extra arguments beyond name are passed to the generator that is being decorated during instantiation. If they are not defined during interpretation of ... | def middleware(name, *args, **kwargs):
def new_annotate(g_fn):
def new_middleware(handler):
def new_handler(ctx):
_print_inwards(name)
g = g_fn(ctx, *args, **kwargs)
changed_ctx = next(g)
new_ctx = handler(changed_ctx)
... | [
"def consumer(func):\n\n from functools import wraps\n\n @wraps(func)\n def wrapper(*args,**kw):\n gen = func(*args, **kw)\n gen.next()\n return gen\n return wrapper",
"def writer_wrapper_2(coroutine):\n yield from coroutine",
"def with_outer(*args):\n def generator():\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
This function layers `middleware` left to right around the `handler` and calls it all with `ctx` as an argument. Setting `verbose` to `True` prints when handlers start their before and after sections. | def wrap_and_call(ctx, handler, *middleware, verbose=False):
global _VERBOSE_MODE
_VERBOSE_MODE = verbose
middleware_ = list(middleware)
return compose(*reversed(middleware_))(handler)(ctx) | [
"def _print_inwards(middleware_name):\n if _VERBOSE_MODE:\n print('{}--->'.format(middleware_name))",
"def _print_outwards(middleware_name):\n if _VERBOSE_MODE:\n print('<---{}'.format(middleware_name))",
"def middleware(f):\n @wraps(f)\n def outer(*args):\n def inner(next_dispa... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
converts kml files to open airspace files | def kml_2_open_airspace_and_json_format(self, full_path):
# read file
f = open(full_path,'r')
kml = f.readlines()
f.close()
# find airspaces
"""Placemark >
< name > Bremen - Blumenthal
Thermikplatte < / name >
< styleUrl > # inline10</styleUrl>
... | [
"def keyholemarkup2x(file,output='df'):\n r = re.compile(r'(?<=\\.)km+[lz]?',re.I)\n try:\n extension = r.search(file).group(0) #(re.findall(r'(?<=\\.)[\\w]+',file))[-1]\n \n \n except IOError as e:\n logging.error(\"I/O error {0}\".format(e))\n if (extension.lower()=='kml') is T... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
convert to open airspace format | def make_open_airspace_format(self):
# Extract coordinates from KML
for idxline in range(len(self.kml_lines)):
if '<name>' in self.kml_lines[idxline]:
self.name = self.kml_lines[idxline].replace('\t', '').replace('<name>', '').replace('</name>', '').replace('\n','')
... | [
"def kml_2_open_airspace_and_json_format(self, full_path):\n # read file\n f = open(full_path,'r')\n kml = f.readlines()\n f.close()\n # find airspaces\n \"\"\"Placemark >\n < name > Bremen - Blumenthal\n Thermikplatte < / name >\n < styleUrl > # inlin... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
uses template in order to make kml format | def make_kml_format(self,kml_template):
if self.as_type == 'A':
self.kml_lines = kml_template['good_subdivided']['placemark']
elif self.as_type == 'B':
self.kml_lines = kml_template['bad_subdivided']['placemark']
else:
print('Unknown airspace type')
# ... | [
"def generate_document_kml(self, title, content):\n return \"\"\"\\\n<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<kml xmlns=\"http://earth.google.com/kml/2.1\">\n <Document>\n <name>%s</name>\n <description></description>\n <Style>\n <ListStyle id=\"hideChildren\">\n <listItemType>checkHideCh... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
New() > itkTernaryAddImageFilterID2ID2ID2ID2_Superclass Create a new object of the class itkTernaryAddImageFilterID2ID2ID2ID2_Superclass and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects ... | def New(*args, **kargs):
obj = itkTernaryAddImageFilterID2ID2ID2ID2_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIUL2IUL2IUL2IUL2_Superclass.__New_orig__()\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
itkTernaryAddImageFilterID2ID2ID2ID2_Superclass_cast(itkLightObject obj) > itkTernaryAddImageFilterID2ID2ID2ID2_Superclass | def itkTernaryAddImageFilterID2ID2ID2ID2_Superclass_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterID2ID2ID2ID2_Superclass_cast(*args) | [
"def itkNotImageFilterIF2IF2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_Superclass_cast(obj)",
"def itkNotImageFilterIUS2IUS2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIUS2IUS2_Superclass *\":\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
New() > itkTernaryAddImageFilterID3ID3ID3ID3_Superclass Create a new object of the class itkTernaryAddImageFilterID3ID3ID3ID3_Superclass and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects ... | def New(*args, **kargs):
obj = itkTernaryAddImageFilterID3ID3ID3ID3_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkAddImageFilterID3ID3ID3_Superclass.__New_orig__()\n import itkT... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
itkTernaryAddImageFilterID3ID3ID3ID3_Superclass_cast(itkLightObject obj) > itkTernaryAddImageFilterID3ID3ID3ID3_Superclass | def itkTernaryAddImageFilterID3ID3ID3ID3_Superclass_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterID3ID3ID3ID3_Superclass_cast(*args) | [
"def itkNotImageFilterIF3IF3_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF3IF3_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF3IF3_Superclass_cast(obj)",
"def itkNotImageFilterISS3ISS3_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterISS3ISS3_Superclass *\":\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
New() > itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass Create a new object of the class itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects ... | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterID2ID2ID2ID2_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkAddImageFilterIF2IF2IF2_Superclass.__New_orig__()\n import itkT... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass_cast(itkLightObject obj) > itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass | def itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass_cast(*args):
return _itkTernaryAddImageFilterPython.itkTernaryAddImageFilterIF2IF2IF2IF2_Superclass_cast(*args) | [
"def itkNotImageFilterIF2IF2_Superclass_cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2_Superclass *\":\n return _itkNotImageFilterPython.itkNotImageFilterIF2IF2_Superclass_cast(obj)",
"def cast(obj: 'itkLightObject') -> \"itkNotImageFilterIF2IF2_Superclass *\":\n return _itkNotImageFilterPytho... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
New() > itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass Create a new object of the class itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass and set the input and the parameters if some named or nonnamed arguments are passed to that method. New() tries to assign all the non named parameters to the input of the new objects ... | def New(*args, **kargs):
obj = itkTernaryAddImageFilterIF3IF3IF3IF3_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj | [
"def New(*args, **kargs):\n obj = itkTernaryAddImageFilterID3ID3ID3ID3_Superclass.__New_orig__()\n import itkTemplate\n itkTemplate.New(obj, *args, **kargs)\n return obj",
"def New(*args, **kargs):\n obj = itkAddImageFilterIF3IF3IF3_Superclass.__New_orig__()\n import itkT... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |