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 checkout master", ""),
("git checkout main", ""),
("git checkout wibble", "wibble"),
],
)
def test_not_match(script, branch_name, output):
assert not match(Command(script, output))
@pytest.mark.parametrize(
"script, branch_name, new_command",
[
("git checkout main", "main", "git checkout master"),
("git checkout master", "master", "git checkout main"),
("git checkout wibble", "wibble", "git checkout wibble"),
],
)
def test_get_new_command(script, branch_name, new_command, output):
<|code_end|>
, determine the next line of code. You have imports:
import pytest
from thefuck.rules.git_main_master import match, get_new_command
from thefuck.types import Command
and context (class names, function names, or code) available:
# Path: thefuck/rules/git_main_master.py
# @git_support
# def match(command):
# return "'master'" in command.output or "'main'" in command.output
#
# @git_support
# def get_new_command(command):
# if "'master'" in command.output:
# return command.script.replace("master", "main")
# return command.script.replace("main", "master")
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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",
[
("git checkout main", "main"),
("git checkout master", "master"),
("git show main", "main"),
],
)
def test_match(script, branch_name, output):
<|code_end|>
. Use current file imports:
import pytest
from thefuck.rules.git_main_master import match, get_new_command
from thefuck.types import Command
and context (classes, functions, or code) from other files:
# Path: thefuck/rules/git_main_master.py
# @git_support
# def match(command):
# return "'master'" in command.output or "'main'" in command.output
#
# @git_support
# def get_new_command(command):
# if "'master'" in command.output:
# return command.script.replace("master", "main")
# return command.script.replace("main", "master")
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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, False, True, False)])
def test_get_alias(monkeypatch, mocker, py2,
enable_experimental_instant_mode,
which, is_instant):
monkeypatch.setattr('six.PY2', py2)
args = Mock(
enable_experimental_instant_mode=enable_experimental_instant_mode,
alias='fuck', )
mocker.patch('thefuck.entrypoints.alias.which', return_value=which)
shell = Mock(app_alias=lambda _: 'app_alias',
instant_mode_alias=lambda _: 'instant_mode_alias')
monkeypatch.setattr('thefuck.entrypoints.alias.shell', shell)
<|code_end|>
, determine the next line of code. You have imports:
from mock import Mock
from thefuck.entrypoints.alias import _get_alias, print_alias
import pytest
and context (class names, function names, or code) available:
# Path: thefuck/entrypoints/alias.py
# 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_experimental_instant_mode:
# if six.PY2:
# warn("Instant mode requires Python 3")
# elif not which('script'):
# warn("Instant mode requires `script` app")
# else:
# return shell.instant_mode_alias(known_args.alias)
#
# return alias
#
# def print_alias(known_args):
# settings.init(known_args)
# print(_get_alias(known_args))
. Output only the next line. | 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 test_get_alias(monkeypatch, mocker, py2,
enable_experimental_instant_mode,
which, is_instant):
monkeypatch.setattr('six.PY2', py2)
args = Mock(
enable_experimental_instant_mode=enable_experimental_instant_mode,
alias='fuck', )
mocker.patch('thefuck.entrypoints.alias.which', return_value=which)
shell = Mock(app_alias=lambda _: 'app_alias',
instant_mode_alias=lambda _: 'instant_mode_alias')
monkeypatch.setattr('thefuck.entrypoints.alias.shell', shell)
alias = _get_alias(args)
if is_instant:
assert alias == 'instant_mode_alias'
else:
assert alias == 'app_alias'
def test_print_alias(mocker):
settings_mock = mocker.patch('thefuck.entrypoints.alias.settings')
_get_alias_mock = mocker.patch('thefuck.entrypoints.alias._get_alias')
known_args = Mock()
<|code_end|>
, determine the next line of code. You have imports:
from mock import Mock
from thefuck.entrypoints.alias import _get_alias, print_alias
import pytest
and context (class names, function names, or code) available:
# Path: thefuck/entrypoints/alias.py
# 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_experimental_instant_mode:
# if six.PY2:
# warn("Instant mode requires Python 3")
# elif not which('script'):
# warn("Instant mode requires `script` app")
# else:
# return shell.instant_mode_alias(known_args.alias)
#
# return alias
#
# def print_alias(known_args):
# settings.init(known_args)
# print(_get_alias(known_args))
. Output only the next line. | 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_experimental_instant_mode:
if six.PY2:
warn("Instant mode requires Python 3")
elif not which('script'):
warn("Instant mode requires `script` app")
else:
return shell.instant_mode_alias(known_args.alias)
return alias
def print_alias(known_args):
<|code_end|>
, predict the next line using imports from the current file:
import six
from ..conf import settings
from ..logs import warn
from ..shells import shell
from ..utils import which
and context including class names, function names, and sometimes code from other files:
# Path: thefuck/conf.py
# class Settings(dict):
# def __getattr__(self, item):
# def __setattr__(self, key, value):
# def init(self, args=None):
# def _init_settings_file(self):
# def _get_user_dir_path(self):
# def _setup_user_dir(self):
# def _settings_from_file(self):
# def _rules_from_env(self, val):
# def _priority_from_env(self, val):
# def _val_from_env(self, env, attr):
# def _settings_from_env(self):
# def _settings_from_args(self, args):
. Output only the next line. | 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 more log output.
'''.format
output_ambiguous = '''
FAILURE: Build failed with an exception.
* What went wrong:
Task '{}' is ambiguous in root project 'org.rerenderer_example.snake'. Candidates are: 'assembleRelease', 'assembleReleaseUnitTest'.
* 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 more log output.
'''.format
@pytest.fixture(autouse=True)
def tasks(mocker):
patch = mocker.patch('thefuck.rules.gradle_no_task.Popen')
patch.return_value.stdout = BytesIO(gradle_tasks)
return patch
@pytest.mark.parametrize('command', [
<|code_end|>
, determine the next line of code. You have imports:
import pytest
from io import BytesIO
from thefuck.rules.gradle_no_task import match, get_new_command
from thefuck.types import Command
and context (class names, function names, or code) available:
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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 python"])
def test_match(script):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pytest
from thefuck.rules.wrong_hyphen_before_subcommand import match, get_new_command
from thefuck.types import Command
and context:
# Path: thefuck/rules/wrong_hyphen_before_subcommand.py
# @sudo_support
# def match(command):
# first_part = command.script_parts[0]
# if "-" not in first_part or first_part in get_all_executables():
# return False
# cmd, _ = first_part.split("-", 1)
# return cmd in get_all_executables()
#
# @sudo_support
# def get_new_command(command):
# return command.script.replace("-", " ", 1)
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
which might include code, classes, or functions. Output only the next line. | 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", ["git-log", "apt-install python"])
def test_match(script):
assert match(Command(script, ""))
@pytest.mark.parametrize("script", ["ls -la", "git2-make", "apt-get install python"])
def test_not_match(script):
assert not match(Command(script, ""))
@pytest.mark.parametrize(
"script, new_command",
[("git-log", "git log"), ("apt-install python", "apt install python")],
)
def test_get_new_command(script, new_command):
<|code_end|>
using the current file's imports:
import pytest
from thefuck.rules.wrong_hyphen_before_subcommand import match, get_new_command
from thefuck.types import Command
and any relevant context from other files:
# Path: thefuck/rules/wrong_hyphen_before_subcommand.py
# @sudo_support
# def match(command):
# first_part = command.script_parts[0]
# if "-" not in first_part or first_part in get_all_executables():
# return False
# cmd, _ = first_part.split("-", 1)
# return cmd in get_all_executables()
#
# @sudo_support
# def get_new_command(command):
# return command.script.replace("-", " ", 1)
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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-install python"])
def test_match(script):
<|code_end|>
, generate the next line using the imports in this file:
import pytest
from thefuck.rules.wrong_hyphen_before_subcommand import match, get_new_command
from thefuck.types import Command
and context (functions, classes, or occasionally code) from other files:
# Path: thefuck/rules/wrong_hyphen_before_subcommand.py
# @sudo_support
# def match(command):
# first_part = command.script_parts[0]
# if "-" not in first_part or first_part in get_all_executables():
# return False
# cmd, _ = first_part.split("-", 1)
# return cmd in get_all_executables()
#
# @sudo_support
# def get_new_command(command):
# return command.script.replace("-", " ", 1)
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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 the current file:
import pytest
from thefuck.rules.nixos_cmd_not_found import match, get_new_command
from thefuck.types import Command
and context including class names, function names, and sometimes code from other files:
# Path: thefuck/rules/nixos_cmd_not_found.py
# def match(command):
# return regex.findall(command.output)
#
# def get_new_command(command):
# name = regex.findall(command.output)[0]
# return shell.and_('nix-env -iA {}'.format(name), command.script)
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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', [
Command('vim', ''),
Command('', '')])
def test_not_match(mocker, command):
mocker.patch('thefuck.rules.nixos_cmd_not_found', return_value=None)
assert not match(command)
@pytest.mark.parametrize('command, new_command', [
(Command('vim', 'nix-env -iA nixos.vim'), 'nix-env -iA nixos.vim && vim'),
(Command('pacman', 'nix-env -iA nixos.pacman'), 'nix-env -iA nixos.pacman && pacman')])
def test_get_new_command(mocker, command, new_command):
<|code_end|>
using the current file's imports:
import pytest
from thefuck.rules.nixos_cmd_not_found import match, get_new_command
from thefuck.types import Command
and any relevant context from other files:
# Path: thefuck/rules/nixos_cmd_not_found.py
# def match(command):
# return regex.findall(command.output)
#
# def get_new_command(command):
# name = regex.findall(command.output)[0]
# return shell.and_('nix-env -iA {}'.format(name), command.script)
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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 '
'(or any of the parent directories): .git',
'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
<|code_end|>
, predict the immediate next line with the help of imports:
import pytest
from thefuck.rules.scm_correction import match, get_new_command
from thefuck.types import Command
and context (classes, functions, sometimes code) from other files:
# Path: thefuck/rules/scm_correction.py
# @for_app(*wrong_scm_patterns.keys())
# def match(command):
# scm = command.script_parts[0]
# pattern = wrong_scm_patterns[scm]
#
# return pattern in command.output and _get_actual_scm()
#
# def get_new_command(command):
# scm = _get_actual_scm()
# return u' '.join([scm] + command.script_parts[1:])
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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, output))
@pytest.mark.parametrize('script, output, actual_scm', [
('git log', '', 'hg'),
('git log', 'fatal: Not a git repository '
'(or any of the parent directories): .git',
None),
('hg log', "abort: no repository found in '/home/nvbn/exp/thefuck' "
"(.hg not found)!",
None),
('not-scm log', "abort: no repository found in '/home/nvbn/exp/thefuck' "
"(.hg not found)!",
'git')])
def test_not_match(get_actual_scm_mock, script, output, actual_scm):
get_actual_scm_mock.return_value = actual_scm
assert not match(Command(script, output))
@pytest.mark.parametrize('script, actual_scm, result', [
('git log', 'hg', 'hg log'),
('hg log', 'git', 'git log')])
def test_get_new_command(get_actual_scm_mock, script, actual_scm, result):
get_actual_scm_mock.return_value = actual_scm
<|code_end|>
, generate the next line using the imports in this file:
import pytest
from thefuck.rules.scm_correction import match, get_new_command
from thefuck.types import Command
and context (functions, classes, or occasionally code) from other files:
# Path: thefuck/rules/scm_correction.py
# @for_app(*wrong_scm_patterns.keys())
# def match(command):
# scm = command.script_parts[0]
# pattern = wrong_scm_patterns[scm]
#
# return pattern in command.output and _get_actual_scm()
#
# def get_new_command(command):
# scm = _get_actual_scm()
# return u' '.join([scm] + command.script_parts[1:])
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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 '
'(or any of the parent directories): .git',
'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
<|code_end|>
. Use current file imports:
import pytest
from thefuck.rules.scm_correction import match, get_new_command
from thefuck.types import Command
and context (classes, functions, or code) from other files:
# Path: thefuck/rules/scm_correction.py
# @for_app(*wrong_scm_patterns.keys())
# def match(command):
# scm = command.script_parts[0]
# pattern = wrong_scm_patterns[scm]
#
# return pattern in command.output and _get_actual_scm()
#
# def get_new_command(command):
# scm = _get_actual_scm()
# return u' '.join([scm] + command.script_parts[1:])
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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()
executables = get_all_executables()
for command in history:
diff = SequenceMatcher(a=alias, b=command).ratio()
if diff < const.DIFF_WITH_ALIAS or command in executables:
return [command]
return []
def fix_command(known_args):
"""Fixes previous command. Used when `thefuck` called without arguments."""
<|code_end|>
. Use current file imports:
(from pprint import pformat
from difflib import SequenceMatcher
from .. import logs, types, const
from ..conf import settings
from ..corrector import get_corrected_commands
from ..exceptions import EmptyCommand
from ..ui import select_command
from ..utils import get_alias, get_all_executables
import os
import sys)
and context including class names, function names, or small code snippets from other files:
# Path: thefuck/conf.py
# class Settings(dict):
# def __getattr__(self, item):
# def __setattr__(self, key, value):
# def init(self, args=None):
# def _init_settings_file(self):
# def _get_user_dir_path(self):
# def _setup_user_dir(self):
# def _settings_from_file(self):
# def _rules_from_env(self, val):
# def _priority_from_env(self, val):
# def _val_from_env(self, env, attr):
# def _settings_from_env(self):
# def _settings_from_args(self, args):
#
# Path: thefuck/corrector.py
# def get_corrected_commands(command):
# """Returns generator with sorted and unique corrected commands.
#
# :type command: thefuck.types.Command
# :rtype: Iterable[thefuck.types.CorrectedCommand]
#
# """
# corrected_commands = (
# corrected for rule in get_rules()
# if rule.is_match(command)
# for corrected in rule.get_corrected_commands(command))
# return organize_commands(corrected_commands)
. Output only the next line. | 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()
executables = get_all_executables()
for command in history:
diff = SequenceMatcher(a=alias, b=command).ratio()
if diff < const.DIFF_WITH_ALIAS or command in executables:
return [command]
return []
def fix_command(known_args):
"""Fixes previous command. Used when `thefuck` called without arguments."""
settings.init(known_args)
with logs.debug_time('Total'):
logs.debug(u'Run with settings: {}'.format(pformat(settings)))
raw_command = _get_raw_command(known_args)
try:
command = types.Command.from_raw_script(raw_command)
except EmptyCommand:
logs.debug('Empty command, nothing to do')
return
<|code_end|>
. Use current file imports:
(from pprint import pformat
from difflib import SequenceMatcher
from .. import logs, types, const
from ..conf import settings
from ..corrector import get_corrected_commands
from ..exceptions import EmptyCommand
from ..ui import select_command
from ..utils import get_alias, get_all_executables
import os
import sys)
and context including class names, function names, or small code snippets from other files:
# Path: thefuck/conf.py
# class Settings(dict):
# def __getattr__(self, item):
# def __setattr__(self, key, value):
# def init(self, args=None):
# def _init_settings_file(self):
# def _get_user_dir_path(self):
# def _setup_user_dir(self):
# def _settings_from_file(self):
# def _rules_from_env(self, val):
# def _priority_from_env(self, val):
# def _val_from_env(self, env, attr):
# def _settings_from_env(self):
# def _settings_from_args(self, args):
#
# Path: thefuck/corrector.py
# def get_corrected_commands(command):
# """Returns generator with sorted and unique corrected commands.
#
# :type command: thefuck.types.Command
# :rtype: Iterable[thefuck.types.CorrectedCommand]
#
# """
# corrected_commands = (
# corrected for rule in get_rules()
# if rule.is_match(command)
# for corrected in rule.get_corrected_commands(command))
# return organize_commands(corrected_commands)
. Output only the next line. | 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 Command
and context from other files:
# Path: thefuck/rules/git_tag_force.py
# @git_support
# def match(command):
# return ('tag' in command.script_parts
# and 'already exists' in command.output)
#
# @git_support
# def get_new_command(command):
# return replace_argument(command.script, 'tag', 'tag --force')
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
, which may contain function names, class names, or code. Output only the next line. | 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):
<|code_end|>
, predict the next line using imports from the current file:
import pytest
from thefuck.rules.git_tag_force import match, get_new_command
from thefuck.types import Command
and context including class names, function names, and sometimes code from other files:
# Path: thefuck/rules/git_tag_force.py
# @git_support
# def match(command):
# return ('tag' in command.script_parts
# and 'already exists' in command.output)
#
# @git_support
# def get_new_command(command):
# return replace_argument(command.script, 'tag', 'tag --force')
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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
and context from other files:
# Path: thefuck/rules/git_tag_force.py
# @git_support
# def match(command):
# return ('tag' in command.script_parts
# and 'already exists' in command.output)
#
# @git_support
# def get_new_command(command):
# return replace_argument(command.script, 'tag', 'tag --force')
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
, which may include functions, classes, or code. Output only the next line. | 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 stash list', ''))
def test_get_new_command():
<|code_end|>
using the current file's imports:
from thefuck.rules.git_branch_list import match, get_new_command
from thefuck.shells import shell
from thefuck.types import Command
and any relevant context from other files:
# Path: thefuck/rules/git_branch_list.py
# @git_support
# def match(command):
# # catches "git branch list" in place of "git branch"
# return (command.script_parts
# and command.script_parts[1:] == 'branch list'.split())
#
# @git_support
# def get_new_command(command):
# return shell.and_('git branch --delete list', 'git branch')
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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'
'\tservice-bind\n'
'\tservice-doc\n'
'\tservice-info\n'
'\tservice-list\n'
'\tservice-remove\n'
'\tservice-status\n'
'\tservice-unbind'), ['service-add', 'service-bind', 'service-doc',
'service-info', 'service-list', 'service-remove',
'service-status', 'service-unbind'])])
def test_get_all_matched_commands(stderr, result):
assert list(get_all_matched_commands(stderr)) == result
@pytest.mark.usefixtures('no_memoize')
@pytest.mark.parametrize('script, names, result', [
('/usr/bin/git diff', ['git', 'hub'], True),
('/bin/hdfs dfs -rm foo', ['hdfs'], True),
('git diff', ['git', 'hub'], True),
('hub diff', ['git', 'hub'], True),
('hg diff', ['git', 'hub'], False)])
def test_is_app(script, names, result):
<|code_end|>
, generate the next line using the imports in this file:
import pytest
import warnings
from mock import Mock, call, patch
from thefuck.utils import default_settings, \
memoize, get_closest, get_all_executables, replace_argument, \
get_all_matched_commands, is_app, for_app, cache, \
get_valid_history_without_current, _cache, get_close_matches
from thefuck.types import Command
and context (functions, classes, or occasionally code) from other files:
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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', 'workon code-view', 'workon new-env'])
def test_match(script):
<|code_end|>
, predict the next line using imports from the current file:
import pytest
from thefuck.rules.workon_doesnt_exists import match, get_new_command
from thefuck.types import Command
and context including class names, function names, and sometimes code from other files:
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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', 'npminstall', 'watchls'])
def test_match(script):
<|code_end|>
, predict the immediate next line with the help of imports:
import pytest
from thefuck.rules.missing_space_before_subcommand import (
match, get_new_command)
from thefuck.types import Command
and context (classes, functions, sometimes code) from other files:
# Path: thefuck/rules/missing_space_before_subcommand.py
# def match(command):
# return (not command.script_parts[0] in get_all_executables()
# and _get_executable(command.script_parts[0]))
#
# def get_new_command(command):
# executable = _get_executable(command.script_parts[0])
# return command.script.replace(executable, u'{} '.format(executable), 1)
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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', 'npminstall', 'watchls'])
def test_match(script):
assert match(Command(script, ''))
@pytest.mark.parametrize('script', ['git branch', 'vimfile'])
def test_not_match(script):
assert not match(Command(script, ''))
@pytest.mark.parametrize('script, result', [
('gitbranch', 'git branch'),
('ls-la', 'ls -la'),
('npminstall webpack', 'npm install webpack'),
('watchls', 'watch ls')])
def test_get_new_command(script, result):
<|code_end|>
. Write the next line using the current file imports:
import pytest
from thefuck.rules.missing_space_before_subcommand import (
match, get_new_command)
from thefuck.types import Command
and context from other files:
# Path: thefuck/rules/missing_space_before_subcommand.py
# def match(command):
# return (not command.script_parts[0] in get_all_executables()
# and _get_executable(command.script_parts[0]))
#
# def get_new_command(command):
# executable = _get_executable(command.script_parts[0])
# return command.script.replace(executable, u'{} '.format(executable), 1)
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
, which may include functions, classes, or code. Output only the next line. | 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', 'npminstall', 'watchls'])
def test_match(script):
<|code_end|>
, generate the next line using the imports in this file:
import pytest
from thefuck.rules.missing_space_before_subcommand import (
match, get_new_command)
from thefuck.types import Command
and context (functions, classes, or occasionally code) from other files:
# Path: thefuck/rules/missing_space_before_subcommand.py
# def match(command):
# return (not command.script_parts[0] in get_all_executables()
# and _get_executable(command.script_parts[0]))
#
# def get_new_command(command):
# executable = _get_executable(command.script_parts[0])
# return command.script.replace(executable, u'{} '.format(executable), 1)
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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 import get_new_command, match
and context from other files:
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
#
# Path: thefuck/rules/git_push_without_commits.py
# def get_new_command(command):
# return shell.and_('git commit -m "Initial commit"', command.script)
#
# @git_support
# def match(command):
# return bool(re.search(r"src refspec \w+ does not match any", command.output))
, which may include functions, classes, or code. Output only the next line. | 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 match(Command(script, "Everything up-to-date"))
def test_get_new_command():
script = "git push -u origin master"
output = "error: src refspec master does not match any\nerror: failed to..."
new_command = 'git commit -m "Initial commit" && git push -u origin master'
<|code_end|>
using the current file's imports:
from thefuck.types import Command
from thefuck.rules.git_push_without_commits import get_new_command, match
and any relevant context from other files:
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
#
# Path: thefuck/rules/git_push_without_commits.py
# def get_new_command(command):
# return shell.and_('git commit -m "Initial commit"', command.script)
#
# @git_support
# def match(command):
# return bool(re.search(r"src refspec \w+ does not match any", command.output))
. Output only the next line. | 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_without_commits import get_new_command, match
and context (classes, functions, sometimes code) from other files:
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
#
# Path: thefuck/rules/git_push_without_commits.py
# def get_new_command(command):
# return shell.and_('git commit -m "Initial commit"', command.script)
#
# @git_support
# def match(command):
# return bool(re.search(r"src refspec \w+ does not match any", command.output))
. Output only the next line. | 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 branch -D foo",
],
)
def test_not_match(script, output_branch_exists):
assert not match(Command(script, ""))
@pytest.mark.parametrize(
"script, new_command",
[
("git branch 0a", "git branch -D 0a && git branch -a"),
("git branch 0v", "git branch -D 0v && git branch -v"),
("git branch 0d foo", "git branch -D 0d && git branch -d foo"),
("git branch 0D foo", "git branch -D 0D && git branch -D foo"),
("git branch 0l 'maint-*'", "git branch -D 0l && git branch -l 'maint-*'"),
("git branch 0u upstream", "git branch -D 0u && git branch -u upstream"),
],
)
def test_get_new_command_branch_exists(script, output_branch_exists, new_command):
<|code_end|>
with the help of current file imports:
import pytest
from thefuck.rules.git_branch_0flag import get_new_command, match
from thefuck.types import Command
and context from other files:
# Path: thefuck/rules/git_branch_0flag.py
# @git_support
# def get_new_command(command):
# branch_name = first_0flag(command.script_parts)
# fixed_flag = branch_name.replace("0", "-")
# fixed_script = command.script.replace(branch_name, fixed_flag)
# if "A branch named '" in command.output and "' already exists." in command.output:
# delete_branch = u"git branch -D {}".format(branch_name)
# return shell.and_(delete_branch, fixed_script)
# return fixed_script
#
# @git_support
# def match(command):
# return command.script_parts[1] == "branch" and first_0flag(command.script_parts)
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
, which may contain function names, class names, or code. Output only the next line. | 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",
"git branch 0v",
"git branch 0d foo",
"git branch 0D foo",
],
)
def test_match(script, output_branch_exists):
<|code_end|>
, predict the next line using imports from the current file:
import pytest
from thefuck.rules.git_branch_0flag import get_new_command, match
from thefuck.types import Command
and context including class names, function names, and sometimes code from other files:
# Path: thefuck/rules/git_branch_0flag.py
# @git_support
# def get_new_command(command):
# branch_name = first_0flag(command.script_parts)
# fixed_flag = branch_name.replace("0", "-")
# fixed_script = command.script.replace(branch_name, fixed_flag)
# if "A branch named '" in command.output and "' already exists." in command.output:
# delete_branch = u"git branch -D {}".format(branch_name)
# return shell.and_(delete_branch, fixed_script)
# return fixed_script
#
# @git_support
# def match(command):
# return command.script_parts[1] == "branch" and first_0flag(command.script_parts)
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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 branch 0d foo",
"git branch 0D foo",
],
)
def test_match(script, output_branch_exists):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pytest
from thefuck.rules.git_branch_0flag import get_new_command, match
from thefuck.types import Command
and context:
# Path: thefuck/rules/git_branch_0flag.py
# @git_support
# def get_new_command(command):
# branch_name = first_0flag(command.script_parts)
# fixed_flag = branch_name.replace("0", "-")
# fixed_script = command.script.replace(branch_name, fixed_flag)
# if "A branch named '" in command.output and "' already exists." in command.output:
# delete_branch = u"git branch -D {}".format(branch_name)
# return shell.and_(delete_branch, fixed_script)
# return fixed_script
#
# @git_support
# def match(command):
# return command.script_parts[1] == "branch" and first_0flag(command.script_parts)
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
which might include code, classes, or functions. Output only the next line. | 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 the next line. Consider current file imports:
import pytest
from thefuck.rules.remove_shell_prompt_literal import match, get_new_command
from thefuck.types import Command
and context:
# Path: thefuck/rules/remove_shell_prompt_literal.py
# def match(command):
# return (
# "$: command not found" in command.output
# and re.search(r"^[\s]*\$ [\S]+", command.script) is not None
# )
#
# def get_new_command(command):
# return command.script.lstrip("$ ")
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
which might include code, classes, or functions. Output only the next line. | 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"),
Command(" $?", "127: command not found"),
Command("", ""),
],
)
def test_not_match(command):
assert not match(command)
@pytest.mark.parametrize(
"script, new_command",
[
("$ cd newdir", "cd newdir"),
("$ $ cd newdir", "cd newdir"),
("$ python3 -m virtualenv env", "python3 -m virtualenv env"),
(" $ $ $ python3 -m virtualenv env", "python3 -m virtualenv env"),
],
)
def test_get_new_command(script, new_command, output):
<|code_end|>
. Use current file imports:
import pytest
from thefuck.rules.remove_shell_prompt_literal import match, get_new_command
from thefuck.types import Command
and context (classes, functions, or code) from other files:
# Path: thefuck/rules/remove_shell_prompt_literal.py
# def match(command):
# return (
# "$: command not found" in command.output
# and re.search(r"^[\s]*\$ [\S]+", command.script) is not None
# )
#
# def get_new_command(command):
# return command.script.lstrip("$ ")
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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, output):
<|code_end|>
, predict the next line using imports from the current file:
import pytest
from thefuck.rules.remove_shell_prompt_literal import match, get_new_command
from thefuck.types import Command
and context including class names, function names, and sometimes code from other files:
# Path: thefuck/rules/remove_shell_prompt_literal.py
# def match(command):
# return (
# "$: command not found" in command.output
# and re.search(r"^[\s]*\$ [\S]+", command.script) is not None
# )
#
# def get_new_command(command):
# return command.script.lstrip("$ ")
#
# Path: thefuck/types.py
# class Command(object):
# """Command that should be fixed."""
#
# def __init__(self, script, output):
# """Initializes command with given values.
#
# :type script: basestring
# :type output: basestring
#
# """
# self.script = script
# self.output = output
#
# @property
# def stdout(self):
# logs.warn('`stdout` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def stderr(self):
# logs.warn('`stderr` is deprecated, please use `output` instead')
# return self.output
#
# @property
# def script_parts(self):
# if not hasattr(self, '_script_parts'):
# try:
# self._script_parts = shell.split_command(self.script)
# except Exception:
# logs.debug(u"Can't split command script {} because:\n {}".format(
# self, sys.exc_info()))
# self._script_parts = []
#
# return self._script_parts
#
# def __eq__(self, other):
# if isinstance(other, Command):
# return (self.script, self.output) == (other.script, other.output)
# else:
# return False
#
# def __repr__(self):
# return u'Command(script={}, output={})'.format(
# self.script, self.output)
#
# def update(self, **kwargs):
# """Returns new command with replaced fields.
#
# :rtype: Command
#
# """
# kwargs.setdefault('script', self.script)
# kwargs.setdefault('output', self.output)
# return Command(**kwargs)
#
# @classmethod
# def from_raw_script(cls, raw_script):
# """Creates instance of `Command` from a list of script parts.
#
# :type raw_script: [basestring]
# :rtype: Command
# :raises: EmptyCommand
#
# """
# script = format_raw_script(raw_script)
# if not script:
# raise EmptyCommand
#
# expanded = shell.from_shell(script)
# output = get_output(script, expanded)
# return cls(expanded, output)
. Output only the next line. | 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 thefuck.specific.git import git_support
from thefuck.utils import memoize
and context including class names, function names, and sometimes code from other files:
# Path: thefuck/specific/git.py
# @decorator
# def git_support(fn, command):
# """Resolves git aliases and supports testing for both git and hub."""
# # supports GitHub's `hub` command
# # which is recommended to be used with `alias git=hub`
# # but at this point, shell aliases have already been resolved
# if not is_app(command, 'git', 'hub'):
# return False
#
# # perform git aliases expansion
# if command.output and 'trace: alias expansion:' in command.output:
# search = re.search("trace: alias expansion: ([^ ]*) => ([^\n]*)",
# command.output)
# alias = search.group(1)
#
# # by default git quotes everything, for example:
# # 'commit' '--amend'
# # which is surprising and does not allow to easily test for
# # eg. 'git commit'
# expansion = ' '.join(shell.quote(part)
# for part in shell.split_command(search.group(2)))
# new_script = re.sub(r"\b{}\b".format(alias), expansion, command.script)
#
# command = command.update(script=new_script)
#
# return fn(command)
. Output only the next line. | @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('--enable-functional', action="store_true", default=False,
help="Enable functional tests")
@pytest.fixture
def no_memoize(monkeypatch):
monkeypatch.setattr('thefuck.utils.memoize.disabled', True)
@pytest.fixture(autouse=True)
def settings(request):
def _reset_settings():
<|code_end|>
, determine the next line of code. You have imports:
import os
import pytest
from thefuck import shells
from thefuck import conf, const
from thefuck.system import Path
and context (class names, function names, or code) available:
# Path: thefuck/conf.py
# class Settings(dict):
# def __getattr__(self, item):
# def __setattr__(self, key, value):
# def init(self, args=None):
# def _init_settings_file(self):
# def _get_user_dir_path(self):
# def _setup_user_dir(self):
# def _settings_from_file(self):
# def _rules_from_env(self, val):
# def _priority_from_env(self, val):
# def _val_from_env(self, env, attr):
# def _settings_from_env(self):
# def _settings_from_args(self, args):
#
# Path: thefuck/const.py
# class _GenConst(object):
# def __init__(self, name):
# def __repr__(self):
# KEY_UP = _GenConst('↑')
# KEY_DOWN = _GenConst('↓')
# KEY_CTRL_C = _GenConst('Ctrl+C')
# KEY_CTRL_N = _GenConst('Ctrl+N')
# KEY_CTRL_P = _GenConst('Ctrl+P')
# KEY_MAPPING = {'\x0e': KEY_CTRL_N,
# '\x03': KEY_CTRL_C,
# '\x10': KEY_CTRL_P}
# ACTION_SELECT = _GenConst('select')
# ACTION_ABORT = _GenConst('abort')
# ACTION_PREVIOUS = _GenConst('previous')
# ACTION_NEXT = _GenConst('next')
# ALL_ENABLED = _GenConst('All rules enabled')
# DEFAULT_RULES = [ALL_ENABLED]
# DEFAULT_PRIORITY = 1000
# DEFAULT_SETTINGS = {'rules': DEFAULT_RULES,
# 'exclude_rules': [],
# 'wait_command': 3,
# 'require_confirmation': True,
# 'no_colors': False,
# 'debug': False,
# 'priority': {},
# 'history_limit': None,
# 'alter_history': True,
# 'wait_slow_command': 15,
# 'slow_commands': ['lein', 'react-native', 'gradle',
# './gradlew', 'vagrant'],
# 'repeat': False,
# 'instant_mode': False,
# 'num_close_matches': 3,
# 'env': {'LC_ALL': 'C', 'LANG': 'C', 'GIT_TRACE': '1'},
# 'excluded_search_path_prefixes': []}
# ENV_TO_ATTR = {'THEFUCK_RULES': 'rules',
# 'THEFUCK_EXCLUDE_RULES': 'exclude_rules',
# 'THEFUCK_WAIT_COMMAND': 'wait_command',
# 'THEFUCK_REQUIRE_CONFIRMATION': 'require_confirmation',
# 'THEFUCK_NO_COLORS': 'no_colors',
# 'THEFUCK_DEBUG': 'debug',
# 'THEFUCK_PRIORITY': 'priority',
# 'THEFUCK_HISTORY_LIMIT': 'history_limit',
# 'THEFUCK_ALTER_HISTORY': 'alter_history',
# 'THEFUCK_WAIT_SLOW_COMMAND': 'wait_slow_command',
# 'THEFUCK_SLOW_COMMANDS': 'slow_commands',
# 'THEFUCK_REPEAT': 'repeat',
# 'THEFUCK_INSTANT_MODE': 'instant_mode',
# 'THEFUCK_NUM_CLOSE_MATCHES': 'num_close_matches',
# 'THEFUCK_EXCLUDED_SEARCH_PATH_PREFIXES': 'excluded_search_path_prefixes'}
# SETTINGS_HEADER = u"""# The Fuck settings file
# #
# # The rules are defined as in the example bellow:
# #
# # rules = ['cd_parent', 'git_push', 'python_command', 'sudo']
# #
# # The default values are as follows. Uncomment and change to fit your needs.
# # See https://github.com/nvbn/thefuck#settings for more information.
# #
#
# """
# ARGUMENT_PLACEHOLDER = 'THEFUCK_ARGUMENT_PLACEHOLDER'
# CONFIGURATION_TIMEOUT = 60
# USER_COMMAND_MARK = u'\u200B' * 10
# LOG_SIZE_IN_BYTES = 1024 * 1024
# LOG_SIZE_TO_CLEAN = 10 * 1024
# DIFF_WITH_ALIAS = 0.5
# SHELL_LOGGER_SOCKET_ENV = 'SHELL_LOGGER_SOCKET'
# SHELL_LOGGER_LIMIT = 5
. Output only the next line. | 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-functional', action="store_true", default=False,
help="Enable functional tests")
@pytest.fixture
def no_memoize(monkeypatch):
monkeypatch.setattr('thefuck.utils.memoize.disabled', True)
@pytest.fixture(autouse=True)
def settings(request):
def _reset_settings():
conf.settings.clear()
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import pytest
from thefuck import shells
from thefuck import conf, const
from thefuck.system import Path
and context:
# Path: thefuck/conf.py
# class Settings(dict):
# def __getattr__(self, item):
# def __setattr__(self, key, value):
# def init(self, args=None):
# def _init_settings_file(self):
# def _get_user_dir_path(self):
# def _setup_user_dir(self):
# def _settings_from_file(self):
# def _rules_from_env(self, val):
# def _priority_from_env(self, val):
# def _val_from_env(self, env, attr):
# def _settings_from_env(self):
# def _settings_from_args(self, args):
#
# Path: thefuck/const.py
# class _GenConst(object):
# def __init__(self, name):
# def __repr__(self):
# KEY_UP = _GenConst('↑')
# KEY_DOWN = _GenConst('↓')
# KEY_CTRL_C = _GenConst('Ctrl+C')
# KEY_CTRL_N = _GenConst('Ctrl+N')
# KEY_CTRL_P = _GenConst('Ctrl+P')
# KEY_MAPPING = {'\x0e': KEY_CTRL_N,
# '\x03': KEY_CTRL_C,
# '\x10': KEY_CTRL_P}
# ACTION_SELECT = _GenConst('select')
# ACTION_ABORT = _GenConst('abort')
# ACTION_PREVIOUS = _GenConst('previous')
# ACTION_NEXT = _GenConst('next')
# ALL_ENABLED = _GenConst('All rules enabled')
# DEFAULT_RULES = [ALL_ENABLED]
# DEFAULT_PRIORITY = 1000
# DEFAULT_SETTINGS = {'rules': DEFAULT_RULES,
# 'exclude_rules': [],
# 'wait_command': 3,
# 'require_confirmation': True,
# 'no_colors': False,
# 'debug': False,
# 'priority': {},
# 'history_limit': None,
# 'alter_history': True,
# 'wait_slow_command': 15,
# 'slow_commands': ['lein', 'react-native', 'gradle',
# './gradlew', 'vagrant'],
# 'repeat': False,
# 'instant_mode': False,
# 'num_close_matches': 3,
# 'env': {'LC_ALL': 'C', 'LANG': 'C', 'GIT_TRACE': '1'},
# 'excluded_search_path_prefixes': []}
# ENV_TO_ATTR = {'THEFUCK_RULES': 'rules',
# 'THEFUCK_EXCLUDE_RULES': 'exclude_rules',
# 'THEFUCK_WAIT_COMMAND': 'wait_command',
# 'THEFUCK_REQUIRE_CONFIRMATION': 'require_confirmation',
# 'THEFUCK_NO_COLORS': 'no_colors',
# 'THEFUCK_DEBUG': 'debug',
# 'THEFUCK_PRIORITY': 'priority',
# 'THEFUCK_HISTORY_LIMIT': 'history_limit',
# 'THEFUCK_ALTER_HISTORY': 'alter_history',
# 'THEFUCK_WAIT_SLOW_COMMAND': 'wait_slow_command',
# 'THEFUCK_SLOW_COMMANDS': 'slow_commands',
# 'THEFUCK_REPEAT': 'repeat',
# 'THEFUCK_INSTANT_MODE': 'instant_mode',
# 'THEFUCK_NUM_CLOSE_MATCHES': 'num_close_matches',
# 'THEFUCK_EXCLUDED_SEARCH_PATH_PREFIXES': 'excluded_search_path_prefixes'}
# SETTINGS_HEADER = u"""# The Fuck settings file
# #
# # The rules are defined as in the example bellow:
# #
# # rules = ['cd_parent', 'git_push', 'python_command', 'sudo']
# #
# # The default values are as follows. Uncomment and change to fit your needs.
# # See https://github.com/nvbn/thefuck#settings for more information.
# #
#
# """
# ARGUMENT_PLACEHOLDER = 'THEFUCK_ARGUMENT_PLACEHOLDER'
# CONFIGURATION_TIMEOUT = 60
# USER_COMMAND_MARK = u'\u200B' * 10
# LOG_SIZE_IN_BYTES = 1024 * 1024
# LOG_SIZE_TO_CLEAN = 10 * 1024
# DIFF_WITH_ALIAS = 0.5
# SHELL_LOGGER_SOCKET_ENV = 'SHELL_LOGGER_SOCKET'
# SHELL_LOGGER_LIMIT = 5
which might include code, classes, or functions. Output only the next line. | 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 _get_raw_command
and context from other files:
# Path: thefuck/entrypoints/fix_command.py
# 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()
# executables = get_all_executables()
# for command in history:
# diff = SequenceMatcher(a=alias, b=command).ratio()
# if diff < const.DIFF_WITH_ALIAS or command in executables:
# return [command]
# return []
, which may include functions, classes, or code. Output only the next line. | 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'Rerun: process PID {} ({}) could not be terminated'.format(
proc.pid, proc.exe()))
def _wait_output(popen, is_slow):
"""Returns `True` if we can get output of the command in the
`settings.wait_command` time.
Command will be killed if it wasn't finished in the time.
:type popen: Popen
:rtype: bool
"""
proc = Process(popen.pid)
try:
<|code_end|>
using the current file's imports:
import os
import shlex
import six
from subprocess import Popen, PIPE, STDOUT
from psutil import AccessDenied, Process, TimeoutExpired
from .. import logs
from ..conf import settings
and any relevant context from other files:
# Path: thefuck/conf.py
# class Settings(dict):
# def __getattr__(self, item):
# def __setattr__(self, key, value):
# def init(self, args=None):
# def _init_settings_file(self):
# def _get_user_dir_path(self):
# def _setup_user_dir(self):
# def _settings_from_file(self):
# def _rules_from_env(self, val):
# def _priority_from_env(self, val):
# def _val_from_env(self, env, attr):
# def _settings_from_env(self):
# def _settings_from_args(self, args):
. Output only the next line. | 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 thefuck.const import DEFAULT_PRIORITY
and context (classes, functions, or code) from other files:
# Path: thefuck/types.py
# class Command(object):
# class Rule(object):
# class CorrectedCommand(object):
# def __init__(self, script, output):
# def stdout(self):
# def stderr(self):
# def script_parts(self):
# def __eq__(self, other):
# def __repr__(self):
# def update(self, **kwargs):
# def from_raw_script(cls, raw_script):
# def __init__(self, name, match, get_new_command,
# enabled_by_default, side_effect,
# priority, requires_output):
# def __eq__(self, other):
# def __repr__(self):
# def from_path(cls, path):
# def is_enabled(self):
# def is_match(self, command):
# def get_corrected_commands(self, command):
# def __init__(self, script, side_effect, priority):
# def __eq__(self, other):
# def __hash__(self):
# def __repr__(self):
# def _get_script(self):
# def run(self, old_cmd):
#
# Path: thefuck/const.py
# DEFAULT_PRIORITY = 1000
. Output only the next line. | 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 imports:
import unittest
from alfpy import word_pattern
from alfpy import word_vector
from alfpy.utils import distance
from alfpy.utils import distmatrix
from . import utils
and context (classes, functions, sometimes code) from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/utils/distance.py
# class Distance(object):
# def __getitem__(self, seqnum):
# def get_disttypes(cls):
# def set_disttype(self, disttype):
# def __init__(self, vector, disttype):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_google(self, seq1idx, seq2idx):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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, 2)
<|code_end|>
, determine the next line of code. You have imports:
import unittest
from alfpy import word_pattern
from alfpy import word_vector
from alfpy.utils import distance
from alfpy.utils import distmatrix
from . import utils
and context (class names, function names, or code) available:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/utils/distance.py
# class Distance(object):
# def __getitem__(self, seqnum):
# def get_disttypes(cls):
# def set_disttype(self, disttype):
# def __init__(self, vector, disttype):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_google(self, seq1idx, seq2idx):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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, 2)
self.counts = word_vector.Counts(self.dna_records.length_list,
self.pattern)
self.freqs = word_vector.Freqs(self.dna_records.length_list,
self.pattern)
def test_euclid_squared_counts(self):
# The result of this method is identical to that from decaf+py.
<|code_end|>
, determine the next line of code. You have imports:
import unittest
from alfpy import word_pattern
from alfpy import word_vector
from alfpy.utils import distance
from alfpy.utils import distmatrix
from . import utils
and context (class names, function names, or code) available:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/utils/distance.py
# class Distance(object):
# def __getitem__(self, seqnum):
# def get_disttypes(cls):
# def set_disttype(self, disttype):
# def __init__(self, vector, disttype):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_google(self, seq1idx, seq2idx):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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_list, 2)
self.counts = word_vector.Counts(self.dna_records.length_list,
self.pattern)
self.freqs = word_vector.Freqs(self.dna_records.length_list,
self.pattern)
def test_euclid_squared_counts(self):
# The result of this method is identical to that from decaf+py.
dist = distance.Distance(self.counts, 'euclid_squared')
<|code_end|>
, predict the immediate next line with the help of imports:
import unittest
from alfpy import word_pattern
from alfpy import word_vector
from alfpy.utils import distance
from alfpy.utils import distmatrix
from . import utils
and context (classes, functions, sometimes code) from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/utils/distance.py
# class Distance(object):
# def __getitem__(self, seqnum):
# def get_disttypes(cls):
# def set_disttype(self, disttype):
# def __init__(self, vector, disttype):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_google(self, seq1idx, seq2idx):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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 this file:
import unittest
from alfpy import word_pattern
from alfpy import word_vector
from . import utils
and context (functions, classes, or occasionally code) from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
. Output only the next line. | 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.seq_list, 1)
self.pattern2 = word_pattern.create(self.dna_records.seq_list, 2)
self.pattern3 = word_pattern.create(self.dna_records.seq_list, 3)
def test_counts_pattern1(self):
<|code_end|>
, generate the next line using the imports in this file:
import unittest
from alfpy import word_pattern
from alfpy import word_vector
from . import utils
and context (functions, classes, or occasionally code) from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
. Output only the next line. | 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_test_data(cls):
ScriptsCommonTest.set_test_data()
cls.filename_char_weights = get_test_data('char_weights.txt')
cls.filename_char_freqs = get_test_data('char_freqs.txt')
cls.filename_pep_1mer_wordpos = get_test_data(
'pep.fa.1mer.wordpos.txt')
cls.filename_pep_1mer = get_test_data('pep.fa.1mer.txt')
cls.filename_pep_2mer_wordpos = get_test_data(
'pep.fa.2mer.wordpos.txt')
cls.filename_pep_2mer = get_test_data('pep.fa.2mer.txt')
cls.filename_pep_3mer_wordpos = get_test_data(
'pep.fa.3mer.wordpos.txt')
cls.filename_pep_3mer = get_test_data('pep.fa.3mer.txt')
class ModulesCommonTest:
@classmethod
def set_test_data(cls):
fh = open(get_test_data('dna.fa'))
<|code_end|>
. Use current file imports:
(import hashlib
import os
import subprocess
from alfpy.utils import seqrecords
from alfpy import __version__)
and context including class names, function names, or small code snippets from other files:
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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,
universal_newlines=True)
out = "".join(p.communicate())
return p.returncode, out
class ScriptsCommonTest:
"""Methods testing arguments that are common to all scripts."""
# the name of the file to read from
@classmethod
def set_test_data(cls):
cls.filename_dna = get_test_data('dna.fa')
cls.filename_pep = get_test_data('pep.fa')
def test_arg_version(self):
cmd = ['--version']
return_code, out = runscript(self.script_name, cmd)
self.assertEqual(return_code, 0)
<|code_end|>
, determine the next line of code. You have imports:
import hashlib
import os
import subprocess
from alfpy.utils import seqrecords
from alfpy import __version__
and context (class names, function names, or code) available:
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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 independance.
# $D_{ij}(l) = p_{ij}(l) - p_i p_j$
D = l_dist_correlations - np.dot(p.T, p)
bbc += D + (D ** 2 / 2 * np.dot(p.T ** 2, p ** 2)) + D ** 3
# Flatten the bbc into a 16 feature vector.
bbc.shape = (1, L * L)
return bbc
def create_vectors(seq_records, k=10, alphabet="ATGC"):
"""Create BBC's vectors for multiple sequence records.
Args:
seq_records (obj SeqRecords)
"""
data = np.zeros(shape=(seq_records.count, len(alphabet)**2))
for seqidx, seq in enumerate(seq_records.seq_list):
vector = base_base_correlation(seq, k=k, alphabet=alphabet)
data[seqidx] = vector
return data
<|code_end|>
using the current file's imports:
import numpy as np
from .utils import distance
from .utils.seqrecords import main
from .utils import distmatrix
and any relevant context from other files:
# Path: alfpy/utils/distance.py
# class Distance(object):
# def __getitem__(self, seqnum):
# def get_disttypes(cls):
# def set_disttype(self, disttype):
# def __init__(self, vector, disttype):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_google(self, seq1idx, seq2idx):
. Output only the next line. | 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 in enumerate(seq_records.seq_list):
vector = _2DSGraphVector(seq)
data[seqidx] = vector
return data
def create_2DMGraphVectors(seq_records, n):
data = np.zeros(shape=(seq_records.count, n))
for seqidx, seq in enumerate(seq_records.seq_list):
vector = _2DMGraphVector(seq, n)
data[seqidx] = vector
return data
def create_2DNGraphVectors(seq_records):
data = np.zeros(shape=(seq_records.count, 48))
for seqidx, seq in enumerate(seq_records.seq_list):
vector = _2DNGraphVector(seq)
data[seqidx] = vector
return data
<|code_end|>
, predict the immediate next line with the help of imports:
import numpy as np
from .utils import distance
from .utils.seqrecords import main
from .utils import distmatrix
and context (classes, functions, sometimes code) from other files:
# Path: alfpy/utils/distance.py
# class Distance(object):
# def __getitem__(self, seqnum):
# def get_disttypes(cls):
# def set_disttype(self, disttype):
# def __init__(self, vector, disttype):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_google(self, seq1idx, seq2idx):
. Output only the next line. | 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 imports from the current file:
import numpy as np
import unittest
from alfpy import word_pattern
from alfpy import word_vector
from alfpy import word_bool_distance
from alfpy.utils import distmatrix
from . import utils
and context including class names, function names, and sometimes code from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/word_bool_distance.py
# def _nbool_correspond_ft_tf(u, v):
# def _nbool_correspond_all(u, v):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_yule(self, seq1idx, seq2idx):
# def pwdist_rogerstanimoto(self, seq1idx, seq2idx):
# def pwdist_russellrao(self, seq1idx, seq2idx):
# def pwdist_sokalmichener(self, seq1idx, seq2idx):
# def pwdist_sokalsneath(self, seq1idx, seq2idx):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def pwdist_kulsinski(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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|>
, generate the next line using the imports in this file:
import numpy as np
import unittest
from alfpy import word_pattern
from alfpy import word_vector
from alfpy import word_bool_distance
from alfpy.utils import distmatrix
from . import utils
and context (functions, classes, or occasionally code) from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/word_bool_distance.py
# def _nbool_correspond_ft_tf(u, v):
# def _nbool_correspond_all(u, v):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_yule(self, seq1idx, seq2idx):
# def pwdist_rogerstanimoto(self, seq1idx, seq2idx):
# def pwdist_russellrao(self, seq1idx, seq2idx):
# def pwdist_sokalmichener(self, seq1idx, seq2idx):
# def pwdist_sokalsneath(self, seq1idx, seq2idx):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def pwdist_kulsinski(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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.vector = word_vector.Bools(self.pep_records.length_list, self.p)
def test_nbool_correspond_ft_tf(self):
u = np.array([True, False, True])
v = np.array([True, True, False])
<|code_end|>
. Write the next line using the current file imports:
import numpy as np
import unittest
from alfpy import word_pattern
from alfpy import word_vector
from alfpy import word_bool_distance
from alfpy.utils import distmatrix
from . import utils
and context from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/word_bool_distance.py
# def _nbool_correspond_ft_tf(u, v):
# def _nbool_correspond_all(u, v):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_yule(self, seq1idx, seq2idx):
# def pwdist_rogerstanimoto(self, seq1idx, seq2idx):
# def pwdist_russellrao(self, seq1idx, seq2idx):
# def pwdist_sokalmichener(self, seq1idx, seq2idx):
# def pwdist_sokalsneath(self, seq1idx, seq2idx):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def pwdist_kulsinski(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
, which may include functions, classes, or code. Output only the next line. | 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_records.seq_list, 2)
self.vector = word_vector.Bools(self.pep_records.length_list, self.p)
def test_nbool_correspond_ft_tf(self):
u = np.array([True, False, True])
v = np.array([True, True, False])
vec = word_bool_distance._nbool_correspond_ft_tf(u, v)
self.assertEqual(vec, (1, 1))
def test_nbool_correspond_ft_tf_u_equals_v(self):
u = np.array([True, True, False])
v = np.array([True, True, False])
vec = word_bool_distance._nbool_correspond_ft_tf(u, v)
self.assertEqual(vec, (0, 0))
def test_nbool_correspond_all(self):
u = np.array([True, False, True])
v = np.array([True, True, False])
vec = word_bool_distance._nbool_correspond_all(u, v)
self.assertEqual(vec, (0, 1, 1, 1))
def test_distance_dice(self):
dist = word_bool_distance.Distance(self.vector, 'dice')
<|code_end|>
, predict the next line using imports from the current file:
import numpy as np
import unittest
from alfpy import word_pattern
from alfpy import word_vector
from alfpy import word_bool_distance
from alfpy.utils import distmatrix
from . import utils
and context including class names, function names, and sometimes code from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/word_bool_distance.py
# def _nbool_correspond_ft_tf(u, v):
# def _nbool_correspond_all(u, v):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_yule(self, seq1idx, seq2idx):
# def pwdist_rogerstanimoto(self, seq1idx, seq2idx):
# def pwdist_russellrao(self, seq1idx, seq2idx):
# def pwdist_sokalmichener(self, seq1idx, seq2idx):
# def pwdist_sokalsneath(self, seq1idx, seq2idx):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def pwdist_kulsinski(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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_LIST = [
'MEVVIRSANFTDNAKIIIVQLNASVEINCTRPNNYTRKGIRIGPGRAVYAAEEIIGDNTLKQVVTKLRE',
'MVIRSANFTDNAKIIIVQLNASVEINCTRPNNNTRKGIRIGPGRAVYAAEEIIGDIRRAHCNIS',
'MFTDNAKIIIVQLNASVEINCTRPNNNTRKGIHIGPGRAFYATGEIIGDIRQAHCNISGAKW',
'MFTDNAKIIIVQLNASVEINCTRPNNNTR'
]
def _validate_FastaRecord_init(self, fasta_record, seqidx):
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import unittest
from alfpy.utils import fasta
from . import utils
and context (classes, functions, sometimes code) from other files:
# Path: alfpy/utils/fasta.py
# class FastaRecord():
# def __init__(self, seq, seqid, description=False):
# def __iter__(self):
# def __contains__(self, char):
# def __str__(self):
# def __len__(self):
# def format(self, wrap=70):
# def parse(handle):
# def read(handle):
# def to_dict(sequences):
. Output only the next line. | 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):
"""Return a set of words (of a given size) that are present
in a given sequence.
Args:
seq (str)
word_size (int): >= 1
Example:
>>> seq = 'ATGCGTA'
>>> print(_getwords(seq, 2))
set(['GT', 'CG', 'GC', 'AT', 'TG', 'TA'])
"""
s = set([])
for i in range(0, len(seq) - word_size + 1):
word = seq[i:i + word_size]
s.add(word)
return s
<|code_end|>
with the help of current file imports:
from .utils import distance
from .utils.seqrecords import SeqRecords
from .utils import distmatrix
and context from other files:
# Path: alfpy/utils/distance.py
# class Distance(object):
# def __getitem__(self, seqnum):
# def get_disttypes(cls):
# def set_disttype(self, disttype):
# def __init__(self, vector, disttype):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_google(self, seq1idx, seq2idx):
, which may contain function names, class names, or code. Output only the next line. | 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_help=False, prog='calc_word_bool.py'
)
group = parser.add_argument_group('REQUIRED ARGUMENTS')
group.add_argument('--fasta', '-f',
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_exclusive_group()
g1.add_argument('--word_size', '-s', metavar="N",
help='word size for creating word patterns',
type=int)
g1.add_argument('--word_pattern', '-w',
help='input filename w/ pre-computed word patterns',
type=argparse.FileType('r'), metavar="FILE")
group = parser.add_argument_group('OPTIONAL ARGUMENTS')
<|code_end|>
. Write the next line using the current file imports:
import argparse
import sys
from alfpy import word_bool_distance
from alfpy import word_pattern
from alfpy import word_vector
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context from other files:
# Path: alfpy/word_bool_distance.py
# def _nbool_correspond_ft_tf(u, v):
# def _nbool_correspond_all(u, v):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_yule(self, seq1idx, seq2idx):
# def pwdist_rogerstanimoto(self, seq1idx, seq2idx):
# def pwdist_russellrao(self, seq1idx, seq2idx):
# def pwdist_sokalmichener(self, seq1idx, seq2idx):
# def pwdist_sokalsneath(self, seq1idx, seq2idx):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def pwdist_kulsinski(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
, which may include functions, classes, or code. Output only the next line. | 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="output filename",
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")
group.add_argument("-h", "--help", action="help",
help="show this help message and exit")
group.add_argument('--version', action='version',
version='%(prog)s {}'.format(__version__))
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:
parser.error('Word size must be >= 1.')
<|code_end|>
. Use current file imports:
(import argparse
import sys
from alfpy import word_bool_distance
from alfpy import word_pattern
from alfpy import word_vector
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__)
and context including class names, function names, or small code snippets from other files:
# Path: alfpy/word_bool_distance.py
# def _nbool_correspond_ft_tf(u, v):
# def _nbool_correspond_all(u, v):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_yule(self, seq1idx, seq2idx):
# def pwdist_rogerstanimoto(self, seq1idx, seq2idx):
# def pwdist_russellrao(self, seq1idx, seq2idx):
# def pwdist_sokalmichener(self, seq1idx, seq2idx):
# def pwdist_sokalsneath(self, seq1idx, seq2idx):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def pwdist_kulsinski(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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:
parser.error('Word size must be >= 1.')
elif args.word_pattern:
pass
else:
parser.error("Specify either: --word_size or --word_pattern.")
return args
def main():
parser = get_parser()
args = validate_args(parser)
seq_records = seqrecords.read_fasta(args.fasta)
if args.word_size:
p = word_pattern.create(seq_records.seq_list, args.word_size)
else:
p = word_pattern.read(args.word_pattern)
<|code_end|>
. Use current file imports:
(import argparse
import sys
from alfpy import word_bool_distance
from alfpy import word_pattern
from alfpy import word_vector
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__)
and context including class names, function names, or small code snippets from other files:
# Path: alfpy/word_bool_distance.py
# def _nbool_correspond_ft_tf(u, v):
# def _nbool_correspond_all(u, v):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_yule(self, seq1idx, seq2idx):
# def pwdist_rogerstanimoto(self, seq1idx, seq2idx):
# def pwdist_russellrao(self, seq1idx, seq2idx):
# def pwdist_sokalmichener(self, seq1idx, seq2idx):
# def pwdist_sokalsneath(self, seq1idx, seq2idx):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def pwdist_kulsinski(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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_pattern:
pass
else:
parser.error("Specify either: --word_size or --word_pattern.")
return args
def main():
parser = get_parser()
args = validate_args(parser)
seq_records = seqrecords.read_fasta(args.fasta)
if args.word_size:
p = word_pattern.create(seq_records.seq_list, args.word_size)
else:
p = word_pattern.read(args.word_pattern)
bools = word_vector.Bools(seq_records.length_list, p)
dist = word_bool_distance.Distance(bools, args.distance)
<|code_end|>
. Write the next line using the current file imports:
import argparse
import sys
from alfpy import word_bool_distance
from alfpy import word_pattern
from alfpy import word_vector
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context from other files:
# Path: alfpy/word_bool_distance.py
# def _nbool_correspond_ft_tf(u, v):
# def _nbool_correspond_all(u, v):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_yule(self, seq1idx, seq2idx):
# def pwdist_rogerstanimoto(self, seq1idx, seq2idx):
# def pwdist_russellrao(self, seq1idx, seq2idx):
# def pwdist_sokalmichener(self, seq1idx, seq2idx):
# def pwdist_sokalsneath(self, seq1idx, seq2idx):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def pwdist_kulsinski(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
, which may include functions, classes, or code. Output only the next line. | 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',
version='%(prog)s {}'.format(__version__))
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:
parser.error('Word size must be >= 1.')
elif args.word_pattern:
pass
else:
parser.error("Specify either: --word_size or --word_pattern.")
return args
def main():
parser = get_parser()
args = validate_args(parser)
<|code_end|>
, predict the next line using imports from the current file:
import argparse
import sys
from alfpy import word_bool_distance
from alfpy import word_pattern
from alfpy import word_vector
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context including class names, function names, and sometimes code from other files:
# Path: alfpy/word_bool_distance.py
# def _nbool_correspond_ft_tf(u, v):
# def _nbool_correspond_all(u, v):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_yule(self, seq1idx, seq2idx):
# def pwdist_rogerstanimoto(self, seq1idx, seq2idx):
# def pwdist_russellrao(self, seq1idx, seq2idx):
# def pwdist_sokalmichener(self, seq1idx, seq2idx):
# def pwdist_sokalsneath(self, seq1idx, seq2idx):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def pwdist_kulsinski(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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 alfpy import word_pattern
from alfpy import word_sets_distance
from alfpy.utils import distmatrix
from . import utils)
and context including class names, function names, or small code snippets from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_sets_distance.py
# def _getwords(seq, word_size):
# def __init__(self, seq_records, word_size, disttype='jaccard'):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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 test_getwords(self):
<|code_end|>
. Use current file imports:
import numpy as np
import unittest
from alfpy import word_pattern
from alfpy import word_sets_distance
from alfpy.utils import distmatrix
from . import utils
and context (classes, functions, or code) from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_sets_distance.py
# def _getwords(seq, word_size):
# def __init__(self, seq_records, word_size, disttype='jaccard'):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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_getwords(self):
words = word_sets_distance._getwords('ATGCGTA', 2)
self.assertSetEqual(words, set(['GT', 'CG', 'GC', 'AT', 'TG', 'TA']))
def test_distance_dice(self):
# The result of this function is identical
# to the Dice distance implemented in word_bool_distance.
dist = word_sets_distance.Distance(self.pep_records, 2, 'dice')
<|code_end|>
, generate the next line using the imports in this file:
import numpy as np
import unittest
from alfpy import word_pattern
from alfpy import word_sets_distance
from alfpy.utils import distmatrix
from . import utils
and context (functions, classes, or occasionally code) from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_sets_distance.py
# def _getwords(seq, word_size):
# def __init__(self, seq_records, word_size, disttype='jaccard'):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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 unittest
from alfpy import word_pattern
from alfpy import word_rtd
from alfpy.utils import distmatrix
from . import utils
and context (classes, functions, sometimes code) from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_rtd.py
# def calc_rtd(word_positions):
# def create_vector(seqcount, pattern):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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_list, 2, True)
def test_calc_rtd(self):
seq = 'CTACACAACTTTGCGGGTAGCCGGAAACATTGTGAATGCGGTGAACA'
apos = [i for i, nt in enumerate(seq) if nt == 'A']
<|code_end|>
. Use current file imports:
(import unittest
from alfpy import word_pattern
from alfpy import word_rtd
from alfpy.utils import distmatrix
from . import utils)
and context including class names, function names, or small code snippets from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_rtd.py
# def calc_rtd(word_positions):
# def create_vector(seqcount, pattern):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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_list, 2, True)
def test_calc_rtd(self):
seq = 'CTACACAACTTTGCGGGTAGCCGGAAACATTGTGAATGCGGTGAACA'
apos = [i for i, nt in enumerate(seq) if nt == 'A']
val = word_rtd.calc_rtd(apos)
exp = (3.3846153846153846, 3.1510306381944679)
self.assertEqual(val, exp)
def test_create_vector(self):
vec = word_rtd.create_vector(self.pep_records.count, self.pep_2mer_pos)
exp = (self.pep_records.count, len(self.pep_2mer_pos.pat_list)*2)
self.assertEqual(vec.shape, exp)
def test_distance(self):
vec = word_rtd.create_vector(self.pep_records.count, self.pep_2mer_pos)
dist = word_rtd.Distance(vec, 'google')
<|code_end|>
. Write the next line using the current file imports:
import unittest
from alfpy import word_pattern
from alfpy import word_rtd
from alfpy.utils import distmatrix
from . import utils
and context from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_rtd.py
# def calc_rtd(word_positions):
# def create_vector(seqcount, pattern):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
, which may include functions, classes, or code. Output only the next line. | 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()
fh = open(self.output_filename)
result = fh.read()
fh.close()
os.remove(self.output_filename)
exp = [
"seq1\tseq2\t0.353",
"seq1\tseq3\t0.355",
"seq2\tseq3\t0.295\n"
]
self.assertEqual(result, "\n".join(exp))
def test_iter(self):
exp = [(0, 1, 'seq1', 'seq2', 0.35315869999999999),
(0, 2, 'seq1', 'seq3', 0.35509332999999998),
(1, 2, 'seq2', 'seq3', 0.29539399999999999)]
self.assertEqual(list(self.matrix), exp)
def test_create_matrix(self):
l = [[3, 6, 4, 1, 3, 4, 3, 0, 1, 1, 6, 4, 5, 0, 3, 4],
[0, 3, 0, 3, 0, 0, 0, 2, 9, 0, 3, 3, 0, 6, 3, 6],
[9, 0, 0, 3, 0, 0, 0, 2, 6, 0, 3, 3, 0, 3, 3, 3]]
vector = np.array(l)
<|code_end|>
using the current file's imports:
import numpy as np
import os
import unittest
from alfpy import word_distance
from alfpy.utils import distmatrix
from . import utils
and any relevant context from other files:
# Path: alfpy/word_distance.py
# def geometric_mean(values):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen1(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen2(self, seq1idx, seq2idx):
# def __angle_cos(self, seq1idx, seq2idx):
# def pwdist_angle_cos_diss(self, seq1idx, seq2idx):
# def pwdist_angle_cos_evol(self, seq1idx, seq2idx):
# def pwdist_manhattan(self, seq1idx, seq2idx):
# def pwdist_diff_abs_add(self, seq1idx, seq2idx):
# def pwdist_chebyshev(self, seq1idx, seq2idx):
# def pwdist_braycurtis(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult1(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult2(self, seq1idx, seq2idx):
# def pwdist_kld(self, seq1idx, seq2idx):
# def pwdist_jsd(self, seq1idx, seq2idx):
# def entropy(p, q):
# def pwdist_google(self, seq1idx, seq2idx):
# def pwdist_lcc(self, seq1idx, seq2idx):
# def pwdist_canberra(self, seq1idx, seq2idx):
# def pwdist_minkowski(self, seq1idx, seq2idx, p=2):
# def main():
# class Distance(distance.Distance):
# _P = x + 0.0000001
# _Q = y + 0.0000001
# _M = 0.5 * (_P + _Q)
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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.35509333, 0.295394, 0.]
])
<|code_end|>
, predict the next line using imports from the current file:
import numpy as np
import os
import unittest
from alfpy import word_distance
from alfpy.utils import distmatrix
from . import utils
and context including class names, function names, and sometimes code from other files:
# Path: alfpy/word_distance.py
# def geometric_mean(values):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen1(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen2(self, seq1idx, seq2idx):
# def __angle_cos(self, seq1idx, seq2idx):
# def pwdist_angle_cos_diss(self, seq1idx, seq2idx):
# def pwdist_angle_cos_evol(self, seq1idx, seq2idx):
# def pwdist_manhattan(self, seq1idx, seq2idx):
# def pwdist_diff_abs_add(self, seq1idx, seq2idx):
# def pwdist_chebyshev(self, seq1idx, seq2idx):
# def pwdist_braycurtis(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult1(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult2(self, seq1idx, seq2idx):
# def pwdist_kld(self, seq1idx, seq2idx):
# def pwdist_jsd(self, seq1idx, seq2idx):
# def entropy(p, q):
# def pwdist_google(self, seq1idx, seq2idx):
# def pwdist_lcc(self, seq1idx, seq2idx):
# def pwdist_canberra(self, seq1idx, seq2idx):
# def pwdist_minkowski(self, seq1idx, seq2idx, p=2):
# def main():
# class Distance(distance.Distance):
# _P = x + 0.0000001
# _Q = y + 0.0000001
# _M = 0.5 * (_P + _Q)
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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 2:1
4 3 C 0:1 1:2 2:1
2 2 T 0:1 2:1
2 2 A 0:1 2:1
>>> p = create(seqs, 1, True)
>>> print(p)
4 3 G 0 2 1 1 1 3 2 0
4 3 C 0 3 1 0 1 2 2 1
2 2 T 0 1 2 3
2 2 A 0 0 2 2
"""
if wordpos:
return _create_wordpattern_positions(seq_list, word_size)
return _create_wordpattern(seq_list, word_size)
def create_from_fasta(handle, word_size=1, wordpos=False):
"""Create word patterns (Pattern object) from a FASTA file"""
<|code_end|>
. Use current file imports:
(from alfpy.utils import seqrecords
from .utils import seqrecords
from .utils.data import seqcontent
import subprocess
import uuid
import os)
and context including class names, function names, or small code snippets from other files:
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
. Output only the next line. | 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", action="help",
help="show this help message and exit")
group.add_argument('--version', action='version',
version='%(prog)s {}'.format(__version__))
if len(sys.argv[1:]) == 0:
# parser.print_help()
parser.print_usage()
parser.exit()
return parser
def validate_args(parser):
args = parser.parse_args()
if args.word_size < 1:
parser.error('--word_size must be >= 1')
return args
def main():
parser = get_parser()
args = validate_args(parser)
seq_records = seqrecords.read_fasta(args.fasta)
<|code_end|>
. Use current file imports:
import argparse
import sys
from alfpy import fcgr
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context (classes, functions, or code) from other files:
# Path: alfpy/fcgr.py
# def fcgr_vector(dnaseq, word_size):
# def create_vectors(seq_records, word_size):
# def __init__(self, vector, disttype='euclid_norm'):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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('--version', action='version',
version='%(prog)s {}'.format(__version__))
if len(sys.argv[1:]) == 0:
# parser.print_help()
parser.print_usage()
parser.exit()
return parser
def validate_args(parser):
args = parser.parse_args()
if args.word_size < 1:
parser.error('--word_size must be >= 1')
return args
def main():
parser = get_parser()
args = validate_args(parser)
seq_records = seqrecords.read_fasta(args.fasta)
vector = fcgr.create_vectors(seq_records, args.word_size)
dist = fcgr.Distance(vector)
<|code_end|>
, generate the next line using the imports in this file:
import argparse
import sys
from alfpy import fcgr
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context (functions, classes, or occasionally code) from other files:
# Path: alfpy/fcgr.py
# def fcgr_vector(dnaseq, word_size):
# def create_vectors(seq_records, word_size):
# def __init__(self, vector, disttype='euclid_norm'):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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]')
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(__version__))
if len(sys.argv[1:]) == 0:
# parser.print_help()
parser.print_usage()
parser.exit()
return parser
def validate_args(parser):
args = parser.parse_args()
if args.word_size < 1:
parser.error('--word_size must be >= 1')
return args
def main():
parser = get_parser()
args = validate_args(parser)
<|code_end|>
, predict the immediate next line with the help of imports:
import argparse
import sys
from alfpy import fcgr
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context (classes, functions, sometimes code) from other files:
# Path: alfpy/fcgr.py
# def fcgr_vector(dnaseq, word_size):
# def create_vectors(seq_records, word_size):
# def __init__(self, vector, disttype='euclid_norm'):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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_help=False, prog='calc_fcgr.py'
)
group = parser.add_argument_group('REQUIRED ARGUMENTS')
group.add_argument('--fasta', '-f',
help='input FASTA sequence filename', required=True,
type=argparse.FileType('r'), metavar="FILE")
group.add_argument('--word_size', '-w', required=True,
help='word size', type=int)
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',
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('--version', action='version',
<|code_end|>
. Write the next line using the current file imports:
import argparse
import sys
from alfpy import fcgr
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context from other files:
# Path: alfpy/fcgr.py
# def fcgr_vector(dnaseq, word_size):
# def create_vectors(seq_records, word_size):
# def __init__(self, vector, disttype='euclid_norm'):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
, which may include functions, classes, or code. Output only the next line. | 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|>
. Use current file imports:
import os
import unittest
from alfpy import word_pattern
from . import utils
and context (classes, functions, or code) from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
. Output only the next line. | 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")
group.add_argument("-h", "--help", action="help",
help="show this help message and exit")
group.add_argument('--version', action='version',
version='%(prog)s {}'.format(__version__))
if len(sys.argv[1:]) == 0:
# parser.print_help()
parser.print_usage()
parser.exit()
return parser
def validate_args(parser):
args = parser.parse_args()
if args.word_size < 1:
parser.error('Word size must be >= 1.')
return args
def main():
parser = get_parser()
args = validate_args(parser)
seq_records = seqrecords.read_fasta(args.fasta)
<|code_end|>
, predict the next line using imports from the current file:
import argparse
import sys
from alfpy import word_sets_distance
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context including class names, function names, and sometimes code from other files:
# Path: alfpy/word_sets_distance.py
# def _getwords(seq, word_size):
# def __init__(self, seq_records, word_size, disttype='jaccard'):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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_argument('--version', action='version',
version='%(prog)s {}'.format(__version__))
if len(sys.argv[1:]) == 0:
# parser.print_help()
parser.print_usage()
parser.exit()
return parser
def validate_args(parser):
args = parser.parse_args()
if args.word_size < 1:
parser.error('Word size must be >= 1.')
return args
def main():
parser = get_parser()
args = validate_args(parser)
seq_records = seqrecords.read_fasta(args.fasta)
dist = word_sets_distance.Distance(seq_records, args.word_size,
args.distance)
<|code_end|>
using the current file's imports:
import argparse
import sys
from alfpy import word_sets_distance
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and any relevant context from other files:
# Path: alfpy/word_sets_distance.py
# def _getwords(seq, word_size):
# def __init__(self, seq_records, word_size, disttype='jaccard'):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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")
group.add_argument("-h", "--help", action="help",
help="show this help message and exit")
group.add_argument('--version', action='version',
version='%(prog)s {}'.format(__version__))
if len(sys.argv[1:]) == 0:
# parser.print_help()
parser.print_usage()
parser.exit()
return parser
def validate_args(parser):
args = parser.parse_args()
if args.word_size < 1:
parser.error('Word size must be >= 1.')
return args
def main():
parser = get_parser()
args = validate_args(parser)
<|code_end|>
. Use current file imports:
(import argparse
import sys
from alfpy import word_sets_distance
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__)
and context including class names, function names, or small code snippets from other files:
# Path: alfpy/word_sets_distance.py
# def _getwords(seq, word_size):
# def __init__(self, seq_records, word_size, disttype='jaccard'):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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 sequence filename', required=True,
type=argparse.FileType('r'), metavar="FILE")
group.add_argument('--word_size', '-s', metavar="N", required=True,
help='word size for creating word patterns',
type=int)
group = parser.add_argument_group('OPTIONAL ARGUMENTS')
distlist = ['dice', 'hamming', 'jaccard']
group.add_argument('--distance', '-d', choices=distlist,
help='choose from: {} [DEFAULT: %(default)s]'.format(
", ".join(distlist)),
metavar='', default="dice")
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',
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('--version', action='version',
<|code_end|>
with the help of current file imports:
import argparse
import sys
from alfpy import word_sets_distance
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context from other files:
# Path: alfpy/word_sets_distance.py
# def _getwords(seq, word_size):
# def __init__(self, seq_records, word_size, disttype='jaccard'):
# def pwdist_jaccard(self, seq1idx, seq2idx):
# def pwdist_dice(self, seq1idx, seq2idx):
# def pwdist_hamming(self, seq1idx, seq2idx):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
, which may contain function names, class names, or code. Output only the next line. | 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] += 1
vectors.pop(0)
return vectors
def create_vectors(seq_records, word_size):
"""Create a matrix of FCGR vectors.
Args:
seq_records (obj: SeqRecords)
word_size (int): word size (>= 1)
Returns:
numpy.ndarray
"""
data = np.zeros(shape=(seq_records.count, pow(4, word_size) - 1))
for seqidx, seq in enumerate(seq_records.seq_list):
vector = fcgr_vector(seq, word_size)
data[seqidx] = vector
return data
<|code_end|>
, predict the next line using imports from the current file:
import numpy as np
from .utils import distance
from .utils.seqrecords import main
from .utils import distmatrix
and context including class names, function names, and sometimes code from other files:
# Path: alfpy/utils/distance.py
# class Distance(object):
# def __getitem__(self, seqnum):
# def get_disttypes(cls):
# def set_disttype(self, disttype):
# def __init__(self, vector, disttype):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_google(self, seq1idx, seq2idx):
. Output only the next line. | 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'
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import unittest
from alfpy import lempelziv
from alfpy.utils import distmatrix
from . import utils
and context:
# Path: alfpy/lempelziv.py
# def complexity(s):
# def complexity1(seq):
# def is_reproducible(seq, index, hist_len, last_match=0):
# def __init__(self, seq_records, disttype='d1_star'):
# def __precompute_complexity(self):
# def __get_complexity(self, seq1idx, seq2idx):
# def pwdist_d(self, seq1idx, seq2idx):
# def pwdist_d_star(self, seq1idx, seq2idx):
# def pwdist_d1(self, seq1idx, seq2idx):
# def pwdist_d1_star(self, seq1idx, seq2idx):
# def pwdist_d1_star2(self, seq1idx, seq2idx):
# def set_disttype(self, disttype):
# def main():
# class Distance:
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
which might include code, classes, or functions. Output only the next line. | 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)
self.assertEqual(c, 20)
def test_complexities(self):
dist = lempelziv.Distance(self.pep_records)
exp = [((0,), 40), ((0, 1), 47), ((0, 2), 53),
((0, 3), 43), ((1,), 38), ((1, 0), 47),
((1, 2), 47), ((1, 3), 41), ((2,), 35),
((2, 0), 50), ((2, 1), 45), ((2, 3), 37),
((3,), 19), ((3, 0), 39), ((3, 1), 37),
((3, 2), 36)]
self.assertEqual(sorted(dist._complexity.items()), exp)
class DistanceTest(unittest.TestCase, utils.ModulesCommonTest):
def __init__(self, *args, **kwargs):
super(DistanceTest, self).__init__(*args, **kwargs)
utils.ModulesCommonTest.set_test_data()
self.dist = lempelziv.Distance(self.pep_records, 'd')
def test_distance_d(self):
<|code_end|>
using the current file's imports:
import unittest
from alfpy import lempelziv
from alfpy.utils import distmatrix
from . import utils
and any relevant context from other files:
# Path: alfpy/lempelziv.py
# def complexity(s):
# def complexity1(seq):
# def is_reproducible(seq, index, hist_len, last_match=0):
# def __init__(self, seq_records, disttype='d1_star'):
# def __precompute_complexity(self):
# def __get_complexity(self, seq1idx, seq2idx):
# def pwdist_d(self, seq1idx, seq2idx):
# def pwdist_d_star(self, seq1idx, seq2idx):
# def pwdist_d1(self, seq1idx, seq2idx):
# def pwdist_d1_star(self, seq1idx, seq2idx):
# def pwdist_d1_star2(self, seq1idx, seq2idx):
# def set_disttype(self, disttype):
# def main():
# class Distance:
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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, Rigoutsos, Ragan (2006) Evol Bioinform Online 2: 359-375.
doi: 10.1080/10635150701294741.
"""
def geometric_mean(values):
"""Calculate geometric mean in numpy array.
Avoids numerical over- and underflow at the cost of compute time.
Args:
values (ndarray)
Returns:
float
"""
inv_len = 1.0 / values.size
x = values**inv_len
return x.prod()
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import math
import numpy as np
from .utils import distance
from .utils.seqrecords import main as main1
from .word_vector import main as main2
from .utils import distmatrix
and context:
# Path: alfpy/utils/distance.py
# class Distance(object):
# def __getitem__(self, seqnum):
# def get_disttypes(cls):
# def set_disttype(self, disttype):
# def __init__(self, vector, disttype):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_google(self, seq1idx, seq2idx):
which might include code, classes, or functions. Output only the next line. | 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 their
relative orders''',
add_help=False, prog='calc_word_rtd.py'
)
group = parser.add_argument_group('REQUIRED ARGUMENTS')
group.add_argument('--fasta', '-f',
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_exclusive_group()
g1.add_argument('--word_size', '-s', metavar="N",
help='word size for creating word patterns',
type=int)
g1.add_argument('--word_pattern', '-w',
help='input filename w/ pre-computed word patterns',
type=argparse.FileType('r'), metavar="FILE")
group = parser.add_argument_group('OPTIONAL ARGUMENTS')
<|code_end|>
. Use current file imports:
import argparse
import sys
from alfpy import word_distance
from alfpy import word_pattern
from alfpy import word_rtd
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context (classes, functions, or code) from other files:
# Path: alfpy/word_distance.py
# def geometric_mean(values):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen1(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen2(self, seq1idx, seq2idx):
# def __angle_cos(self, seq1idx, seq2idx):
# def pwdist_angle_cos_diss(self, seq1idx, seq2idx):
# def pwdist_angle_cos_evol(self, seq1idx, seq2idx):
# def pwdist_manhattan(self, seq1idx, seq2idx):
# def pwdist_diff_abs_add(self, seq1idx, seq2idx):
# def pwdist_chebyshev(self, seq1idx, seq2idx):
# def pwdist_braycurtis(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult1(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult2(self, seq1idx, seq2idx):
# def pwdist_kld(self, seq1idx, seq2idx):
# def pwdist_jsd(self, seq1idx, seq2idx):
# def entropy(p, q):
# def pwdist_google(self, seq1idx, seq2idx):
# def pwdist_lcc(self, seq1idx, seq2idx):
# def pwdist_canberra(self, seq1idx, seq2idx):
# def pwdist_minkowski(self, seq1idx, seq2idx, p=2):
# def main():
# class Distance(distance.Distance):
# _P = x + 0.0000001
# _Q = y + 0.0000001
# _M = 0.5 * (_P + _Q)
#
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_rtd.py
# def calc_rtd(word_positions):
# def create_vector(seqcount, pattern):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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="output filename",
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")
group.add_argument("-h", "--help", action="help",
help="show this help message and exit")
group.add_argument('--version', action='version',
version='%(prog)s {}'.format(__version__))
if len(sys.argv[1:]) == 0:
# 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')
<|code_end|>
. Write the next line using the current file imports:
import argparse
import sys
from alfpy import word_distance
from alfpy import word_pattern
from alfpy import word_rtd
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context from other files:
# Path: alfpy/word_distance.py
# def geometric_mean(values):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen1(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen2(self, seq1idx, seq2idx):
# def __angle_cos(self, seq1idx, seq2idx):
# def pwdist_angle_cos_diss(self, seq1idx, seq2idx):
# def pwdist_angle_cos_evol(self, seq1idx, seq2idx):
# def pwdist_manhattan(self, seq1idx, seq2idx):
# def pwdist_diff_abs_add(self, seq1idx, seq2idx):
# def pwdist_chebyshev(self, seq1idx, seq2idx):
# def pwdist_braycurtis(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult1(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult2(self, seq1idx, seq2idx):
# def pwdist_kld(self, seq1idx, seq2idx):
# def pwdist_jsd(self, seq1idx, seq2idx):
# def entropy(p, q):
# def pwdist_google(self, seq1idx, seq2idx):
# def pwdist_lcc(self, seq1idx, seq2idx):
# def pwdist_canberra(self, seq1idx, seq2idx):
# def pwdist_minkowski(self, seq1idx, seq2idx, p=2):
# def main():
# class Distance(distance.Distance):
# _P = x + 0.0000001
# _Q = y + 0.0000001
# _M = 0.5 * (_P + _Q)
#
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_rtd.py
# def calc_rtd(word_positions):
# def create_vector(seqcount, pattern):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
, which may include functions, classes, or code. Output only the next line. | 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 = "{0} does not contain info on word positions.\n"
e += "Please use: create_wordpattern.py with"
e += " --word_position option."
parser.error(e.format(args.word_pattern.name))
else:
args.word_pattern = p
else:
parser.error("Specify either: --word_size or --word_pattern.")
return args
def main():
parser = get_parser()
args = validate_args(parser)
seq_records = seqrecords.read_fasta(args.fasta)
if args.word_size:
p = word_pattern.create(seq_records.seq_list, args.word_size, True)
else:
p = args.word_pattern
<|code_end|>
, predict the immediate next line with the help of imports:
import argparse
import sys
from alfpy import word_distance
from alfpy import word_pattern
from alfpy import word_rtd
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context (classes, functions, sometimes code) from other files:
# Path: alfpy/word_distance.py
# def geometric_mean(values):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen1(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen2(self, seq1idx, seq2idx):
# def __angle_cos(self, seq1idx, seq2idx):
# def pwdist_angle_cos_diss(self, seq1idx, seq2idx):
# def pwdist_angle_cos_evol(self, seq1idx, seq2idx):
# def pwdist_manhattan(self, seq1idx, seq2idx):
# def pwdist_diff_abs_add(self, seq1idx, seq2idx):
# def pwdist_chebyshev(self, seq1idx, seq2idx):
# def pwdist_braycurtis(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult1(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult2(self, seq1idx, seq2idx):
# def pwdist_kld(self, seq1idx, seq2idx):
# def pwdist_jsd(self, seq1idx, seq2idx):
# def entropy(p, q):
# def pwdist_google(self, seq1idx, seq2idx):
# def pwdist_lcc(self, seq1idx, seq2idx):
# def pwdist_canberra(self, seq1idx, seq2idx):
# def pwdist_minkowski(self, seq1idx, seq2idx, p=2):
# def main():
# class Distance(distance.Distance):
# _P = x + 0.0000001
# _Q = y + 0.0000001
# _M = 0.5 * (_P + _Q)
#
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_rtd.py
# def calc_rtd(word_positions):
# def create_vector(seqcount, pattern):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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 positions.\n"
e += "Please use: create_wordpattern.py with"
e += " --word_position option."
parser.error(e.format(args.word_pattern.name))
else:
args.word_pattern = p
else:
parser.error("Specify either: --word_size or --word_pattern.")
return args
def main():
parser = get_parser()
args = validate_args(parser)
seq_records = seqrecords.read_fasta(args.fasta)
if args.word_size:
p = word_pattern.create(seq_records.seq_list, args.word_size, True)
else:
p = args.word_pattern
vector = word_rtd.create_vector(seq_records.count, p)
dist = word_rtd.Distance(vector, args.distance)
<|code_end|>
using the current file's imports:
import argparse
import sys
from alfpy import word_distance
from alfpy import word_pattern
from alfpy import word_rtd
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and any relevant context from other files:
# Path: alfpy/word_distance.py
# def geometric_mean(values):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen1(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen2(self, seq1idx, seq2idx):
# def __angle_cos(self, seq1idx, seq2idx):
# def pwdist_angle_cos_diss(self, seq1idx, seq2idx):
# def pwdist_angle_cos_evol(self, seq1idx, seq2idx):
# def pwdist_manhattan(self, seq1idx, seq2idx):
# def pwdist_diff_abs_add(self, seq1idx, seq2idx):
# def pwdist_chebyshev(self, seq1idx, seq2idx):
# def pwdist_braycurtis(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult1(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult2(self, seq1idx, seq2idx):
# def pwdist_kld(self, seq1idx, seq2idx):
# def pwdist_jsd(self, seq1idx, seq2idx):
# def entropy(p, q):
# def pwdist_google(self, seq1idx, seq2idx):
# def pwdist_lcc(self, seq1idx, seq2idx):
# def pwdist_canberra(self, seq1idx, seq2idx):
# def pwdist_minkowski(self, seq1idx, seq2idx, p=2):
# def main():
# class Distance(distance.Distance):
# _P = x + 0.0000001
# _Q = y + 0.0000001
# _M = 0.5 * (_P + _Q)
#
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_rtd.py
# def calc_rtd(word_positions):
# def create_vector(seqcount, pattern):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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.word_pattern:
p = word_pattern.read(args.word_pattern)
if not p.pos_list:
e = "{0} does not contain info on word positions.\n"
e += "Please use: create_wordpattern.py with"
e += " --word_position option."
parser.error(e.format(args.word_pattern.name))
else:
args.word_pattern = p
else:
parser.error("Specify either: --word_size or --word_pattern.")
return args
def main():
parser = get_parser()
args = validate_args(parser)
<|code_end|>
, generate the next line using the imports in this file:
import argparse
import sys
from alfpy import word_distance
from alfpy import word_pattern
from alfpy import word_rtd
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context (functions, classes, or occasionally code) from other files:
# Path: alfpy/word_distance.py
# def geometric_mean(values):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen1(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen2(self, seq1idx, seq2idx):
# def __angle_cos(self, seq1idx, seq2idx):
# def pwdist_angle_cos_diss(self, seq1idx, seq2idx):
# def pwdist_angle_cos_evol(self, seq1idx, seq2idx):
# def pwdist_manhattan(self, seq1idx, seq2idx):
# def pwdist_diff_abs_add(self, seq1idx, seq2idx):
# def pwdist_chebyshev(self, seq1idx, seq2idx):
# def pwdist_braycurtis(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult1(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult2(self, seq1idx, seq2idx):
# def pwdist_kld(self, seq1idx, seq2idx):
# def pwdist_jsd(self, seq1idx, seq2idx):
# def entropy(p, q):
# def pwdist_google(self, seq1idx, seq2idx):
# def pwdist_lcc(self, seq1idx, seq2idx):
# def pwdist_canberra(self, seq1idx, seq2idx):
# def pwdist_minkowski(self, seq1idx, seq2idx, p=2):
# def main():
# class Distance(distance.Distance):
# _P = x + 0.0000001
# _Q = y + 0.0000001
# _M = 0.5 * (_P + _Q)
#
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_rtd.py
# def calc_rtd(word_positions):
# def create_vector(seqcount, pattern):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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_exclusive_group()
g1.add_argument('--word_size', '-s', metavar="N",
help='word size for creating word patterns',
type=int)
g1.add_argument('--word_pattern', '-w',
help='input filename w/ pre-computed word patterns',
type=argparse.FileType('r'), metavar="FILE")
group = parser.add_argument_group('OPTIONAL ARGUMENTS')
distlist = word_distance.Distance.get_disttypes()
group.add_argument('--distance', '-d', choices=distlist,
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="output filename",
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")
group.add_argument("-h", "--help", action="help",
help="show this help message and exit")
group.add_argument('--version', action='version',
<|code_end|>
, predict the next line using imports from the current file:
import argparse
import sys
from alfpy import word_distance
from alfpy import word_pattern
from alfpy import word_rtd
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context including class names, function names, and sometimes code from other files:
# Path: alfpy/word_distance.py
# def geometric_mean(values):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen1(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen2(self, seq1idx, seq2idx):
# def __angle_cos(self, seq1idx, seq2idx):
# def pwdist_angle_cos_diss(self, seq1idx, seq2idx):
# def pwdist_angle_cos_evol(self, seq1idx, seq2idx):
# def pwdist_manhattan(self, seq1idx, seq2idx):
# def pwdist_diff_abs_add(self, seq1idx, seq2idx):
# def pwdist_chebyshev(self, seq1idx, seq2idx):
# def pwdist_braycurtis(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult1(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult2(self, seq1idx, seq2idx):
# def pwdist_kld(self, seq1idx, seq2idx):
# def pwdist_jsd(self, seq1idx, seq2idx):
# def entropy(p, q):
# def pwdist_google(self, seq1idx, seq2idx):
# def pwdist_lcc(self, seq1idx, seq2idx):
# def pwdist_canberra(self, seq1idx, seq2idx):
# def pwdist_minkowski(self, seq1idx, seq2idx, p=2):
# def main():
# class Distance(distance.Distance):
# _P = x + 0.0000001
# _Q = y + 0.0000001
# _M = 0.5 * (_P + _Q)
#
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_rtd.py
# def calc_rtd(word_positions):
# def create_vector(seqcount, pattern):
# def main():
# class Distance(distance.Distance):
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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:
import unittest
from alfpy import word_pattern
from alfpy import word_vector
from alfpy import word_distance
from alfpy.utils import distmatrix
from . import utils
and context from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/word_distance.py
# def geometric_mean(values):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen1(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen2(self, seq1idx, seq2idx):
# def __angle_cos(self, seq1idx, seq2idx):
# def pwdist_angle_cos_diss(self, seq1idx, seq2idx):
# def pwdist_angle_cos_evol(self, seq1idx, seq2idx):
# def pwdist_manhattan(self, seq1idx, seq2idx):
# def pwdist_diff_abs_add(self, seq1idx, seq2idx):
# def pwdist_chebyshev(self, seq1idx, seq2idx):
# def pwdist_braycurtis(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult1(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult2(self, seq1idx, seq2idx):
# def pwdist_kld(self, seq1idx, seq2idx):
# def pwdist_jsd(self, seq1idx, seq2idx):
# def entropy(p, q):
# def pwdist_google(self, seq1idx, seq2idx):
# def pwdist_lcc(self, seq1idx, seq2idx):
# def pwdist_canberra(self, seq1idx, seq2idx):
# def pwdist_minkowski(self, seq1idx, seq2idx, p=2):
# def main():
# class Distance(distance.Distance):
# _P = x + 0.0000001
# _Q = y + 0.0000001
# _M = 0.5 * (_P + _Q)
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
, which may include functions, classes, or code. Output only the next line. | 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, 2)
<|code_end|>
. Write the next line using the current file imports:
import unittest
from alfpy import word_pattern
from alfpy import word_vector
from alfpy import word_distance
from alfpy.utils import distmatrix
from . import utils
and context from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/word_distance.py
# def geometric_mean(values):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen1(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen2(self, seq1idx, seq2idx):
# def __angle_cos(self, seq1idx, seq2idx):
# def pwdist_angle_cos_diss(self, seq1idx, seq2idx):
# def pwdist_angle_cos_evol(self, seq1idx, seq2idx):
# def pwdist_manhattan(self, seq1idx, seq2idx):
# def pwdist_diff_abs_add(self, seq1idx, seq2idx):
# def pwdist_chebyshev(self, seq1idx, seq2idx):
# def pwdist_braycurtis(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult1(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult2(self, seq1idx, seq2idx):
# def pwdist_kld(self, seq1idx, seq2idx):
# def pwdist_jsd(self, seq1idx, seq2idx):
# def entropy(p, q):
# def pwdist_google(self, seq1idx, seq2idx):
# def pwdist_lcc(self, seq1idx, seq2idx):
# def pwdist_canberra(self, seq1idx, seq2idx):
# def pwdist_minkowski(self, seq1idx, seq2idx, p=2):
# def main():
# class Distance(distance.Distance):
# _P = x + 0.0000001
# _Q = y + 0.0000001
# _M = 0.5 * (_P + _Q)
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
, which may include functions, classes, or code. Output only the next line. | 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_pattern.create(self.dna_records.seq_list, 2)
self.counts = word_vector.Counts(self.dna_records.length_list,
self.pattern)
self.freqs = word_vector.Freqs(self.dna_records.length_list,
self.pattern)
def test_angle_cos_diss_freqs(self):
# The result of this method is identical to that from decaf+py.
<|code_end|>
, predict the next line using imports from the current file:
import unittest
from alfpy import word_pattern
from alfpy import word_vector
from alfpy import word_distance
from alfpy.utils import distmatrix
from . import utils
and context including class names, function names, and sometimes code from other files:
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/word_distance.py
# def geometric_mean(values):
# def pwdist_euclid_squared(self, seq1idx, seq2idx):
# def pwdist_euclid_norm(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen1(self, seq1idx, seq2idx):
# def pwdist_euclid_seqlen2(self, seq1idx, seq2idx):
# def __angle_cos(self, seq1idx, seq2idx):
# def pwdist_angle_cos_diss(self, seq1idx, seq2idx):
# def pwdist_angle_cos_evol(self, seq1idx, seq2idx):
# def pwdist_manhattan(self, seq1idx, seq2idx):
# def pwdist_diff_abs_add(self, seq1idx, seq2idx):
# def pwdist_chebyshev(self, seq1idx, seq2idx):
# def pwdist_braycurtis(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult1(self, seq1idx, seq2idx):
# def pwdist_diff_abs_mult2(self, seq1idx, seq2idx):
# def pwdist_kld(self, seq1idx, seq2idx):
# def pwdist_jsd(self, seq1idx, seq2idx):
# def entropy(p, q):
# def pwdist_google(self, seq1idx, seq2idx):
# def pwdist_lcc(self, seq1idx, seq2idx):
# def pwdist_canberra(self, seq1idx, seq2idx):
# def pwdist_minkowski(self, seq1idx, seq2idx, p=2):
# def main():
# class Distance(distance.Distance):
# _P = x + 0.0000001
# _Q = y + 0.0000001
# _M = 0.5 * (_P + _Q)
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
. Output only the next line. | 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_argument('--version', action='version',
version='%(prog)s {}'.format(__version__))
if len(sys.argv[1:]) == 0:
# parser.print_help()
parser.print_usage()
parser.exit()
return parser
def validate_args(parser):
args = parser.parse_args()
try:
args.matrix = subsmat.get(args.matrix)
except KeyError:
parser.error("Unknown matrix {}".format(args.matrix))
return args
def main():
parser = get_parser()
args = validate_args(parser)
seq_records = seqrecords.read_fasta(args.fasta)
<|code_end|>
using the current file's imports:
import argparse
import sys
from alfpy import wmetric
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.utils.data import subsmat
from alfpy.version import __version__
and any relevant context from other files:
# Path: alfpy/wmetric.py
# def count_seq_chars(seq, alphabet):
# def freq_seq_chars(counts):
# def freq_seqs_chars(seq_records, alphabet):
# def __init__(self, seq_records, matrix):
# def pairwise_distance(self, seqnum1, seqnum2):
# def main():
# class Distance:
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/utils/data/subsmat.py
# class SubsMat:
# def __init__(self, name, data, alphabet_list):
# def get_alphabet_list(name):
# def get(name):
# def list_subsmats():
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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(__version__))
if len(sys.argv[1:]) == 0:
# parser.print_help()
parser.print_usage()
parser.exit()
return parser
def validate_args(parser):
args = parser.parse_args()
try:
args.matrix = subsmat.get(args.matrix)
except KeyError:
parser.error("Unknown matrix {}".format(args.matrix))
return args
def main():
parser = get_parser()
args = validate_args(parser)
seq_records = seqrecords.read_fasta(args.fasta)
dist = wmetric.Distance(seq_records, args.matrix)
<|code_end|>
, determine the next line of code. You have imports:
import argparse
import sys
from alfpy import wmetric
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.utils.data import subsmat
from alfpy.version import __version__
and context (class names, function names, or code) available:
# Path: alfpy/wmetric.py
# def count_seq_chars(seq, alphabet):
# def freq_seq_chars(counts):
# def freq_seqs_chars(seq_records, alphabet):
# def __init__(self, seq_records, matrix):
# def pairwise_distance(self, seqnum1, seqnum2):
# def main():
# class Distance:
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/utils/data/subsmat.py
# class SubsMat:
# def __init__(self, name, data, alphabet_list):
# def get_alphabet_list(name):
# def get(name):
# def list_subsmats():
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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 exit")
group.add_argument('--version', action='version',
version='%(prog)s {}'.format(__version__))
if len(sys.argv[1:]) == 0:
# parser.print_help()
parser.print_usage()
parser.exit()
return parser
def validate_args(parser):
args = parser.parse_args()
try:
args.matrix = subsmat.get(args.matrix)
except KeyError:
parser.error("Unknown matrix {}".format(args.matrix))
return args
def main():
parser = get_parser()
args = validate_args(parser)
<|code_end|>
. Write the next line using the current file imports:
import argparse
import sys
from alfpy import wmetric
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.utils.data import subsmat
from alfpy.version import __version__
and context from other files:
# Path: alfpy/wmetric.py
# def count_seq_chars(seq, alphabet):
# def freq_seq_chars(counts):
# def freq_seqs_chars(seq_records, alphabet):
# def __init__(self, seq_records, matrix):
# def pairwise_distance(self, seqnum1, seqnum2):
# def main():
# class Distance:
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/utils/data/subsmat.py
# class SubsMat:
# def __init__(self, name, data, alphabet_list):
# def get_alphabet_list(name):
# def get(name):
# def list_subsmats():
# def main():
#
# Path: alfpy/version.py
, which may include functions, classes, or code. Output only the next line. | 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'
)
group = parser.add_argument_group('REQUIRED ARGUMENTS')
group.add_argument('--fasta', '-f',
help='input FASTA sequence filename', required=True,
type=argparse.FileType('r'), metavar="FILE")
<|code_end|>
, determine the next line of code. You have imports:
import argparse
import sys
from alfpy import wmetric
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.utils.data import subsmat
from alfpy.version import __version__
and context (class names, function names, or code) available:
# Path: alfpy/wmetric.py
# def count_seq_chars(seq, alphabet):
# def freq_seq_chars(counts):
# def freq_seqs_chars(seq_records, alphabet):
# def __init__(self, seq_records, matrix):
# def pairwise_distance(self, seqnum1, seqnum2):
# def main():
# class Distance:
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/utils/data/subsmat.py
# class SubsMat:
# def __init__(self, name, data, alphabet_list):
# def get_alphabet_list(name):
# def get(name):
# def list_subsmats():
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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_argument('--fasta', '-f',
help='input FASTA sequence filename', required=True,
type=argparse.FileType('r'), metavar="FILE")
l = subsmat.list_subsmats()
group = parser.add_argument_group('OPTIONAL ARGUMENTS')
group.add_argument('--matrix', '-m', choices=l,
help='choose from: {} [DEFAULT: %(default)s]'.format(
", ".join(l)), metavar='',
default="blosum62")
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',
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('--version', action='version',
<|code_end|>
, generate the next line using the imports in this file:
import argparse
import sys
from alfpy import wmetric
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.utils.data import subsmat
from alfpy.version import __version__
and context (functions, classes, or occasionally code) from other files:
# Path: alfpy/wmetric.py
# def count_seq_chars(seq, alphabet):
# def freq_seq_chars(counts):
# def freq_seqs_chars(seq_records, alphabet):
# def __init__(self, seq_records, matrix):
# def pairwise_distance(self, seqnum1, seqnum2):
# def main():
# class Distance:
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/utils/data/subsmat.py
# class SubsMat:
# def __init__(self, name, data, alphabet_list):
# def get_alphabet_list(name):
# def get(name):
# def list_subsmats():
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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(seq_records.seq_list, i)
patterns.append(p)
vecs = []
if args.char_weights is not None:
weightmodel = word_vector.WeightModel(char_weights=args.char_weights)
vecklas = {'counts': word_vector.CountsWeight,
'freqs': word_vector.FreqsWeight}[args.vector]
kwargs = {'seq_lengths': seq_records.length_list,
'weightmodel': weightmodel}
else:
vecklas = {'counts': word_vector.Counts,
'freqs': word_vector.Freqs}[args.vector]
kwargs = {'seq_lengths': seq_records.length_list}
for p in patterns:
v = vecklas(patterns=p, **kwargs)
vecs.append(v)
<|code_end|>
, predict the immediate next line with the help of imports:
import argparse
import sys
from alfpy import word_d2
from alfpy import word_pattern
from alfpy import word_vector
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context (classes, functions, sometimes code) from other files:
# Path: alfpy/word_d2.py
# class Distance:
# def __init__(self, vector_list):
# def pwdist_d2(self, seqidx1, seqidx2):
# def pwdist_d2_squareroot(self, seqidx1, seqidx2):
# def set_disttype(self, disttype):
# def main():
#
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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 greater than min_word_size")
if args.char_weights:
try:
weights = word_vector.read_weightfile(args.char_weights)
args.char_weights = weights
except Exception:
e = 'Invalid format for --char_weights {0}'.format(
args.char_weights.name)
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):
<|code_end|>
. Write the next line using the current file imports:
import argparse
import sys
from alfpy import word_d2
from alfpy import word_pattern
from alfpy import word_vector
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context from other files:
# Path: alfpy/word_d2.py
# class Distance:
# def __init__(self, vector_list):
# def pwdist_d2(self, seqidx1, seqidx2):
# def pwdist_d2_squareroot(self, seqidx1, seqidx2):
# def set_disttype(self, disttype):
# def main():
#
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
, which may include functions, classes, or code. Output only the next line. | 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',
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('--version', action='version',
version='%(prog)s {}'.format(__version__))
if len(sys.argv[1:]) == 0:
# parser.print_help()
parser.print_usage()
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 greater than min_word_size")
if args.char_weights:
try:
<|code_end|>
, generate the next line using the imports in this file:
import argparse
import sys
from alfpy import word_d2
from alfpy import word_pattern
from alfpy import word_vector
from alfpy.utils import distmatrix
from alfpy.utils import seqrecords
from alfpy.version import __version__
and context (functions, classes, or occasionally code) from other files:
# Path: alfpy/word_d2.py
# class Distance:
# def __init__(self, vector_list):
# def pwdist_d2(self, seqidx1, seqidx2):
# def pwdist_d2_squareroot(self, seqidx1, seqidx2):
# def set_disttype(self, disttype):
# def main():
#
# Path: alfpy/word_pattern.py
# class Pattern:
# def __init__(self, pat_list, occr_list, pos_list=None):
# def _alfree_format(self):
# def _teiresias_format(self):
# def format(self, formattype=None):
# def reduce_alphabet(self, alphabet_dict):
# def merge_revcomp(self):
# def revcomp(s):
# def __repr__(self):
# def __str__(self):
# def _create_wordpattern(seq_list, k):
# def _create_wordpattern_positions(seq_list, k):
# def create(seq_list, word_size=1, wordpos=False):
# def create_from_fasta(handle, word_size=1, wordpos=False):
# def create_from_bigfasta(filename, k=1):
# def run_teiresias(input_filename, w=2, l=2, k=2, output_filename=None):
# def read(handle):
# def main():
#
# Path: alfpy/word_vector.py
# class Counts:
# class Bools(Counts):
# class Freqs(Counts):
# class FreqsStd(Freqs):
# class WeightModel:
# class CountsWeight(Counts):
# class FreqsWeight(Freqs):
# class WordModel:
# class EqualFreqs(WordModel):
# class EquilibriumFreqs(WordModel):
# class Composition(Counts):
# def __init__(self, seq_lengths, patterns):
# def _get_counts_occurrence(seq_count, patterns):
# def __getitem__(self, seqidx):
# def __str__(self):
# def format(self, decimal_places=3):
# def __init__(self, seq_lengths, patterns):
# def __init__(self, seq_lengths, patterns):
# def __relative_freqs(self):
# def __init__(self, seq_lengths, patterns, freqmodel):
# def __overlaps(self, freqmodel):
# def __standardize_freqs(self, freqmodel):
# def __init__(self, char_weights, wtype='content'):
# def content(self, vector, patterns):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def __init__(self, seq_lengths, patterns, weightmodel):
# def probabilities(self, word):
# def overlap_capability(self, word):
# def var(self, word, seq_len, word_len=None, overlap_capability=None,
# word_probs=None):
# def __init__(self, alphabet_size):
# def probabilities(self, word):
# def __init__(self, equilibrium_frequencies):
# def probabilities(self, word):
# def __init__(self, seq_lengths, patterns, patterns1, patterns2):
# def __check_patlen(self):
# def __markov_chain_freqs(self, seqnum, seqlen, patnum, patlen, pattern):
# def __composition(self, seqnum, seqlen):
# def _read_charval_file(handle):
# def main():
#
# Path: alfpy/utils/distmatrix.py
# def create(id_list, distance):
# def read_highcharts_matrix(id_list, data):
# def __init__(self, id_list, data):
# def normalize(self):
# def __iter__(self):
# def writer(self, handle, f, decimal_places):
# def display(self, f="phylip", decimal_places=7):
# def write_to_file(self, handle, f="phylip", decimal_places=7):
# def highcharts(self):
# def format(self, decimal_places=7):
# def min(self):
# def max(self):
# def is_zero(self):
# def __repr__(self):
# class Matrix():
#
# Path: alfpy/utils/seqrecords.py
# class SeqRecords:
# def __init__(self, id_list=None, seq_list=None):
# def add(self, seqid, seq):
# def fasta(self, wrap=70):
# def length_list(self):
# def __iter__(self):
# def __len__(self):
# def __repr__(self):
# def read_fasta(handle):
# def main():
#
# Path: alfpy/version.py
. Output only the next line. | 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.