Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Continue the code snippet: <|code_start|>
class SftpRecurseTest(TestCase):
def __sftp_cb(self, ssh, sftp):
def dir_cb(path, full_path, entry):
# print("DIR: %s" % (full_path))
<|code_end|>
. Use current file imports:
from unittest import TestCase
from pysecure.test.test_base import connect_sftp... | pass |
Next line prediction: <|code_start|> )
@patch("vmmaster.webdriver.commands.ping_endpoint_before_start_session", Mock())
def test_session_response_fail(self):
request = copy.deepcopy(self.request)
request.headers.update({"reply": "500"})
def start_selenium_session(req):
fo... | 'vmmaster.webdriver.helpers.is_request_closed', |
Next line prediction: <|code_start|>
def test_take_screenshot_some_string(self):
self.body['desiredCapabilities'].update({
"takeScreenshot": "asdf"
})
self.session_request_headers = {
'content-length': '%s' % len(self.body),
}
self.request.headers.upda... | self.response_body = "some_body" |
Continue the code snippet: <|code_start|> side_effect=make_request_mock
)
):
self.assertRaises(
CreationException, self.commands.start_session,
request, self.session
)
@patch(
'vmmaster.webdriver.helpers.is_session_t... | ) |
Given the code snippet: <|code_start|># coding: utf-8
class CommonCommandsTestCase(BaseTestCase):
webdriver_server = None
vmmaster_agent = None
vnc_server = None
host = 'localhost'
@classmethod
def setUpClass(cls):
setup_config("data/config_openstack.py")
body = {
... | "version": "", |
Based on the snippet: <|code_start|> @classmethod
def tearDownClass(cls):
cls.webdriver_server.stop()
cls.vmmaster_agent.stop()
cls.vnc_server.stop()
del cls.app
def ping_vm_mock(arg, ports=None):
yield None
def selenium_status_mock(arg1, arg2, arg3):
yield None
@pat... | @patch('flask.current_app.database', Mock()) |
Using the snippet: <|code_start|> def test_name(self):
self.body['desiredCapabilities'].update({
"name": "some_name"
})
self.session_request_headers = {
'content-length': '%s' % len(self.body),
}
self.request.headers.update(self.session_request_headers)... | self.request.headers.update(self.session_request_headers) |
Predict the next line for this snippet: <|code_start|>
class TestRunScript(CommonCommandsTestCase):
def setUp(self):
super(TestRunScript, self).setUp()
config.DEFAULT_AGENT_PORT = self.vmmaster_agent.port
self.response_body = "some_body"
def tearDown(self):
super(TestRunScript,... | with patch('core.db.models.Session.current_log_step', |
Using the snippet: <|code_start|>
@patch(
'vmmaster.webdriver.commands.start_selenium_session', new=Mock(
__name__="start_selenium_session",
side_effect=selenium_status_mock
)
)
@patch(
'vmmaster.webdriver.commands.ping_endpoint_before_start_session',
new=Mock(__name__="ping_endpoint_be... | __name__="make_request", |
Using the snippet: <|code_start|> if key == 'server' or key == 'date':
continue
self.assertDictContainsSubset({key: value}, request_headers)
self.assertEqual(body, request.data)
@patch(
'vmmaster.webdriver.helpers.is_request_closed',
Mock(return_value=... | request.headers.update({"reply": "200"}) |
Given the code snippet: <|code_start|> request, self.session)
@patch('flask.current_app.database', Mock())
class TestStartSeleniumSessionCommands(CommonCommandsTestCase):
@patch(
'vmmaster.webdriver.helpers.is_request_closed',
Mock(return_value=False)
)
@patch("vmm... | Mock(return_value=False) |
Next line prediction: <|code_start|> self.session_request_headers = {
'content-length': '%s' % len(self.body),
}
self.request.headers.update(self.session_request_headers)
self.request.data = json.dumps(self.body)
dc = self.commands.get_desired_capabilities(self.request... | @patch('flask.current_app.database', Mock()) |
Here is a snippet: <|code_start|> self.assertTrue(self.pool.endpoint_preparer.stop.called)
self.assertTrue(self.pool.endpoint_remover.stop.called)
self.assertTrue(self.pool.artifact_collector.stop.called)
self.assertTrue(self.pool.preloader.stop.called)
def test_pool_count(self):
... | self.assertIsInstance(self.pool.active_endpoints[0], OpenstackClone) |
Predict the next line for this snippet: <|code_start|> self.assertTrue(self.pool.endpoint_preparer.stop.called)
self.assertTrue(self.pool.endpoint_remover.stop.called)
self.assertTrue(self.pool.artifact_collector.stop.called)
self.assertTrue(self.pool.preloader.stop.called)
def test_... | self.assertIsInstance(self.pool.active_endpoints[0], OpenstackClone) |
Here is a snippet: <|code_start|> def test_stop_workers(self):
self.pool.endpoint_remover.stop = Mock()
self.pool.stop_workers()
self.assertTrue(self.pool.endpoint_preparer.stop.called)
self.assertTrue(self.pool.endpoint_remover.stop.called)
self.assertTrue(self.pool.artifact... | def test_vm_preloading(self): |
Given the following code snippet before the placeholder: <|code_start|> self.mocked_image = Mock(
id=1, status='active',
get=Mock(return_value='snapshot'),
min_disk=20,
min_ram=2,
instance_type_flavorid=1,
)
type(self.mocked_image).name ... | self.ctx.pop() |
Using the snippet: <|code_start|>
class Config(object):
BASEDIR = os.path.dirname(os.path.realpath(__file__))
PORT = get_free_port()
# PostgreSQL dbname
DATABASE = "postgresql://vmmaster:vmmaster@localhost/vmmaster_db"
ENDPOINT_THREADPOOL_PROCESSES = 1
# screenshots
SCREENSHOTS_DIR = os.s... | "selenium": "4455", |
Given the following code snippet before the placeholder: <|code_start|># coding: utf-8
class TestDockerClient(BaseTestCase):
def setUp(self):
with patch("docker.DockerClient", Mock(
containers=Mock(
create=Mock(),
get=Mock()
)
)):
... | self.assertTrue(len(containers_list), 1) |
Here is a snippet: <|code_start|>
class TestOpenstackCloneUnit(BaseTestCase):
def setUp(self):
setup_config('data/config_openstack.py')
self.app = Flask(__name__)
self.app.database = DatabaseMock()
self.pool = Mock(id=1, provider=Provider(name='fake', url='no//url'))
self... | def tearDown(self): |
Here is a snippet: <|code_start|># coding: utf-8
class TestOpenstackCloneUnit(BaseTestCase):
def setUp(self):
setup_config('data/config_openstack.py')
self.app = Flask(__name__)
self.app.database = DatabaseMock()
self.pool = Mock(id=1, provider=Provider(name='fake', url='no//u... | short_name="platform_1", |
Based on the snippet: <|code_start|># coding: utf-8
class TestOpenstackCloneUnit(BaseTestCase):
def setUp(self):
setup_config('data/config_openstack.py')
self.app = Flask(__name__)
self.app.database = DatabaseMock()
self.pool = Mock(id=1, provider=Provider(name='fake', url='no... | instance_type_flavorid=1 |
Next line prediction: <|code_start|>
self.pool = Mock(id=1, provider=Provider(name='fake', url='no//url'))
self.mocked_origin = Mock(
short_name="platform_1",
id=1, status="active",
get=Mock(return_value="snapshot"),
min_disk=20,
min_ram=2,
... | "core.db.models.OpenstackClone", |
Based on the snippet: <|code_start|># coding: utf-8
class TestOpenstackCloneUnit(BaseTestCase):
def setUp(self):
setup_config('data/config_openstack.py')
self.app = Flask(__name__)
self.app.database = DatabaseMock()
self.pool = Mock(id=1, provider=Provider(name='fake', url='no... | instance_type_flavorid=1 |
Given snippet: <|code_start|> def setUp(self):
setup_config('data/config_openstack.py')
self.app = Flask(__name__)
self.app.database = DatabaseMock()
self.pool = Mock(id=1, provider=Provider(name='fake', url='no//url'))
self.mocked_origin = Mock(
short_name="plat... | def test_success_openstack_set_userdata(self): |
Next line prediction: <|code_start|># coding: utf-8
patch('core.utils.call_in_thread', lambda x: x).start()
app_context = Mock(return_value=Mock(__enter__=Mock(), __exit__=Mock()))
class TestEndpointRemover(BaseTestCase):
def setUp(self):
setup_config('data/config_openstack.py')
def test_remove_endp... | endpoint_remover = EndpointRemover( |
Based on the snippet: <|code_start|># coding: utf-8
patch('core.utils.call_in_thread', lambda x: x).start()
class TestEndpointPreparer(BaseTestCase):
def setUp(self):
setup_config('data/config_openstack.py')
@dataprovider([
(True, False, True, False, False, True),
(False, False, Tru... | endpoint_preparer.start_screencast = Mock() |
Predict the next line after this snippet: <|code_start|># coding: utf-8
patch('core.utils.call_in_thread', lambda x: x).start()
class TestEndpointPreparer(BaseTestCase):
def setUp(self):
setup_config('data/config_openstack.py')
@dataprovider([
(True, False, True, False, False, True),
... | ])) |
Next line prediction: <|code_start|># coding: utf-8
patch('core.utils.call_in_thread', lambda x: x).start()
class TestEndpointPreparer(BaseTestCase):
def setUp(self):
setup_config('data/config_openstack.py')
@dataprovider([
<|code_end|>
. Use current file imports:
(from lode_runner import dataprov... | (True, False, True, False, False, True), |
Continue the code snippet: <|code_start|> self.app.cleanup()
self.ctx.pop()
@patch(
"vmmaster.webdriver.helpers.transparent",
Mock(return_value=transparent_mock(200, {}, json.dumps({'status': 0})))
)
def test_successful_open_url_request(self):
with patch(
... | session = Session("origin_1") |
Predict the next line after this snippet: <|code_start|>
@patch(
"vmmaster.webdriver.helpers.transparent",
Mock(side_effect=Exception("request error"))
)
def test_exception_on_open_url_request(self):
with patch(
"core.db.models.Session", Mock()
):
sess... | ): |
Based on the snippet: <|code_start|> _get_nova_client=Mock(return_value=Mock()),
_wait_for_activated_service=custom_wait,
ping_endpoint_before_start_session=Mock(return_value=True),
is_broken=Mock(return_value=False)
)
)
class TestServer(BaseTestFlaskApp):
def setUp(self):
... | tpool = ThreadPool(2) |
Based on the snippet: <|code_start|>
@patch.multiple(
'vmmaster.webdriver.commands',
ping_endpoint_before_start_session=Mock(side_effect=ping_vm_true_mock),
selenium_status=Mock(return_value=(200, {}, json.dumps({'status': 0}))),
start_selenium_session=Mock(return_value=(200, {}, json.dumps({'sessionId... | } |
Given the code snippet: <|code_start|> self.assertIn("request error", response_data.get("value", {}).get("message", None))
@patch(
"vmmaster.webdriver.helpers.transparent",
Mock(return_value=transparent_mock(500, None, None))
)
def test_open_url_request_with_empty_response_from_endpo... | ) |
Continue the code snippet: <|code_start|> setup_config('data/config_openstack.py')
super(TestServer, self).setUp()
self.desired_caps = {
'desiredCapabilities': {
'platform': 'origin_1'
}
}
self.vmmaster_client = self.app.test_client()
... | result1 = deffered1.get() |
Next line prediction: <|code_start|> }
}
self.vmmaster_client = self.app.test_client()
self.ctx = self.app.app_context()
self.ctx.push()
def tearDown(self):
self.app.sessions.kill_all()
self.app.cleanup()
self.ctx.pop()
@patch(
"vmmast... | @patch( |
Given the code snippet: <|code_start|> setup_config('data/config_openstack.py')
super(TestProxyRequests, self).setUp()
self.desired_caps = {
'desiredCapabilities': {
'platform': 'origin_1'
}
}
self.vmmaster_client = self.app.test_client()
... | "sessionId": session.id, |
Here is a snippet: <|code_start|> self.app.sessions.kill_all()
self.app.cleanup()
self.ctx.pop()
@patch(
"vmmaster.webdriver.helpers.transparent",
Mock(return_value=transparent_mock(200, {}, json.dumps({'status': 0})))
)
def test_successful_open_url_request(self):
... | ): |
Based on the snippet: <|code_start|> ), patch(
'vmpool.virtual_machines_pool.VirtualMachinesPool', Mock()
):
self.app = create_app()
self.app.get_matched_platforms = Mock(return_value=('origin_1', 1))
self.desired_caps = {
'desiredCapabilities': {
... | self.app.cleanup() |
Here is a snippet: <|code_start|> def test_open_url_request_if_no_response_from_endpoint(self):
with patch(
"core.db.models.Session", Mock()
):
session = Session("origin_1")
session.id = 1
self.app.sessions.get_session = Mock(return_value=session)
... | endpoint_id=Mock(return_value=1), |
Given the following code snippet before the placeholder: <|code_start|> endpoint_id=Mock(return_value=1),
endpoint=Mock(
vnc_port=5900,
agent_port=9000,
selenium_port=4455,
_get_nova_client=Mock(return_value=Mock()),
_wait_for_activated_service=custom_wait,
ping_en... | def test_server_create_new_session(self): |
Given the code snippet: <|code_start|> session = Session("origin_1")
session.id = 1
self.app.sessions.get_session = Mock(return_value=session)
data = {
"sessionId": session.id,
"url": "http://host.domain"
}
response = open_url_request(s... | "sessionId": session.id, |
Continue the code snippet: <|code_start|>
def ping_vm_false_mock(arg=None, ports=None):
yield False
def transparent_mock(code=200, headers=None, body=None):
if not headers:
headers = {}
return code, headers, body
class BaseTestFlaskApp(BaseTestCase):
def setUp(self):
with patch(
... | @patch("vmmaster.webdriver.take_screenshot", Mock()) |
Continue the code snippet: <|code_start|># coding: utf-8
def ping_vm_true_mock(arg=None, ports=None):
yield True
def selenium_status_true_mock(arg=None, arg2=None, arg3=None):
yield 200, {}, ""
def ping_vm_false_mock(arg=None, ports=None):
yield False
def transparent_mock(code=200, headers=None, b... | 'vmpool.virtual_machines_pool.VirtualMachinesPool', Mock() |
Given snippet: <|code_start|>)
@patch.multiple(
"core.db.models.Session",
endpoint_id=Mock(return_value=1),
endpoint=Mock(
vnc_port=5900,
agent_port=9000,
selenium_port=4455,
_get_nova_client=Mock(return_value=Mock()),
_wait_for_activated_service=custom_wait,
... | self.app.cleanup() |
Using the snippet: <|code_start|> def test_error(self):
raise Exception('some client exception')
class TestLongRequest(DesktopTestCase):
def test_1_long_micro_app_request(self):
self.driver.get(self.micro_app_address)
def test_2_long_micro_app_request(self):
self.driver.get("{}/lon... | super(TestRunScriptOnSessionCreation, cls).setUpClass() |
Predict the next line after this snippet: <|code_start|>
def test_open_mobile_application(self):
raise Exception('application was opened')
class TestPositiveCase(DesktopTestCase):
def test_micro_app(self):
self.driver.get(self.micro_app_address)
go_button = self.driver.find_element_by... | }} |
Based on the snippet: <|code_start|> endpoint = Endpoint(Mock(), '', provider)
endpoint.ip = 'localhost'
self.session.endpoint = endpoint
def tearDown(self):
self.session._close()
self.ctx.pop()
self.vmmaster.app.sessions.kill_all()
self.vmmaster.app.cleanup()... | ): |
Using the snippet: <|code_start|> server.stop()
self.assertEqual("ok", response.content)
def test_proxy_responses_when_trying_to_connect_failed(self):
with patch(
'core.sessions.Sessions.get_session', Mock(
return_value=self.session)
):
respons... | ) |
Given the code snippet: <|code_start|># coding: utf-8
class TestHttpProxy(BaseTestCase):
def setUp(self):
setup_config('data/config_openstack.py')
<|code_end|>
, generate the next line using the imports in this file:
import requests
from mock import Mock, patch
from core.config import setup_config, con... | self.host = "localhost" |
Next line prediction: <|code_start|> server = ServerMock(self.host, self.free_port)
server.start()
with patch(
'core.sessions.Sessions.get_session', Mock(
return_value=self.session)
):
response = requests.get(
"http://%s:%s/proxy/ses... | 'flask.current_app.database.get_session', |
Next line prediction: <|code_start|># coding: utf-8
class TestHttpProxy(BaseTestCase):
def setUp(self):
setup_config('data/config_openstack.py')
self.host = "localhost"
self.port = config.PORT
self.address = (self.host, self.port)
self.vmmaster = vmmaster_server_mock(self... | self.vmmaster.app.sessions.kill_all() |
Here is a snippet: <|code_start|> return_value=self.session)
):
response = requests.get(
"http://%s:%s/proxy/session/%s/port/%s/" %
(self.host, self.port, self.session.id, self.free_port)
)
self.assertEqual(
"Request forw... | ) |
Continue the code snippet: <|code_start|> (self.host, self.port, self.session.id, self.free_port)
)
self.assertEqual(
"Request forwarding failed:\n"
"Connection was refused by other side: 111: Connection refused.",
response.content)
def test_pr... | "/proxy/session/<session_id>/port/<port_number>/<destination>", |
Predict the next line after this snippet: <|code_start|> endpoint = Endpoint(Mock(), '', provider)
endpoint.ip = 'localhost'
self.session.endpoint = endpoint
def tearDown(self):
self.session._close()
self.ctx.pop()
self.vmmaster.app.sessions.kill_all()
self.vm... | ): |
Given the following code snippet before the placeholder: <|code_start|>from __future__ import with_statement
# this is the Alembic Config object, which provides
# access to the values within the .ini file in use.
config = context.config
# Interpret the config file for Python logging.
# This line sets up loggers basic... | def run_migrations_offline(): |
Given snippet: <|code_start|>
def run_script_mock(script, host):
yield 200, {}, '{"output": "test text"}'
def failed_run_script_mock(script, host):
yield 500, {}, ''
class TestArtifactCollector(BaseTestCase):
@classmethod
def setUpClass(cls):
setup_config('data/config_openstack.py')
... | def test_add_tasks(self): |
Based on the snippet: <|code_start|># coding: utf-8
def run_script_mock(script, host):
yield 200, {}, '{"output": "test text"}'
def failed_run_script_mock(script, host):
yield 500, {}, ''
class TestArtifactCollector(BaseTestCase):
@classmethod
<|code_end|>
, predict the immediate next line with the... | def setUpClass(cls): |
Given snippet: <|code_start|># coding: utf-8
def run_script_mock(script, host):
yield 200, {}, '{"output": "test text"}'
def failed_run_script_mock(script, host):
yield 500, {}, ''
class TestArtifactCollector(BaseTestCase):
@classmethod
<|code_end|>
, continue by predicting the next line. Consider ... | def setUpClass(cls): |
Given the code snippet: <|code_start|>
def run_script_mock(script, host):
yield 200, {}, '{"output": "test text"}'
def failed_run_script_mock(script, host):
yield 500, {}, ''
class TestArtifactCollector(BaseTestCase):
@classmethod
def setUpClass(cls):
setup_config('data/config_openstack.py... | @patch('vmpool.artifact_collector.run_script', run_script_mock) |
Based on the snippet: <|code_start|>
def run_script_mock(script, host):
yield 200, {}, '{"output": "test text"}'
def failed_run_script_mock(script, host):
yield 500, {}, ''
class TestArtifactCollector(BaseTestCase):
@classmethod
def setUpClass(cls):
setup_config('data/config_openstack.py')
... | def test_add_tasks(self): |
Given snippet: <|code_start|> DOCKER_BASE_URL = 'unix://var/run/docker.sock'
DOCKER_TIMEOUT = 120
DOCKER_NUM_POOLS = 100
DOCKER_NETWORK_NAME = "vmmaster_network"
DOCKER_SUBNET = "192.168.1.0/24"
DOCKER_GATEWAY = "192.168.1.254"
DOCKER_CONTAINER_MEMORY_LIMIT = "1g"
DOCKER_CONTAINER_CPU_PER... | FLASK_THREAD_POOL_MAX = 10 |
Predict the next line after this snippet: <|code_start|># coding: utf-8
class TestSeleniumMatcherNegative(BaseTestCase):
def test_empty_platforms_config(self):
matcher = SeleniumMatcher(platforms={})
dc = {
'browserName': 'ANY',
'version': 'ANY',
<|code_end|>
using the c... | 'platform': 'ANY', |
Given the code snippet: <|code_start|># # inside of a "create the database" script, first create
# # tables:
# my_metadata.create_all(engine)
# then, load the Alembic configuration and generate the
# version table, "stamping" it with the most recent rev:
alembic_cfg = Config("%s/migrations/alembic.ini" % home_dir())
... | command.upgrade(alembic_cfg, revision) |
Given the following code snippet before the placeholder: <|code_start|>app_context_mock = Mock(return_value=Mock(__enter__=Mock(), __exit__=Mock()))
def call_in_thread_mock(f):
def wrapper(*args, **kwargs):
return f(*args, **kwargs)
return wrapper
def wait_for(condition, timeout=10):
start = tim... | conn.close() |
Here is a snippet: <|code_start|># -*- coding: utf-8 -*-
OPENSTACK_UTILS_LOG_LEVEL = logging.WARNING
OPENSTACK_AUTH_URL = '{}:{}/{}'.format(
config.OPENSTACK_AUTH_URL,
config.OPENSTACK_PORT,
config.OPENSTACK_CLIENT_VERSION
)
logging.getLogger("requests").setLevel(OPENSTACK_UTILS_LOG_LEVEL)
logging.ge... | auth = v3.Password( |
Given the code snippet: <|code_start|> self._cache.popitem(last=False)
def values(self):
return self._cache.values()
def clear(self):
with self._cache_lock:
self._cache.clear()
class Sessions(object):
_worker = None
_cache = None
def __init__(self, databas... | self._worker.stop() |
Next line prediction: <|code_start|> while self.running:
with self.context():
for session in self.sessions.running(cached=True):
if not session.is_active and session.inactivity > config.SESSION_TIMEOUT:
session.timeout()
time... | def _check_limit(self): |
Given the following code snippet before the placeholder: <|code_start|># coding: utf-8
class TestVNCVideoHelper(BaseTestCase):
def setUp(self):
setup_config('data/config_openstack.py')
<|code_end|>
, predict the next line using imports from the current file:
from mock import patch, Mock
from tests.help... | def test_run_recorder(self): |
Given snippet: <|code_start|> session = Session('some_platform')
session.status = 'unknown'
session.name = '__test_file_deletion'
session.save()
session_dir = os.path.join(
config.SCREENSHOTS_DIR, str(session.id)
)
system_utils.run_command(
... | session_ids_to_delete = [p.id for p in self.cleanup.sessions_overflow(user)] |
Given snippet: <|code_start|>
def test_file_deletion(self):
session = Session('some_platform')
session.status = 'unknown'
session.name = '__test_file_deletion'
session.save()
session_dir = os.path.join(
config.SCREENSHOTS_DIR, str(session.id)
)
sy... | session.save() |
Next line prediction: <|code_start|> cls.app = Flask(__name__)
cls.app.sessions = None
cls.app.database = db.Database(config.DATABASE)
with patch(
'core.utils.init.home_dir', Mock(return_value=config.BASEDIR)
):
cls.cleanup = cleanup
def setUp(self):... | ["mkdir", session_dir], |
Based on the snippet: <|code_start|> deffered1 = pool.apply_async(self.runner.run, args=(suite1,))
deffered2 = pool.apply_async(self.runner.run, args=(suite2,))
deffered1.wait()
deffered2.wait()
result1 = deffered1.get()
result2 = deffered2.get()
self.assertEqual(... | def setUp(self): |
Given snippet: <|code_start|> self.assertEqual(0, len(result.errors), result.errors)
self.assertEqual(0, len(result.failures), result.failures)
@unittest.skip("Error \"Connection reset by peer\" in apt-get-scripts on random openstack endpoints")
def test_run_script_tests_parallel_run(self, platf... | def test_mobile_web(self, platform): |
Using the snippet: <|code_start|> def __init__(self, host, port=5900, filename_prefix='vnc'):
self.filename_prefix = filename_prefix
self.dir_path = os.sep.join([config.SCREENSHOTS_DIR,
str(self.filename_prefix)])
if not os.path.isdir(self.dir_path):
... | try: |
Continue the code snippet: <|code_start|>
log = logging.getLogger(__name__)
class VNCVideoHelper:
recorder = None
__filepath = None
def __init__(self, host, port=5900, filename_prefix='vnc'):
self.filename_prefix = filename_prefix
self.dir_path = os.sep.join([config.SCREENSHOTS_DIR,
... | blocksize=blocksize, framerate=framerate, keyframe=keyframe, |
Given snippet: <|code_start|> log.debug('File %s was deleted' % vnc_log)
def start_recording(self):
log.info("Screencast recorder starting for session {}".format(self.filename_prefix))
sys.stderr = sys.stdout = open(os.sep.join([
self.dir_path, 'vnc_video.log'
]), 'w'... | if self.recorder and self.recorder.is_alive(): |
Predict the next line after this snippet: <|code_start|>
class LogStreamHandlerTest(BaseTestCase):
def setUp(self):
self.logger = logging.getLogger('logging-test')
self.logger.setLevel(logging.DEBUG)
self.buffer = BytesIO()
self.logHandler = logging.StreamHandler(self.buffer)
... | ]) |
Based on the snippet: <|code_start|># coding: utf-8
class LogStreamHandlerTest(BaseTestCase):
def setUp(self):
self.logger = logging.getLogger('logging-test')
self.logger.setLevel(logging.DEBUG)
self.buffer = BytesIO()
self.logHandler = logging.StreamHandler(self.buffer)
se... | "{0}" |
Next line prediction: <|code_start|>
return sorted(screenshots)
def get_screenshots_for_label(session_id, label_id):
steps_groups = {}
current_label = 0
log_steps = current_app.database.get_log_steps_for_session(session_id)
for step in reversed(log_steps):
if label_step(step.control_line)... | except: |
Using the snippet: <|code_start|>
log = logging.getLogger(__name__)
class RequestHelper(object):
method = None
url = None
headers = None
data = None
def __init__(self, method, url="/", headers=None, data=""):
_headers = {}
<|code_end|>
, determine the next line of code. You have imports:... | if headers: |
Based on the snippet: <|code_start|> continue
try:
s = socket.create_connection((host, port), timeout=0.1)
except socket.error:
s.close()
s = None
continue
break
return s
def get_free_port():
s = socket.socket(socket.AF_INET, ... | return False |
Here is a snippet: <|code_start|>
log = logging.getLogger(__name__)
class RequestHelper(object):
method = None
url = None
headers = None
data = None
def __init__(self, method, url="/", headers=None, data=""):
_headers = {}
if headers:
for key, value in headers.items()... | def get_interface_subnet(inteface): |
Next line prediction: <|code_start|>
def get_socket(host, port):
s = None
addr_info = socket.getaddrinfo(
host, port, socket.AF_UNSPEC, socket.SOCK_STREAM
)
for af, socktype, proto, canonname, sa in addr_info:
try:
s = socket.socket(af, socktype, proto)
except socke... | s.close() |
Given the following code snippet before the placeholder: <|code_start|>
def get_ip_by_mac(mac):
subnet = get_interface_subnet("br0")
nmap_ping_scan(subnet)
code, output = arp_numeric()
split_output = output.split("\n")
for line in split_output:
if mac in line:
break
if lin... | try: |
Based on the snippet: <|code_start|> with patch(
'core.utils.init.home_dir', Mock(return_value=fake_home_dir())
), patch(
'core.db.Database', DatabaseMock()
), patch(
'vmpool.virtual_machines_pool.VirtualMachinesPool', Mock()
):
self.app = c... | self.assertEqual(names[0], self.platform) |
Here is a snippet: <|code_start|> provider = Provider(name='noname', url='nourl')
endpoint = Endpoint(Mock(), '', provider)
endpoint.ip = '127.0.0.1'
endpoint.name = 'test_endpoint'
endpoint.ports = {'4455': 4455, '9000': 9000, '5900': 5900}
session = Session("some_platfor... | session = Session("some_platform") |
Using the snippet: <|code_start|> ), patch(
'core.utils.kill_process', Mock()
), patch(
'core.db.Database', DatabaseMock()
):
self.app = create_app()
self.vmmaster_client = self.app.test_client()
self.platform = 'origin_1'
self.desired... | endpoint.ports = {'4455': 4455, '9000': 9000, '5900': 5900} |
Continue the code snippet: <|code_start|>
def test_when_during_proxy_starting_session_was_closed(self):
provider = Provider(name='noname', url='nourl')
endpoint = Endpoint(Mock(), '', provider)
endpoint.ip = '127.0.0.1'
endpoint.name = 'test_endpoint'
endpoint.ports = {'4455'... | endpoint = Endpoint(Mock(), '', provider) |
Given the following code snippet before the placeholder: <|code_start|> PLATFORMS = {}
OPENSTACK_AUTH_URL = "localhost"
OPENSTACK_PORT = 5000
OPENSTACK_CLIENT_VERSION = "v3"
OPENSTACK_USERNAME = "user"
OPENSTACK_PASSWORD = "password"
OPENSTACK_TENANT_NAME = "name"
OPENSTACK_TENANT_ID = "... | DOCKER_CONTAINER_MEMORY_LIMIT = "1g" |
Predict the next line after this snippet: <|code_start|>
testdata_dir = os.path.realpath(
os.path.join(
os.path.dirname(__file__), '..', '..', 'testdata', 'source',
'waveapps'))
examples = [
'test_basic',
'test_matching',
]
<|code_end|>
using the current file's imports:
import os
impo... | @pytest.mark.parametrize('name', examples) |
Continue the code snippet: <|code_start|>
testdata_dir = os.path.realpath(
os.path.join(
os.path.dirname(__file__), '..', '..', 'testdata', 'source',
'google_purchases'))
examples = [
'test_basic',
'test_matching',
'test_invalid',
<|code_end|>
. Use current file imports:
import os
im... | ] |
Predict the next line after this snippet: <|code_start|>
testdata_dir = os.path.realpath(
os.path.join(
os.path.dirname(__file__), '..', '..', 'testdata', 'source', 'mint'))
examples = [
'test_basic',
'test_training_examples',
'test_invalid',
]
@pytest.mark.parametrize('name', examples)
def... | example_dir=os.path.join(testdata_dir, name), |
Predict the next line after this snippet: <|code_start|>
testdata_dir = os.path.realpath(
os.path.join(
os.path.dirname(__file__), '..', '..', 'testdata', 'source',
'paypal'))
examples = [
'test_basic',
<|code_end|>
using the current file's imports:
import os
import pytest
from .source_test... | 'test_matching', |
Given the following code snippet before the placeholder: <|code_start|> words.append(w)
for start_i in range(len(words)):
for end_i in range(start_i + 1, len(words) + 1):
features['%s:%s' % (key, ' '.join(
words[start_i:end_i]))]... | posting for posting in transaction.postings |
Predict the next line for this snippet: <|code_start|> if entry.meta:
for k in entry.meta:
extractor = example_transaction_key_extractors.get(k, None)
if extractor is None: continue
extractor(entry.meta[k], transaction_key_value_pair... | target_account=posting.account, |
Continue the code snippet: <|code_start|> self, transaction: Transaction) -> List[Optional[PredictionInput]]:
group_numbers = get_unknown_account_group_numbers(transaction)
example_posting_key_extractors = self.example_posting_key_extractors
example_transaction_key_extractors = self.e... | transaction.postings) |
Next line prediction: <|code_start|>
testdata_dir = os.path.realpath(
os.path.join(
os.path.dirname(__file__), '..', '..', 'testdata', 'source', 'generic_importer'))
testdata_csv = os.path.join(testdata_dir, "csv")
examples = [
'test_basic',
'test_invalid',
'test_training_examples'
]
import... | 'USD', |
Continue the code snippet: <|code_start|>
class DescriptionBasedSourceTest(unittest.TestCase):
def test_merged_posting_is_cleared(self):
postings = [
Posting(account="a", units=Amount(D(10), "USD"), cost=None,
price=None, flag=None, meta=None),
Posting(account=... | self.assertEqual(source.is_posting_cleared(postings[0]), False) |
Given the code snippet: <|code_start|> '€0.00': Amount(D('0.00'), 'EUR'),
'-€.12': Amount(D('-0.12'), 'EUR'),
'-€123.45': Amount(D('-123.45'), 'EUR'),
'£12345.67': Amount(D('12345.67'), 'GBP'),
'£12,345.67': Amount(D('12345.67'), 'GBP'),
'+£123': Amount(D('123'), 'GBP'),
... | except ValueError: |
Predict the next line for this snippet: <|code_start|>
def test_two_parents_for_one_goal_is_forbidden():
with pytest.raises(AssertionError):
build_goaltree(
open_(1, "First parent of 3", [2, 3]),
open_(2, "Second parent of 3", [3]),
open_(3, "Fellow child"),
<|code_end|... | ) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.