Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Using the snippet: <|code_start|> ("git checkout main", "main"),
("git checkout master", "master"),
("git show main", "main"),
],
)
def test_match(script, branch_name, output):
assert match(Command(script, output))
@pytest.mark.parametrize(
"script, branch_name",
[
("git... | assert get_new_command(Command(script, output)) == new_command |
Continue the code snippet: <|code_start|>
@pytest.fixture
def output(branch_name):
if not branch_name:
return ""
output_str = u"error: pathspec '{}' did not match any file(s) known to git"
return output_str.format(branch_name)
@pytest.mark.parametrize(
"script, branch_name",
[
("g... | assert match(Command(script, output)) |
Using the snippet: <|code_start|>
@pytest.mark.parametrize(
'py2, enable_experimental_instant_mode, which, is_instant', [
(False, True, True, True),
(False, False, True, False),
(False, True, False, False),
(True, True, True, False),
(True, True, False, False),
(True... | alias = _get_alias(args) |
Using the snippet: <|code_start|> 'py2, enable_experimental_instant_mode, which, is_instant', [
(False, True, True, True),
(False, False, True, False),
(False, True, False, False),
(True, True, True, False),
(True, True, False, False),
(True, False, True, False)])
def ... | print_alias(known_args) |
Given the following code snippet before the placeholder: <|code_start|>
def _get_alias(known_args):
if six.PY2:
warn("The Fuck will drop Python 2 support soon, more details "
"https://github.com/nvbn/thefuck/issues/685")
alias = shell.app_alias(known_args.alias)
if known_args.enable_... | settings.init(known_args) |
Using the snippet: <|code_start|>
FAILURE: Build failed with an exception.
* What went wrong:
Task '{}' not found in root project 'org.rerenderer_example.snake'.
* Try:
Run gradlew tasks to get a list of available tasks. Run with --stacktrace option to get the stack trace. Run with --info or --debug option to get mor... | Command('./gradlew assembler', output_ambiguous('assembler')), |
Given snippet: <|code_start|>
@pytest.fixture(autouse=True)
def get_all_executables(mocker):
mocker.patch(
"thefuck.rules.wrong_hyphen_before_subcommand.get_all_executables",
return_value=["git", "apt", "apt-get", "ls", "pwd"],
)
@pytest.mark.parametrize("script", ["git-log", "apt-install py... | assert match(Command(script, "")) |
Predict the next line after this snippet: <|code_start|>
@pytest.fixture(autouse=True)
def get_all_executables(mocker):
mocker.patch(
"thefuck.rules.wrong_hyphen_before_subcommand.get_all_executables",
return_value=["git", "apt", "apt-get", "ls", "pwd"],
)
@pytest.mark.parametrize("script", ... | assert get_new_command(Command(script, "")) == new_command |
Given the code snippet: <|code_start|>
@pytest.fixture(autouse=True)
def get_all_executables(mocker):
mocker.patch(
"thefuck.rules.wrong_hyphen_before_subcommand.get_all_executables",
return_value=["git", "apt", "apt-get", "ls", "pwd"],
)
@pytest.mark.parametrize("script", ["git-log", "apt-i... | assert match(Command(script, "")) |
Given the following code snippet before the placeholder: <|code_start|>
@pytest.mark.parametrize('command', [
Command('vim', 'nix-env -iA nixos.vim')])
def test_match(mocker, command):
mocker.patch('thefuck.rules.nixos_cmd_not_found', return_value=None)
<|code_end|>
, predict the next line using imports from t... | assert match(command) |
Predict the next line after this snippet: <|code_start|>
@pytest.mark.parametrize('command', [
Command('vim', 'nix-env -iA nixos.vim')])
def test_match(mocker, command):
mocker.patch('thefuck.rules.nixos_cmd_not_found', return_value=None)
assert match(command)
@pytest.mark.parametrize('command', [
Co... | assert get_new_command(command) == new_command |
Based on the snippet: <|code_start|>
@pytest.fixture
def get_actual_scm_mock(mocker):
return mocker.patch('thefuck.rules.scm_correction._get_actual_scm',
return_value=None)
@pytest.mark.parametrize('script, output, actual_scm', [
('git log', 'fatal: Not a git repository '
... | assert match(Command(script, output)) |
Given the code snippet: <|code_start|> 'hg'),
('hg log', "abort: no repository found in '/home/nvbn/exp/thefuck' "
"(.hg not found)!",
'git')])
def test_match(get_actual_scm_mock, script, output, actual_scm):
get_actual_scm_mock.return_value = actual_scm
assert match(Command(script, ... | new_command = get_new_command(Command(script, '')) |
Continue the code snippet: <|code_start|>
@pytest.fixture
def get_actual_scm_mock(mocker):
return mocker.patch('thefuck.rules.scm_correction._get_actual_scm',
return_value=None)
@pytest.mark.parametrize('script, output, actual_scm', [
('git log', 'fatal: Not a git repository '
... | assert match(Command(script, output)) |
Next line prediction: <|code_start|>
def _get_raw_command(known_args):
if known_args.force_command:
return [known_args.force_command]
elif not os.environ.get('TF_HISTORY'):
return known_args.command
else:
history = os.environ['TF_HISTORY'].split('\n')[::-1]
alias = get_alias... | settings.init(known_args) |
Next line prediction: <|code_start|>
def _get_raw_command(known_args):
if known_args.force_command:
return [known_args.force_command]
elif not os.environ.get('TF_HISTORY'):
return known_args.command
else:
history = os.environ['TF_HISTORY'].split('\n')[::-1]
alias = get_alias(... | corrected_commands = get_corrected_commands(command) |
Predict the next line for this snippet: <|code_start|>
@pytest.fixture
def output():
return '''fatal: tag 'alert' already exists'''
def test_match(output):
<|code_end|>
with the help of current file imports:
import pytest
from thefuck.rules.git_tag_force import match, get_new_command
from thefuck.types import ... | assert match(Command('git tag alert', output)) |
Given the following code snippet before the placeholder: <|code_start|>
@pytest.fixture
def output():
return '''fatal: tag 'alert' already exists'''
def test_match(output):
assert match(Command('git tag alert', output))
assert not match(Command('git tag alert', ''))
def test_get_new_command(output):
<|... | assert (get_new_command(Command('git tag alert', output)) |
Here is a snippet: <|code_start|>
@pytest.fixture
def output():
return '''fatal: tag 'alert' already exists'''
def test_match(output):
<|code_end|>
. Write the next line using the current file imports:
import pytest
from thefuck.rules.git_tag_force import match, get_new_command
from thefuck.types import Command... | assert match(Command('git tag alert', output)) |
Predict the next line after this snippet: <|code_start|>
def test_match():
assert match(Command('git branch list', ''))
def test_not_match():
assert not match(Command('', ''))
assert not match(Command('git commit', ''))
assert not match(Command('git branch', ''))
assert not match(Command('git sta... | assert (get_new_command(Command('git branch list', '')) == |
Given the code snippet: <|code_start|> 'Did you mean one of these?\n'
'\trebase\n'
'\treset\n'
'\tgrep\n'
'\trm'), ['rebase', 'reset', 'grep', 'rm']),
(('tsuru: "target" is not a tsuru command. See "tsuru help".\n'
'\n'
'Did you mean one of these?\n'
'\tservice-add\n'
... | assert is_app(Command(script, ''), *names) == result |
Given the following code snippet before the placeholder: <|code_start|>
@pytest.fixture(autouse=True)
def envs(mocker):
return mocker.patch(
'thefuck.rules.workon_doesnt_exists._get_all_environments',
return_value=['thefuck', 'code_view'])
@pytest.mark.parametrize('script', [
'workon tehfuck'... | assert match(Command(script, '')) |
Based on the snippet: <|code_start|>
@pytest.fixture(autouse=True)
def all_executables(mocker):
return mocker.patch(
'thefuck.rules.missing_space_before_subcommand.get_all_executables',
return_value=['git', 'ls', 'npm', 'w', 'watch'])
@pytest.mark.parametrize('script', [
'gitbranch', 'ls-la',... | assert match(Command(script, '')) |
Here is a snippet: <|code_start|>
@pytest.fixture(autouse=True)
def all_executables(mocker):
return mocker.patch(
'thefuck.rules.missing_space_before_subcommand.get_all_executables',
return_value=['git', 'ls', 'npm', 'w', 'watch'])
@pytest.mark.parametrize('script', [
'gitbranch', 'ls-la', 'n... | assert get_new_command(Command(script, '')) == result |
Given the code snippet: <|code_start|>
@pytest.fixture(autouse=True)
def all_executables(mocker):
return mocker.patch(
'thefuck.rules.missing_space_before_subcommand.get_all_executables',
return_value=['git', 'ls', 'npm', 'w', 'watch'])
@pytest.mark.parametrize('script', [
'gitbranch', 'ls-la... | assert match(Command(script, '')) |
Here is a snippet: <|code_start|>
def test_match():
script = "git push -u origin master"
output = "error: src refspec master does not match any\nerror: failed to..."
<|code_end|>
. Write the next line using the current file imports:
from thefuck.types import Command
from thefuck.rules.git_push_without_commits... | assert match(Command(script, output)) |
Predict the next line after this snippet: <|code_start|>
def test_match():
script = "git push -u origin master"
output = "error: src refspec master does not match any\nerror: failed to..."
assert match(Command(script, output))
def test_not_match():
script = "git push -u origin master"
assert not ... | assert get_new_command(Command(script, output)) == new_command |
Based on the snippet: <|code_start|>
def test_match():
script = "git push -u origin master"
output = "error: src refspec master does not match any\nerror: failed to..."
<|code_end|>
, predict the immediate next line with the help of imports:
from thefuck.types import Command
from thefuck.rules.git_push_withou... | assert match(Command(script, output)) |
Predict the next line for this snippet: <|code_start|>def test_match(script, output_branch_exists):
assert match(Command(script, output_branch_exists))
@pytest.mark.parametrize(
"script",
[
"git branch -a",
"git branch -r",
"git branch -v",
"git branch -d foo",
"git... | assert get_new_command(Command(script, output_branch_exists)) == new_command |
Given the following code snippet before the placeholder: <|code_start|>
@pytest.fixture
def output_branch_exists():
return "fatal: A branch named 'bar' already exists."
@pytest.mark.parametrize(
"script",
[
"git branch 0a",
"git branch 0d",
"git branch 0f",
"git branch 0r... | assert match(Command(script, output_branch_exists)) |
Given snippet: <|code_start|>
@pytest.fixture
def output_branch_exists():
return "fatal: A branch named 'bar' already exists."
@pytest.mark.parametrize(
"script",
[
"git branch 0a",
"git branch 0d",
"git branch 0f",
"git branch 0r",
"git branch 0v",
"git b... | assert match(Command(script, output_branch_exists)) |
Given snippet: <|code_start|>
@pytest.fixture
def output():
return "$: command not found"
@pytest.mark.parametrize(
"script",
[
"$ cd newdir",
" $ cd newdir",
"$ $ cd newdir",
" $ $ cd newdir",
],
)
def test_match(script, output):
<|code_end|>
, continue by predicting ... | assert match(Command(script, output)) |
Continue the code snippet: <|code_start|> ],
)
def test_match(script, output):
assert match(Command(script, output))
@pytest.mark.parametrize(
"command",
[
Command("$", "$: command not found"),
Command(" $", "$: command not found"),
Command("$?", "127: command not found"),
... | assert get_new_command(Command(script, output)) == new_command |
Given the following code snippet before the placeholder: <|code_start|>
@pytest.fixture
def output():
return "$: command not found"
@pytest.mark.parametrize(
"script",
[
"$ cd newdir",
" $ cd newdir",
"$ $ cd newdir",
" $ $ cd newdir",
],
)
def test_match(script, outpu... | assert match(Command(script, output)) |
Given the following code snippet before the placeholder: <|code_start|>
@memoize
def first_0flag(script_parts):
return next((p for p in script_parts if len(p) == 2 and p.startswith("0")), None)
<|code_end|>
, predict the next line using imports from the current file:
from thefuck.shells import shell
from thefuc... | @git_support |
Using the snippet: <|code_start|>
shells.shell = shells.Generic()
def pytest_configure(config):
config.addinivalue_line("markers", "functional: mark test as functional")
def pytest_addoption(parser):
"""Adds `--enable-functional` argument."""
group = parser.getgroup("thefuck")
group.addoption('--ena... | conf.settings.clear() |
Given snippet: <|code_start|>
shells.shell = shells.Generic()
def pytest_configure(config):
config.addinivalue_line("markers", "functional: mark test as functional")
def pytest_addoption(parser):
"""Adds `--enable-functional` argument."""
group = parser.getgroup("thefuck")
group.addoption('--enable-... | conf.settings.update(const.DEFAULT_SETTINGS) |
Here is a snippet: <|code_start|>
class TestGetRawCommand(object):
def test_from_force_command_argument(self):
known_args = Mock(force_command='git brunch')
<|code_end|>
. Write the next line using the current file imports:
import pytest
from mock import Mock
from thefuck.entrypoints.fix_command import _g... | assert _get_raw_command(known_args) == ['git brunch'] |
Predict the next line after this snippet: <|code_start|>
def _kill_process(proc):
"""Tries to kill the process otherwise just logs a debug message, the
process will be killed when thefuck terminates.
:type proc: Process
"""
try:
proc.kill()
except AccessDenied:
logs.debug(u'Re... | proc.wait(settings.wait_slow_command if is_slow |
Continue the code snippet: <|code_start|>
class Rule(types.Rule):
def __init__(self, name='', match=lambda *_: True,
get_new_command=lambda *_: '',
enabled_by_default=True,
side_effect=None,
<|code_end|>
. Use current file imports:
from thefuck import types
from ... | priority=DEFAULT_PRIORITY, |
Based on the snippet: <|code_start|>
class DistanceTest(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(DistanceTest, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
<|code_end|>
, predict the immediate next line with the help of im... | self.pattern = word_pattern.create(self.dna_records.seq_list, 2) |
Using the snippet: <|code_start|>
class DistanceTest(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(DistanceTest, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
self.pattern = word_pattern.create(self.dna_records.seq_list,... | self.counts = word_vector.Counts(self.dna_records.length_list, |
Using the snippet: <|code_start|>
class DistanceTest(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(DistanceTest, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
self.pattern = word_pattern.create(self.dna_records.seq_list,... | dist = distance.Distance(self.counts, 'euclid_squared') |
Based on the snippet: <|code_start|>
class DistanceTest(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(DistanceTest, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
self.pattern = word_pattern.create(self.dna_records.seq_li... | matrix = distmatrix.create(self.dna_records.id_list, dist) |
Given the code snippet: <|code_start|>
class WordVectorTest(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(WordVectorTest, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
<|code_end|>
, generate the next line using the imports in t... | self.pattern1 = word_pattern.create(self.dna_records.seq_list, 1) |
Given the code snippet: <|code_start|>
class WordVectorTest(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(WordVectorTest, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
self.pattern1 = word_pattern.create(self.dna_records... | counts = word_vector.Counts(self.dna_records.length_list, |
Next line prediction: <|code_start|> fh = open(output_filename)
result = fh.read()
fh.close()
os.remove(output_filename)
md5 = calc_md5(result)
return returncode, result, md5
class ScriptsWordCommonTest(ScriptsCommonTest):
@classmethod
def set_te... | cls.dna_records = seqrecords.read_fasta(fh) |
Using the snippet: <|code_start|>
def calc_md5(obj):
return hashlib.md5(str(obj).encode("utf-8")).hexdigest()
def runscript(scriptname, args):
cmd = [scriptname]
for arg in args:
cmd.append(arg)
p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
... | self.assertIn(__version__, out) |
Predict the next line after this snippet: <|code_start|> nuc1 = alphabet[s[i]]
nuc2 = alphabet[s[i + l]]
l_dist_correlations[nuc1][nuc2] += 1
l_dist_correlations /= np.sum(l_dist_correlations)
# Compute the D_{ij}(l) which is the deviation from
# statistical i... | class Distance(distance.Distance): |
Based on the snippet: <|code_start|> (pow(counts[nt] * genlen, k - 1))
templist[nt][i] = tempn
vector.append(np.sum(templist[nt]))
return np.array(vector)
def create_2DSGraphVectors(seq_records):
data = np.zeros(shape=(seq_records.count, 10))
for seqidx, seq ... | class Distance(distance.Distance): |
Given the following code snippet before the placeholder: <|code_start|>
class Test(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(Test, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
<|code_end|>
, predict the next line using impo... | self.p = word_pattern.create(self.pep_records.seq_list, 2) |
Given the code snippet: <|code_start|>
class Test(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(Test, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
self.p = word_pattern.create(self.pep_records.seq_list, 2)
<|code_end|>
... | self.vector = word_vector.Bools(self.pep_records.length_list, self.p) |
Here is a snippet: <|code_start|>
class Test(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(Test, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
self.p = word_pattern.create(self.pep_records.seq_list, 2)
self.vecto... | vec = word_bool_distance._nbool_correspond_ft_tf(u, v) |
Given the following code snippet before the placeholder: <|code_start|>
class Test(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(Test, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
self.p = word_pattern.create(self.pep_rec... | matrix = distmatrix.create(self.pep_records.id_list, dist) |
Based on the snippet: <|code_start|>
class FastaTest(unittest.TestCase):
def __init__(self, *args, **kwargs):
super(FastaTest, self).__init__(*args, **kwargs)
self.ID_LIST = ['seq1', 'seq2', 'seq3', 'seq4']
self.DESC_LIST = ['seq1 desc', 'seq2 desc', 'seq3 desc', '']
self.SEQ_LIS... | self.assertIsInstance(fasta_record, fasta.FastaRecord) |
Predict the next line for this snippet: <|code_start|>"""Distance methods measuring dissimilarity between sets of words.
These methods are also implemented in numpy and provided in the
`word_bool_distance` module. However, here are their faster
implemetations based on python sets.
"""
def _getwords(seq, word_size):... | class Distance(distance.Distance): |
Here is a snippet: <|code_start|>#! /usr/bin/env python
# Copyright (c) 2016 Zielezinski A, combio.pl
def get_parser():
parser = argparse.ArgumentParser(
description='''Calculate distances between DNA/protein sequences based
on boolean 1-D vectors of word counting occurrences.''',
add_h... | distlist = word_bool_distance.Distance.get_disttypes() |
Next line prediction: <|code_start|> help='choose from: {} [DEFAULT: %(default)s]'.format(
", ".join(distlist)),
metavar='', default="jaccard")
group = parser.add_argument_group('OUTPUT ARGUMENTS')
group.add_argument('--out', '-o', help="o... | elif args.word_pattern: |
Next line prediction: <|code_start|> if len(sys.argv[1:]) == 0:
# parser.print_help()
parser.print_usage() # for just the usage line
parser.exit()
return parser
def validate_args(parser):
args = parser.parse_args()
if args.word_size:
if args.word_size < 1:
... | bools = word_vector.Bools(seq_records.length_list, p) |
Here is a snippet: <|code_start|> parser.print_usage() # for just the usage line
parser.exit()
return parser
def validate_args(parser):
args = parser.parse_args()
if args.word_size:
if args.word_size < 1:
parser.error('Word size must be >= 1.')
elif args.word_patte... | matrix = distmatrix.create(seq_records.id_list, dist) |
Given the following code snippet before the placeholder: <|code_start|> group = parser.add_argument_group("OTHER OPTIONS")
group.add_argument("-h", "--help", action="help",
help="show this help message and exit")
group.add_argument('--version', action='version',
... | seq_records = seqrecords.read_fasta(args.fasta) |
Next line prediction: <|code_start|>
class Test(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(Test, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
<|code_end|>
. Use current file imports:
(import numpy as np
import unittest
from... | self.p = word_pattern.create(self.pep_records.seq_list, 2) |
Continue the code snippet: <|code_start|>
class Test(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(Test, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
self.p = word_pattern.create(self.pep_records.seq_list, 2)
def t... | words = word_sets_distance._getwords('ATGCGTA', 2) |
Given the code snippet: <|code_start|>
class Test(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(Test, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
self.p = word_pattern.create(self.pep_records.seq_list, 2)
def test... | matrix = distmatrix.create(self.pep_records.id_list, dist) |
Based on the snippet: <|code_start|>
class Test(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(Test, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
<|code_end|>
, predict the immediate next line with the help of imports:
import u... | self.pep_2mer_pos = word_pattern.create( |
Next line prediction: <|code_start|>
class Test(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(Test, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
self.pep_2mer_pos = word_pattern.create(
self.pep_records.seq_... | val = word_rtd.calc_rtd(apos) |
Here is a snippet: <|code_start|>
class Test(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(Test, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
self.pep_2mer_pos = word_pattern.create(
self.pep_records.seq_lis... | matrix = distmatrix.create(self.pep_records.id_list, dist) |
Predict the next line after this snippet: <|code_start|> "seq2\tseq3\t0.2953940\n"
]
self.assertEqual(result, "\n".join(exp))
def test_write_to_file_pairwise_decimal3(self):
oh = open(self.output_filename, 'w')
self.matrix.write_to_file(oh, 'pairwise', 3)
oh.close... | dist = word_distance.Distance(vector, 'minkowski') |
Given the following code snippet before the placeholder: <|code_start|>
class TestDistMatrix(unittest.TestCase):
def setUp(self):
id_list = ['seq1', 'seq2', 'seq3']
data = np.array([[0, 0.3531587, 0.35509333],
[0.3531587, 0, 0.295394],
[0.3550933... | self.matrix = distmatrix.Matrix(id_list, data) |
Next line prediction: <|code_start|> k (int) : word size
wordpos (bool) : record (True) or ignore (False) the word positions
Returns:
instance of Pattern
Examples:
>>> seqs = ['ATGC', 'CGCG', 'GCAT']
>>> p = create(seqs, 1)
>>> print(p)
4 3 G 0:1 1:2 ... | seq_records = seqrecords.read_fasta(handle) |
Continue the code snippet: <|code_start|> group.add_argument('--outfmt', choices=['phylip', 'pairwise'],
default='phylip',
help='distances output format [DEFAULT: %(default)s]')
group = parser.add_argument_group("OTHER OPTIONS")
group.add_argument("-h", "--help"... | vector = fcgr.create_vectors(seq_records, args.word_size) |
Given the code snippet: <|code_start|> help='distances output format [DEFAULT: %(default)s]')
group = parser.add_argument_group("OTHER OPTIONS")
group.add_argument("-h", "--help", action="help",
help="show this help message and exit")
group.add_argument('--versi... | matrix = distmatrix.create(seq_records.id_list, dist) |
Based on the snippet: <|code_start|> group.add_argument('--out', '-o', help="output filename",
metavar="FILE")
group.add_argument('--outfmt', choices=['phylip', 'pairwise'],
default='phylip',
help='distances output format [DEFAULT: %(default)s]... | seq_records = seqrecords.read_fasta(args.fasta) |
Here is a snippet: <|code_start|># Copyright (c) 2016 Zielezinski A, combio.pl
def get_parser():
parser = argparse.ArgumentParser(
description='''Calculate distances between DNA sequences based on
Frequency Chaos Game Representation (FCGR) patterns of
word occurrences.''',
add_he... | version='%(prog)s {}'.format(__version__)) |
Continue the code snippet: <|code_start|>
class Test(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(Test, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
def test_word_pattern_create_wordsize1_wordposFalse(self):
<|code_end|>
... | p = word_pattern.create(self.dna_records.seq_list, |
Given the following code snippet before the placeholder: <|code_start|> group.add_argument('--outfmt', choices=['phylip', 'pairwise'],
default='phylip',
help='distances output format [DEFAULT: %(default)s]')
group = parser.add_argument_group("OTHER OPTIONS")
gro... | dist = word_sets_distance.Distance(seq_records, args.word_size, |
Predict the next line after this snippet: <|code_start|> help='distances output format [DEFAULT: %(default)s]')
group = parser.add_argument_group("OTHER OPTIONS")
group.add_argument("-h", "--help", action="help",
help="show this help message and exit")
group.add... | matrix = distmatrix.create(seq_records.id_list, dist) |
Next line prediction: <|code_start|> metavar="FILE")
group.add_argument('--outfmt', choices=['phylip', 'pairwise'],
default='phylip',
help='distances output format [DEFAULT: %(default)s]')
group = parser.add_argument_group("OTHER OPTIONS")
... | seq_records = seqrecords.read_fasta(args.fasta) |
Predict the next line for this snippet: <|code_start|> on boolean 1-D vectors of word counting occurrences.''',
add_help=False, prog='calc_word_sets.py'
)
group = parser.add_argument_group('REQUIRED ARGUMENTS')
group.add_argument('--fasta', '-f',
help='input FASTA sequ... | version='%(prog)s {}'.format(__version__)) |
Given the following code snippet before the placeholder: <|code_start|> vectors = [0.0] * ndata # list
for point in CGRs:
xx = int(point[0] / temp)
yy = int(point[1] / temp)
if yy == pow(2, word_size):
yy = pow(2, word_size) - 1
vectors[yy * pow(2, word_size) + xx] +... | class Distance(distance.Distance): |
Given snippet: <|code_start|>
class VectorTest(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(VectorTest, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
def test_complexity(self):
seq = 'MFTDNAKIIIVQLNASVEINCTRPNNNTR'... | c = lempelziv.complexity(seq) |
Predict the next line after this snippet: <|code_start|>
def test_complexity(self):
seq = 'MFTDNAKIIIVQLNASVEINCTRPNNNTR'
c = lempelziv.complexity(seq)
self.assertEqual(c, 19)
def test_complexity1(self):
seq = 'MFTDNAKIIIVQLNASVEINCTRPNNNTR'
c = lempelziv.complexity1(seq... | matrix = distmatrix.create(self.pep_records.id_list, self.dist) |
Given snippet: <|code_start|>The following code is inspired by, and was created based on, an excellent
Python code `decaf+py` (http://bioinformatics.org.au/tools/decaf+py/)
originally published in:
1. Hohl and Ragan. (2007) Systematic Biology. 56. 2007. p. 206-221
doi: 10.1080/10635150701294741.
2. Hohl... | class Distance(distance.Distance): |
Continue the code snippet: <|code_start|>#! /usr/bin/env python
# Copyright (c) 2016 Zielezinski A, combio.pl
def get_parser():
parser = argparse.ArgumentParser(
description='''Calculate distances between protein/DNA sequences based
on Return Time Distribution (RTD) of words\' occurrences and t... | distlist = word_distance.Distance.get_disttypes() |
Here is a snippet: <|code_start|> help='choose from: {} [DEFAULT: %(default)s]'.format(
", ".join(distlist)),
metavar='', default="google")
group = parser.add_argument_group('OUTPUT ARGUMENTS')
group.add_argument('--out', '-o', help="outpu... | elif args.word_pattern: |
Based on the snippet: <|code_start|>
def validate_args(parser):
args = parser.parse_args()
if args.word_size:
if args.word_size < 1:
parser.error('word size must be >= 1')
elif args.word_pattern:
p = word_pattern.read(args.word_pattern)
if not p.pos_list:
e = ... | vector = word_rtd.create_vector(seq_records.count, p) |
Predict the next line after this snippet: <|code_start|> if args.word_size:
if args.word_size < 1:
parser.error('word size must be >= 1')
elif args.word_pattern:
p = word_pattern.read(args.word_pattern)
if not p.pos_list:
e = "{0} does not contain info on word posi... | matrix = distmatrix.create(seq_records.id_list, dist) |
Given the code snippet: <|code_start|> # parser.print_help()
parser.print_usage()
parser.exit()
return parser
def validate_args(parser):
args = parser.parse_args()
if args.word_size:
if args.word_size < 1:
parser.error('word size must be >= 1')
elif args.wor... | seq_records = seqrecords.read_fasta(args.fasta) |
Given the following code snippet before the placeholder: <|code_start|> help='input FASTA sequence filename', required=True,
type=argparse.FileType('r'), metavar="FILE")
group = parser.add_argument_group(' Choose between the two options')
g1 = group.add_mutually_ex... | version='%(prog)s {}'.format(__version__)) |
Here is a snippet: <|code_start|>
class DistanceTest(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(DistanceTest, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
<|code_end|>
. Write the next line using the current file imports:
i... | self.pattern = word_pattern.create(self.dna_records.seq_list, 2) |
Here is a snippet: <|code_start|>
class DistanceTest(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(DistanceTest, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
self.pattern = word_pattern.create(self.dna_records.seq_list,... | self.counts = word_vector.Counts(self.dna_records.length_list, |
Given the following code snippet before the placeholder: <|code_start|>
class DistanceTest(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(DistanceTest, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
self.pattern = word_pat... | dist = word_distance.Distance(self.freqs, 'angle_cos_diss') |
Predict the next line after this snippet: <|code_start|> help='distances output format [DEFAULT: %(default)s]')
group = parser.add_argument_group("OTHER OPTIONS")
group.add_argument("-h", "--help", action="help",
help="show this help message and exit")
group.add... | dist = wmetric.Distance(seq_records, args.matrix) |
Using the snippet: <|code_start|>
group = parser.add_argument_group("OTHER OPTIONS")
group.add_argument("-h", "--help", action="help",
help="show this help message and exit")
group.add_argument('--version', action='version',
version='%(prog)s {}'.format(__versio... | matrix = distmatrix.create(seq_records.id_list, dist) |
Here is a snippet: <|code_start|> default='phylip',
help='distances output format [DEFAULT: %(default)s]')
group = parser.add_argument_group("OTHER OPTIONS")
group.add_argument("-h", "--help", action="help",
help="show this help message and ex... | seq_records = seqrecords.read_fasta(args.fasta) |
Using the snippet: <|code_start|>#! /usr/bin/env python
# Copyright (c) 2016 Zielezinski A, combio.pl
def get_parser():
parser = argparse.ArgumentParser(
description='''Calculate distances between protein sequences based
on W-metric (Wm).''', add_help=False, prog='calc_wmetric.py'
)
gro... | l = subsmat.list_subsmats() |
Given the code snippet: <|code_start|>
def get_parser():
parser = argparse.ArgumentParser(
description='''Calculate distances between protein sequences based
on W-metric (Wm).''', add_help=False, prog='calc_wmetric.py'
)
group = parser.add_argument_group('REQUIRED ARGUMENTS')
group.add_... | version='%(prog)s {}'.format(__version__)) |
Based on the snippet: <|code_start|> parser.error(e)
return args
def main():
parser = get_parser()
args = validate_args(parser)
seq_records = seqrecords.read_fasta(args.fasta)
patterns = []
for i in range(args.min_word_size, args.max_word_size + 1):
p = word_pattern.create... | dist = word_d2.Distance(vecs) |
Here is a snippet: <|code_start|> parser.exit()
return parser
def validate_args(parser):
args = parser.parse_args()
if not args.min_word_size:
parser.error("min_word_size must be greater than 0")
elif args.min_word_size >= args.max_word_size:
parser.error("max_word_size must be... | p = word_pattern.create(seq_records.seq_list, i) |
Given the code snippet: <|code_start|>
group = parser.add_argument_group('OUTPUT ARGUMENTS')
group.add_argument('--out', '-o', help="output filename",
metavar="FILE")
group.add_argument('--outfmt', choices=['phylip', 'pairwise'],
default='phylip',
... | weights = word_vector.read_weightfile(args.char_weights) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.