Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Continue the code snippet: <|code_start|> def testRightClippingPaddedTwo(self):
"""
Test that right soft clipping of two bases works when the reference
is padded on the right.
"""
self.assertEqual('2M2S', makeCigar(' ACGT ',
' AT... | self.assertEqual([], list(cigarTuplesToOperations([]))) |
Based on the snippet: <|code_start|> """
self.assertEqual(
[CHARD_CLIP, CHARD_CLIP, CINS, CINS, CMATCH, CMATCH, CMATCH],
list(cigarTuplesToOperations(
[(CHARD_CLIP, 2), (CINS, 2), (CMATCH, 3)])))
def testSkipHardClipping(self):
"""
It must be p... | softClippedOffset, 0, ((0, None),), (CSOFT_CLIP,)) |
Given the code snippet: <|code_start|> softClippedOffset(2,
((0, 10), (1, None), (2, None)),
(CMATCH, CSOFT_CLIP, CSOFT_CLIP)))
def testMatchTwoAfterThenHardClips(self):
"""
Test that a soft-clipped base two sites after a non-so... | insertionOffset, 0, ((0, None),), (CINS,)) |
Predict the next line for this snippet: <|code_start|> 'non-hard-clipped bases.')
def insertionOffset(offset, pairs, cigarOperations):
"""
Get the insertion offset in the reference for a base that is part of an
insertion.
@param offset: The offset (in C{pairs}) of the soft-clipped... | assert cigarOperation not in CONSUMES_REFERENCE |
Given the following code snippet before the placeholder: <|code_start|>#!/usr/bin/env python
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description=('Given FASTA on stdin, write information about the '
'number of various characters to stdout.'))
parser.add_ar... | addFASTACommandLineOptions(parser) |
Continue the code snippet: <|code_start|>#!/usr/bin/env python
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description=('Given FASTA on stdin, write information about the '
'number of various characters to stdout.'))
parser.add_argument(
'--ignoreCase'... | reads = parseFASTACommandLineOptions(args) |
Predict the next line after this snippet: <|code_start|>#!/usr/bin/env python
from __future__ import print_function
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description=('Given FASTA on stdin, write the sequence ids and '
'lengths to stdout.'))
<|code_end|>
us... | addFASTACommandLineOptions(parser) |
Given the following code snippet before the placeholder: <|code_start|>#!/usr/bin/env python
from __future__ import print_function
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description=('Given FASTA on stdin, write the sequence ids and '
'lengths to stdout.'))
... | reads = parseFASTACommandLineOptions(args) |
Given snippet: <|code_start|>#!/usr/bin/env python
from __future__ import print_function
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description=('Given FASTA sequences (of equal length) on stdin '
'write Phylip to stdout.'))
parser.add_argument(
'--a... | addFASTACommandLineOptions(parser) |
Next line prediction: <|code_start|>#!/usr/bin/env python
from __future__ import print_function
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description=('Given FASTA sequences (of equal length) on stdin '
'write Phylip to stdout.'))
parser.add_argument(
... | reads = parseFASTACommandLineOptions(args) |
Given the code snippet: <|code_start|>#!/usr/bin/env python
from __future__ import print_function
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description=('Given FASTA on stdin, write the sequence ids and '
'lengths to stdout.'))
<|code_end|>
, generate the next l... | addFASTACommandLineOptions(parser) |
Continue the code snippet: <|code_start|>#!/usr/bin/env python
from __future__ import print_function
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description=('Given FASTA on stdin, write the sequence ids and '
'lengths to stdout.'))
addFASTACommandLineOptions(... | reads = parseFASTACommandLineOptions(args) |
Given snippet: <|code_start|>
@param dnaMatch: A C{dict} returned by C{compareDNAReads}.
@param read1: A C{Read} instance or an instance of one of its subclasses.
@param read2: A C{Read} instance or an instance of one of its subclasses.
@param matchAmbiguous: If C{True}, ambiguous nucleotides that are
... | append(countPrint('%sExact matches' % indent, identicalMatchCount, |
Here is a snippet: <|code_start|>#!/usr/bin/env python
"""
Read DNA FASTA from stdin and print FASTA to stdout, with the sequences
randomized. The read ids and lengths are preserved.
Note: This produces DNA sequences. If you have AA reads and you need this
functionality, we can add it.
"""
from __future__ impo... | print(DNARead(read.id, seq).toString('fasta')) |
Next line prediction: <|code_start|>#!/usr/bin/env python
from __future__ import print_function
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description=(
'Given FASTA on stdin, write the sequences to stdout.'))
<|code_end|>
. Use current file imports:
(from dark.reads imp... | addFASTACommandLineOptions(parser) |
Given snippet: <|code_start|>#!/usr/bin/env python
from __future__ import print_function
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description=(
'Given FASTA on stdin, write the sequences to stdout.'))
addFASTACommandLineOptions(parser)
args = parser.parse_args()... | reads = parseFASTACommandLineOptions(args) |
Predict the next line for this snippet: <|code_start|>#!/usr/bin/env python
from __future__ import print_function
if __name__ == '__main__':
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
description=(
'Given FASTA on stdin, print the numbe... | addFASTACommandLineOptions(parser) |
Next line prediction: <|code_start|>#!/usr/bin/env python
from __future__ import print_function
if __name__ == '__main__':
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
description=(
'Given FASTA on stdin, print the number of sequences to ... | reads = parseFASTACommandLineOptions(args) |
Given snippet: <|code_start|> an amino acid match is due to an exact nucleotide matches or not.
Also, the numbers in the BTOP string will be multiplied by 3 since
they refer to a number of amino acids matching.
@raise ValueError: If L{parseBtop} finds an error in C{btopString} or
if C... | thisOperation = CINS_STR |
Given snippet: <|code_start|> of the more specific 'X' and '='.
@param aa: If C{True}, C{btopString} will be interpreted as though it
refers to amino acids (as in the BTOP string produced by DIAMOND).
In that case, it is not possible to use the 'precise' CIGAR characters
because amino... | thisOperation = CDEL_STR |
Given the following code snippet before the placeholder: <|code_start|> return (queryGaps, subjectGaps)
def btop2cigar(btopString, concise=False, aa=False):
"""
Convert a BTOP string to a CIGAR string.
@param btopString: A C{str} BTOP sequence.
@param concise: If C{True}, use 'M' for matches and m... | thisOperation = CEQUAL_STR if concise else CMATCH_STR |
Using the snippet: <|code_start|> return (queryGaps, subjectGaps)
def btop2cigar(btopString, concise=False, aa=False):
"""
Convert a BTOP string to a CIGAR string.
@param btopString: A C{str} BTOP sequence.
@param concise: If C{True}, use 'M' for matches and mismatches instead
of the more ... | thisOperation = CEQUAL_STR if concise else CMATCH_STR |
Using the snippet: <|code_start|> if C{aa} and C{concise} are both C{True}.
@return: A generator that yields C{str} pieces of a CIGAR string. Use
''.join(btopString(...)) to get a complete CIGAR string.
"""
if aa and concise:
raise ValueError('aa and concise cannot both be True')
... | thisOperation = CDIFF_STR if concise else CMATCH_STR |
Given the code snippet: <|code_start|>#!/usr/bin/env python
from __future__ import print_function
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
description='Print SAM/BAM file reference names and lengths.')
parser.add_argument(
'samfile', metavar='FILENAME',
... | print(samReferencesToStr(parser.parse_args().samfile)) |
Given snippet: <|code_start|> help=('The name of the FASTA files containing the sequences to be '
'combined.'))
parser.add_argument(
'--threads', type=int, default=multiprocessing.cpu_count(),
help=('The number of threads to use when running the aligner (if '
'--a... | print(DNARead('Combined', combinedSequence).toString(format_='fasta')) |
Next line prediction: <|code_start|>
log = logging.getLogger(__package__)
def init(app):
app.hooks.connect("pre-arg-parse", add_argparse)
app.hooks.connect("post-arg-parse", post_argparse)
def add_argparse(app, parser, subparsers):
s = subparsers.add_parser("openscap", help="Security management")
s... | os = OSCAPScanner() |
Given the code snippet: <|code_start|> if name == '.' or name == '..':
return False
# Check that all characters are in the allowed set and that the name
# does not start with a -
if not re.match('^[a-zA-Z0-9+_.][a-zA-Z0-9+_.-]*$', name):
return False
# Ac... | run = ExternalBinary() |
Given the code snippet: <|code_start|>#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed ... | _lvs = LvmCLI.lvs |
Given the code snippet: <|code_start|> return LVM._lvs(["--noheadings", "--ignoreskippedcluster",
"-olv_path", self.lvm_name])
@property
def dm_path(self):
return LVM._lvs(["--noheadings", "--ignoreskippedcluster",
"-olv_d... | return cls.from_path(find_mount_source(mixed)) |
Based on the snippet: <|code_start|> self.configure()
def register(self, datastream, profile):
log.info("Registering profile %s from %s", profile, datastream)
if profile not in self.profiles(datastream):
log.error("Profile %s not found", profile)
return
se... | nsenter(args) |
Using the snippet: <|code_start|> return
self._config.datastream = os.path.realpath(datastream)
self._config.profile = profile
def unregister(self, profile):
if profile == self._config.profile:
log.info("Unregistering profile %s", profile)
self._config.pro... | if not datastream or not File(datastream).exists(): |
Here is a snippet: <|code_start|> self.scan(remediate=True, path=path)
else:
self.configure()
def register(self, datastream, profile):
log.info("Registering profile %s from %s", profile, datastream)
if profile not in self.profiles(datastream):
log.error("P... | with bindmounted("/proc", path + "/proc"): |
Given the code snippet: <|code_start|>
log = logging.getLogger(__package__)
def init(app):
app.hooks.connect("pre-arg-parse", add_argparse)
app.hooks.connect("post-arg-parse", post_argparse)
def add_argparse(app, parser, subparsers):
if not app.experimental:
return
s = subparsers.add_parse... | vols = Volumes(app.imgbase) |
Using the snippet: <|code_start|># Copyright (C) 2017 Red Hat, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#... | class TimeserverConfiguration(File): |
Predict the next line for this snippet: <|code_start|>#! /usr/bin/env python
from __future__ import unicode_literals, print_function
# TODO(cnicolaou): get the multi section tests working
class MyMultiSectionFactory(MultiSectionFactory):
def __init__(self, dir):
self.main_file_name = os.path.join(dir,... | self.main_sink = FileCodeSink(open(self.main_file_name, "wt")) |
Next line prediction: <|code_start|>
if PY3:
string_types = str,
else:
string_types = basestring,
try:
any = any
except NameError:
def any(iterable):
for element in iterable:
if element:
return True
return False
try:
except ImportError:
__version__ = [0... | assert isinstance(code_sink, CodeSink) |
Continue the code snippet: <|code_start|> else:
raise TypeError("Could not parse `%r' as a Parameter" % param_spec)
return args, kwargs
def parse_retval_spec(retval_spec):
if isinstance(retval_spec, tuple):
assert len(retval_spec) >= 1
if isinstance(retval_spec[-1], dict):
... | TypeLookupError)) |
Given the code snippet: <|code_start|>
def mangle_name(name):
"""make a name Like<This,and,That> look Like__lt__This_and_That__gt__"""
s = name.replace('<', '__lt__').replace('>', '__gt__').replace(',', '_')
s = s.replace(' ', '_').replace('&', '__amp__').replace('*', '__star__')
s = s.replace(':', '_... | exceptions_to_handle=(TypeConfigurationError, |
Predict the next line after this snippet: <|code_start|>
def mangle_name(name):
"""make a name Like<This,and,That> look Like__lt__This_and_That__gt__"""
s = name.replace('<', '__lt__').replace('>', '__gt__').replace(',', '_')
s = s.replace(' ', '_').replace('&', '__amp__').replace('*', '__star__')
s = ... | CodeGenerationError, |
Predict the next line after this snippet: <|code_start|>
def mangle_name(name):
"""make a name Like<This,and,That> look Like__lt__This_and_That__gt__"""
s = name.replace('<', '__lt__').replace('>', '__gt__').replace(',', '_')
s = s.replace(' ', '_').replace('&', '__amp__').replace('*', '__star__')
s = s... | NotSupportedError)): |
Predict the next line for this snippet: <|code_start|> assert len(param_spec) >= 2
if isinstance(param_spec[-1], dict):
kwargs = param_spec[-1]
args = param_spec[:-1]
else:
kwargs = dict()
args = param_spec
else:
raise TypeError("Could n... | if isinstance(param_value, Parameter): |
Here is a snippet: <|code_start|>
def parse_retval_spec(retval_spec):
if isinstance(retval_spec, tuple):
assert len(retval_spec) >= 1
if isinstance(retval_spec[-1], dict):
kwargs = retval_spec[-1]
args = retval_spec[:-1]
else:
kwargs = dict()
a... | if isinstance(retval_value, ReturnValue): |
Given the code snippet: <|code_start|>PY3 = (sys.version_info[0] >= 3)
if PY3:
string_types = str,
else:
string_types = basestring,
try:
any = any
except NameError:
def any(iterable):
for element in iterable:
if element:
return True
return False
try:
excep... | min_python_version = settings.min_python_version |
Using the snippet: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless r... | class BuiltinChecker(Checker): |
Here is a snippet: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless r... | self.loader = BuiltinLoader() |
Using the snippet: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless r... | self.reporter = ProblemReporter() |
Given the code snippet: <|code_start|>
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software... | controller._run_checker(checker, False, path) |
Using the snippet: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless r... | class ApiMpiChecker(Checker): |
Based on the snippet: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unles... | class ApiDfpChecker(Checker): |
Here is a snippet: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless r... | class PerformanceDegradationChecker(Checker): |
Predict the next line after this snippet: <|code_start|>
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless re... | self.hint = core.get_ifdef_regex("x86", "\\|") |
Using the snippet: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless r... | class HtmChecker(Checker): |
Continue the code snippet: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
... | self.htm_functions = HtmLoader().get_functions() |
Given the following code snippet before the placeholder: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apa... | class AsmChecker(Checker): |
Given the following code snippet before the placeholder: <|code_start|>#! /usr/bin/env python
# -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the Lic... | quickfix_loader = QuickfixLoader() |
Predict the next line after this snippet: <|code_start|>
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in... | lines = core.execute_stdout(command)[1] |
Using the snippet: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless r... | class ApiMklChecker(Checker): |
Given the following code snippet before the placeholder: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apa... | class LongDoubleChecker(Checker): |
Continue the code snippet: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
... | class ApiIppChecker(Checker): |
Next line prediction: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unles... | self.problems = ProblemReporter.get_problems() |
Given the code snippet: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unl... | class SyscallChecker(Checker): |
Based on the snippet: <|code_start|>Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law ... | self.syscalls_names = SyscallsLoader().get_names() |
Here is a snippet: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless r... | class CharChecker(Checker): |
Here is a snippet: <|code_start|>
def get_pattern_hint(self):
return self.hint
def get_problem_msg(self):
return self.problem_msg
def get_problem_type(self):
return self.problem_type
def check_node(self, node):
kind = node.kind
if kind != CursorKind.BINARY_OPER... | raw_node = core.get_raw_node(node) |
Given the following code snippet before the placeholder: <|code_start|># -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the “License”);
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apa... | class PthreadChecker(Checker): |
Predict the next line for this snippet: <|code_start|>#! /usr/bin/env python
# -*- coding: utf-8 -*-
"""
Copyright (C) 2017 IBM Corporation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://ww... | asm_replacer = AssemblyReplacer() |
Here is a snippet: <|code_start|>
class ISupport(object):
def __init__(self):
self.serverName = None
self.serverVersion = None
self.network = None
self.rawTokens = {}
self.userModes = "iosw"
self.chanModes = {
<|code_end|>
. Write the next line using the current file... | "b": ModeType.LIST, |
Given the following code snippet before the placeholder: <|code_start|> supportedStatuses = self.bot.supportHelper.statusModes
modesAdded = []
paramsAdded = []
modesRemoved = []
paramsRemoved = []
for mode in modes:
if mode == "+":
adding = True... | elif supportedChanModes[mode] == ModeType.LIST: |
Next line prediction: <|code_start|>
if TYPE_CHECKING:
class TargetTypes(Enum):
CHANNEL = 1
USER = 2
class IRCMessage(object):
<|code_end|>
. Use current file imports:
(import re
from enum import Enum
from typing import Dict, Optional, TYPE_CHECKING
from desertbot.channel import IRCChannel
fro... | def __init__(self, msgType: str, user: IRCUser, channel: Optional[IRCChannel], message: str, bot: 'DesertBot', |
Predict the next line for this snippet: <|code_start|>
if TYPE_CHECKING:
class TargetTypes(Enum):
CHANNEL = 1
USER = 2
class IRCMessage(object):
<|code_end|>
with the help of current file imports:
import re
from enum import Enum
from typing import Dict, Optional, TYPE_CHECKING
from desertbot.... | def __init__(self, msgType: str, user: IRCUser, channel: Optional[IRCChannel], message: str, bot: 'DesertBot', |
Based on the snippet: <|code_start|>
def hookBot(self, bot: 'DesertBot') -> None:
self.bot = bot
def loadDataStore(self):
dataRootPath = os.path.join(self.bot.rootDir, 'data', 'servers', self.bot.server)
defaultRootPath = os.path.join(self.bot.rootDir, 'data', 'defaults')
self.... | def checkIgnoreList(self, message: IRCMessage) -> bool: |
Using the snippet: <|code_start|> return func(inst, message)
return wrapped
class BotModule(object):
def __init__(self):
self.logger = logging.getLogger('desertbot.{}'.format(self.__class__.__name__))
self.bot = None
self.storage = None
self.storageSync = None
... | self.storage = DataStore(storagePath=os.path.join(dataRootPath, f'{self.__class__.__name__}.json'), |
Given snippet: <|code_start|> phase.
"""
def __init__(self,
direction=None,
observable=None,
interface=None,
symmetry='default',
mode='default',
MCnorm=True,
**kargs):
_dir = {'x'... | self.observable = Number() |
Given the following code snippet before the placeholder: <|code_start|> if self._dir is not None:
r = np.array([0., box[self._dir]])
if self.interface is not None:
r -= r[1] / 2.
self._range = r
def _determine_bins(self):
nbins = int((self._range[1] - self._r... | rnd_pos = IntrinsicDistance( |
Based on the snippet: <|code_start|> self.count = count * 0.0
self.edges = edges
self.g1 = self.universe.atoms
self.g2 = None
self._rdf = self.count
def _set_default_values(self, generalized_coordinate, max_distance, nbins):
self.dimensions = np.asarray(self.coords_i... | self.generalized_coordinate = Position(self.coords_in, cartesian=self.cartesian, |
Here is a snippet: <|code_start|> self.g2 = None
self._rdf = self.count
def _set_default_values(self, generalized_coordinate, max_distance, nbins):
self.dimensions = np.asarray(self.coords_in).shape[0]
self.dimensions_out = np.asarray(self.coords_out).shape[0]
self.generaliz... | self.generalized_coordinate = RelativePosition(self.coords_in, cartesian=self.cartesian, |
Given snippet: <|code_start|> universe.add_TopologyAttr(missing_class(values))
if name == 'elements':
types = MDAnalysis.topology.guessers.guess_types(group.names)
# is there an inconsistency in the way 'element' is defined
# in different modules in MDA?
# ... | d = atoms_maps |
Predict the next line for this snippet: <|code_start|> correlation at time lag :math:`t` by its value at time lag 0
computed over all trajectories that extend up to time
lag :math:`t` and do not start with :math:`h=0`.
>>> # not normalizd, intermittent
>>> cor... | corr = utilities.correlate(ts) |
Using the snippet: <|code_start|>
def generatecodewithinit(self, _cfilepath_from_pipsdb, _cfileanalyzed, _dicvarinitandloc):
"""
write new code where for each function identified in (2) we should add
the new vars to VAR#init
:param _cfilepath_from_pipsdb:
:param _dicvarinit... | r = ast.RunAstDecl(_cfilepath_from_pipsdb) |
Here is a snippet: <|code_start|> for var in _dicvarinitandloc[nextline]:
# print("INIT: ", var)
# Creating INIT vars
#print(">>>>>> ", dict_varsdata[var][0])
#print(var)
#print("IN... | runtranslatepips = translate_pips.PipsTranslateAnnot() |
Predict the next line after this snippet: <|code_start|> list_paths_to_delete.append(inputCFile)
if args.setInvariantTool == "pips" or args.setInvariantTool == "all":
# Applying the preprocess code - Define a specific format to code
inputCFile = rundepthk... | runtranspagai = translate_pagai.TranslatePagai() |
Given the following code snippet before the placeholder: <|code_start|> inputCFile = rundepthk.rununcrustify(inputCFile)
# Apply hacking to handle with GNU extensions
# HackGNUext: Generate a copy the analyzed program to a tmp file
# now with the extension... | geninvpagai = generate_inv_pagai.GeneratePagaiInv() |
Here is a snippet: <|code_start|> #runtranslatepips.nameoforicprogram = self.nameoforicprogram
runtranslatepips.list_beginnumfuct = listnumbeginfunc
# print(runtranslatepips.instprecondinprog(_cpathpipscode))
# sys.exit()
return runtranslatepips.instprecondinprog(_cpathpipscode)
... | runesbmc = esbmccheck.DepthEsbmcCheck() |
Continue the code snippet: <|code_start|> #
# # delete code with auxiliary code to #init
# if os.path.exists(_pathcodeinit):
# os.remove(_pathcodeinit)
@staticmethod
def checkesbmcsolversupport(_namesolver):
if _namesolver == "z3":
... | str_filelines = hack_extensions.make_pycparser_compatible(filec.read()) |
Given the following code snippet before the placeholder: <|code_start|>
DOSSIER_COURANT = os.path.dirname(os.path.abspath(__file__))
DOSSIER_PARENT = os.path.dirname(DOSSIER_COURANT)
sys.path.append(DOSSIER_PARENT)
@pytest.fixture(scope='module')
def ho_ph_instance():
v = HO_PH('testnode', "127.0.0.1", 1337, Non... | assert isinstance(ho_ph_instance, HO) |
Given snippet: <|code_start|>
DOSSIER_COURANT = os.path.dirname(os.path.abspath(__file__))
DOSSIER_PARENT = os.path.dirname(DOSSIER_COURANT)
sys.path.append(DOSSIER_PARENT)
@pytest.fixture(scope='module')
def ho_ph_instance():
<|code_end|>
, continue by predicting the next line. Consider current file imports:
impor... | v = HO_PH('testnode', "127.0.0.1", 1337, None, run=False) |
Using the snippet: <|code_start|>
DOSSIER_COURRANT = os.path.dirname(os.path.abspath(__file__))
DOSSIER_PARENT = os.path.dirname(DOSSIER_COURRANT)
sys.path.append(DOSSIER_PARENT)
@pytest.fixture(scope='module')
def node_instance():
<|code_end|>
, determine the next line of code. You have imports:
import unittest
imp... | n = Node('testnode', "127.0.0.1", 1337, None, run=False) |
Here is a snippet: <|code_start|># Module name: agent_controller_pox.py
# Version: 1.0
# Created: 29/04/2014 by Aurélien Wailly <aurelien.wailly@orange.com>
#
# Copyright (C) 2010-2014 Orange
#
# This file is part of VESPA.
#
# VESPA is free software: you can redistribute it and/or modify
# it under the terms o... | class Agent_Controller_Pox(Agent_Controller): |
Given the code snippet: <|code_start|>
DOSSIER_COURRANT = os.path.dirname(os.path.abspath(__file__))
DOSSIER_PARENT = os.path.dirname(DOSSIER_COURRANT)
sys.path.append(DOSSIER_PARENT)
class TestInit(unittest.TestCase):
def test_instance_node(self):
v = HO('testnode', "127.0.0.1", 1337, None, run=False)
<... | self.assertTrue(isinstance(v, Node)) |
Here is a snippet: <|code_start|>
DOSSIER_COURRANT = os.path.dirname(os.path.abspath(__file__))
DOSSIER_PARENT = os.path.dirname(DOSSIER_COURRANT)
sys.path.append(DOSSIER_PARENT)
class TestInit(unittest.TestCase):
def test_instance_node(self):
<|code_end|>
. Write the next line using the current file imports:
i... | v = HO('testnode', "127.0.0.1", 1337, None, run=False) |
Here is a snippet: <|code_start|> quarantine_user +
"@" +
quarantine +
"/system")
domNode = self._get_dom_name(nodeName, conn_local)
domNode.migrate(
conn_quarantine,
libvirt.VIR_MIGRATE_LIVE,
None,
None,
... | debug1( |
Predict the next line for this snippet: <|code_start|># d.blockRebase d.migrate2 d.setMemoryStatsPeriod
# d.blockResize d.migrate3 d.setMetadata
# d.blockStats d.migrateGetCompressionCache d.setNumaParameters
# d.blockStatsFlags d.migrateGetMaxSpeed ... | class Agent_Libvirt(Agent): |
Next line prediction: <|code_start|>
DOSSIER_COURRANT = os.path.dirname(os.path.abspath(__file__))
DOSSIER_PARENT = os.path.dirname(DOSSIER_COURRANT)
sys.path.append(DOSSIER_PARENT)
class TestInit(unittest.TestCase):
def test_instance_agent(self):
v = Agent('testnode', "127.0.0.1", 1339, None, run=False)... | self.assertTrue(isinstance(v, Node)) |
Here is a snippet: <|code_start|>
DOSSIER_COURRANT = os.path.dirname(os.path.abspath(__file__))
DOSSIER_PARENT = os.path.dirname(DOSSIER_COURRANT)
sys.path.append(DOSSIER_PARENT)
class TestInit(unittest.TestCase):
def test_instance_agent(self):
<|code_end|>
. Write the next line using the current file imports:
... | v = Agent('testnode', "127.0.0.1", 1339, None, run=False) |
Predict the next line for this snippet: <|code_start|>
DOSSIER_COURANT = os.path.dirname(os.path.abspath(__file__))
DOSSIER_PARENT = os.path.dirname(DOSSIER_COURANT)
sys.path.append(DOSSIER_PARENT)
class SimpleRequestHandler(SocketServer.BaseRequestHandler):
def handle(self):
data = self.request.recv(1024... | assert isinstance(agent_instance, Agent) |
Here is a snippet: <|code_start|>
DOSSIER_COURANT = os.path.dirname(os.path.abspath(__file__))
DOSSIER_PARENT = os.path.dirname(DOSSIER_COURANT)
sys.path.append(DOSSIER_PARENT)
class SimpleRequestHandler(SocketServer.BaseRequestHandler):
def handle(self):
data = self.request.recv(102400) # token receive
... | a = Agent_Controller('testnode', "127.0.0.1", 1340, None, run=False) |
Using the snippet: <|code_start|>
DOSSIER_COURANT = os.path.dirname(os.path.abspath(__file__))
DOSSIER_PARENT = os.path.dirname(DOSSIER_COURANT)
sys.path.append(DOSSIER_PARENT)
@pytest.fixture(scope='module')
def ho_vm_instance():
v = HO_VM('testnode', "127.0.0.1", 1337, None, run=False)
return v
def test_i... | assert isinstance(ho_vm_instance, HO) |
Based on the snippet: <|code_start|>
DOSSIER_COURANT = os.path.dirname(os.path.abspath(__file__))
DOSSIER_PARENT = os.path.dirname(DOSSIER_COURANT)
sys.path.append(DOSSIER_PARENT)
@pytest.fixture(scope='module')
def ho_vm_instance():
<|code_end|>
, predict the immediate next line with the help of imports:
import py... | v = HO_VM('testnode', "127.0.0.1", 1337, None, run=False) |
Given snippet: <|code_start|>
DOSSIER_COURANT = os.path.dirname(os.path.abspath(__file__))
DOSSIER_PARENT = os.path.dirname(DOSSIER_COURANT)
sys.path.append(DOSSIER_PARENT)
@pytest.fixture(scope='module')
def ho_hy_instance():
v = HO_HY('testnode', "127.0.0.1", 1337, None, run=False)
return v
def test_insta... | assert isinstance(ho_hy_instance, HO) |
Next line prediction: <|code_start|>
DOSSIER_COURANT = os.path.dirname(os.path.abspath(__file__))
DOSSIER_PARENT = os.path.dirname(DOSSIER_COURANT)
sys.path.append(DOSSIER_PARENT)
@pytest.fixture(scope='module')
def ho_hy_instance():
<|code_end|>
. Use current file imports:
(import pytest
import sys
import os
from ... | v = HO_HY('testnode', "127.0.0.1", 1337, None, run=False) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.