Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Predict the next line after this snippet: <|code_start|>
def get_all():
built_ins = filter(lambda f: f.endswith(".yml"), os.listdir(constants.rule_templates_path))
customs = []
try:
for f_name in os.listdir(constants.security['rule_folder']):
if f_name.endswith(".yml"):
... | except: |
Given the code snippet: <|code_start|>
db = db_connection.db
sub_id = db_connection.default_sub
ds_full = db_connection.dsid_default
mock_origin = "file://{}".format(os.path.join(os.path.dirname(__file__), "portlut_mock.csv"))
def test_get_raw_data():
update_portLUT.ORIGIN = mock_origin
<|code_end|>
, generate t... | rows = update_portLUT.get_raw_data() |
Given the code snippet: <|code_start|> hostnames = m_nodes.get_hostnames_preview()
assert hostnames == []
def test_del_hosts():
m_nodes = nodes.Nodes(db, sub_id)
t_low, t_high = common.determine_range_string("99")
try:
db.delete(m_nodes.table_nodes, where="ipstart BETWEEN $start AND $end", ... | t_low, t_high = common.determine_range_string("99") |
Given the following code snippet before the placeholder: <|code_start|> if call == (name, args, kwargs):
return True
return False
class Session(dict):
def kill(self):
self.clear()
class env(object):
def __init__(self, mock_input=False, login_active=None, mock_sessi... | if self.mock_session: |
Given the following code snippet before the placeholder: <|code_start|># coding=utf-8
def test_render():
with db_connection.env(mock_input=True, login_active=False, mock_session=True, mock_render=True):
common.session.clear()
p = sam.pages.metadata.Metadata()
page_title = 'Host Details'
... | assert dummy == "NoneNoneNoneNone" |
Using the snippet: <|code_start|>sub_id = db_connection.default_sub
ds_full = db_connection.dsid_default
def test_decode_get():
with db_connection.env(mock_input=True, login_active=False, mock_session=True):
p = sam.pages.nodes.Nodes()
data = {'address': '10.20.30,150.20,59', 'ds': 'ds_13'}
... | assert request == expected |
Based on the snippet: <|code_start|> 'target': 'aggregator',
'whois': False,
'wsgi': False,
'dest': 'default',
'sub': None
}
assert args == ['wsgi']
argv = 'launcher.py --target=local --whois --format=asasyslog'.split()
parsed, args = launcher.parse_args(argv)
... | 'sub': None |
Next line prediction: <|code_start|>
db = db_connection.db
sub_id = db_connection.default_sub
def test_main():
argv = ['launcher.py', '--target=test_dummy', '--badopt']
assert launcher.main(argv) == 1
argv = ['launcher.py', '--target=bad_target']
assert launcher.main(argv) == 2
argv = ['launcher... | 'port': None, |
Using the snippet: <|code_start|>
parsed = {'port': '8040', 'format': 'paloalto'}
mocker = launcher.launch_collector_stream(parsed, None)
assert len(mocker.calls) == 1
assert mocker.calls[0][0] == 'run_streamreader'
assert mocker.calls[0][1][0] is sys.stdin
assert mocker.... | parsed = {'port': None, 'wsgi': True} |
Continue the code snippet: <|code_start|> 'format': None,
'port': None,
'target': 'import',
'whois': False,
'wsgi': False,
'dest': 'newds',
'sub': '4'
}
assert args == []
argv = 'launcher.py --target=collector_stream'.split()
parsed, args = launche... | 'wsgi': False, |
Here is a snippet: <|code_start|>
dfn = rule_template.get_definition(rule_template.abs_rule_path(s))
assert isinstance(dfn, rule_template.RuleTemplate)
def test_yml_compromised():
s = 'compromised.yml'
dfn = rule_template.get_definition(rule_template.abs_rule_path(s))
assert isinstance(dfn, rule_t... | s = 'suspicious.yml' |
Based on the snippet: <|code_start|> default: "1.2.3.4"
regex: "^([0-9]|[01]?[0-9][0-9]|2[0-4][0-9]|25[0-5])(\\\\.([0-9]|[01]?[0-9][0-9]|2[0-4][0-9]|25[0-5])){3}$"
dest_ip:
format: text
label: temp label 2
default: "5.6.7.8"
regex: "^([0-9]|[01]?[0-9][0-9]|2[0-4][0-9]|25[0-5])(\\\\.([0-9]|[01]?... | alert_label: Special Label |
Continue the code snippet: <|code_start|> def get_tags_preview(self):
tags = self.nodes_model.get_tag_list()
tags.sort()
return tags[:10]
def get_envs_preview(self):
envs = self.nodes_model.get_env_list()
envs.discard("inherit")
l_envs = list(envs)
l_envs.... | envs_preview = self.get_envs_preview() |
Using the snippet: <|code_start|> assert req.headers['Content-Type'] == "application/json"
data = json.loads(req.data)
assert simplify(data) == (1, 1, 1, 1, 1, 1)
def test_request_component():
app = web.application(constants.urls)
test_ip = '50.60.70.80'
with db_connection.env(mock_... | keys = sorted(data.keys()) |
Next line prediction: <|code_start|>def test_request_timerange():
app = web.application(constants.urls)
mkt = db_connection.make_timestamp
time_all = (1, 2 ** 31 - 1)
time_crop = (mkt('2017-3-21 6:13'), mkt('2017-3-24 13:30'))
time_tiny = (mkt('2017-3-23 6:13'), mkt('2017-3-23 13:30'))
test_ip ... | assert req.headers['Content-Type'] == "application/json" |
Next line prediction: <|code_start|>host3 = common.IPStringtoInt("100.101.103.105")
host4 = common.IPStringtoInt("100.102.103.106")
host5 = common.IPStringtoInt("101.102.103.108")
now = 1503089118
time1 = now
time2 = now - 60*5 # 5 minutes ago
time3 = now - 60*61 # 61 minutes ago
time4 = now - 60*60*24 # 24 hours ago... | {"warning_id": 13, "host": host2, "log_time": time7, 'reason': "test1", 'status': statB, "details": cPickle.dumps(details1)}, |
Next line prediction: <|code_start|> with db_connection.env(mock_input=True, login_active=False, mock_session=True):
web.input = lambda: {'q': 'timerange', 'ds': 'ds{}'.format(ds_full)}
web.ctx['headers'] = []
p = sam.pages.stats.Stats()
response = p.GET()
timerange = json.loa... | protocols = json.loads(response) |
Continue the code snippet: <|code_start|>
def test_timerange():
with db_connection.env(mock_input=True, login_active=False, mock_session=True):
web.input = lambda: {'q': 'timerange', 'ds': 'ds{}'.format(ds_full)}
web.ctx['headers'] = []
p = sam.pages.stats.Stats()
response = p.GET()
... | p = sam.pages.stats.Stats() |
Next line prediction: <|code_start|>def launch_collector(parsed, args):
port = parsed.get('port', None)
if port is None:
port = constants.collector['listen_port']
logger.info('launching collector on {}'.format(port))
# workaround for netflow processing with nfcapd:
if parsed['format'].lower... | def launch_aggregator(parsed, args): |
Given the code snippet: <|code_start|>
@singleton
class LazyLoader:
def __init__(self):
self.__import_dict = {}
@property
def import_dict(self):
return self.__import_dict
@import_dict.setter
def import_dict(self, key, value):
self.__import_dict[key] = value
def import_(self, name, alias=None... | return self.__import_dict[alias] |
Predict the next line after this snippet: <|code_start|>
def train(Xtrain, ytrain, model, optimiser, criterion, epoch, batch_size, mode='train'):
progress = make_progressbar('Training ({}) epoch #{}'.format(mode, epoch), len(Xtrain))
progress.start()
shuffle = np.random.permutation(len(Xtrain))
for ... | indices = shuffle[ibatch*batch_size*2 : (ibatch+1)*batch_size*2] |
Next line prediction: <|code_start|>
def data(fold=False):
fname = df.zoo.download('http://dags.stanford.edu/data/iccv09Data.tar.gz')
# extracting files one-by-one in memory is unfortunately WAY too slow
# for this dataset. So we bite the bullet and extract the full tgz.
where = _p.dirname(fname)
... | le, classes = LabelEncoder(), le |
Based on the snippet: <|code_start|>#!/usr/bin/env python
if __name__ == "__main__":
if __package__ is None: # PEP366
__package__ = "DeepFried2.examples.Pretrained"
parser = argparse.ArgumentParser(description="Runs the image through a model pre-trained on ImageNet.")
parser.add_argument('-m',... | if args.model == 'vgg16': |
Using the snippet: <|code_start|>
# For the regular network, we need to resize and crop the image.
img224 = imresizecrop(img, 224)
# Get them from disk-space HWC to nnet-space CHW.
img = img.transpose((2,0,1))
img224 = img224.transpose((2,0,1))
# Put them into a lonely minibatch.
minibatch... | ilsvrc_words = json.load(open(df.zoo.download('https://gist.github.com/lucasb-eyer/237d03b9fcdb0fe03bce/raw/ILSVRC2012_words.json'))) |
Given the following code snippet before the placeholder: <|code_start|>
def validate(X, y_c, y_f, model, epoch, batch_size):
progress = make_progressbar('Testing epoch #{}'.format(epoch), len(X))
progress.start()
nerrors_c, nerrors_f = 0, 0
for ibatch in range((len(X) + batch_size - 1) // batch_size)... | Xbatch = X[ibatch*batch_size : (ibatch+1)*batch_size].astype(df.floatX) |
Here is a snippet: <|code_start|>
class SpatialConvolutionCUDNN(df.Module):
def __init__(self, nchan_in, nchan_out, filter_size, stride=1, border=0, mode='cross', init=df.init.xavier(), bias=0):
# mode='cross' is the default in Lasagne[1], Torch[2], matConvNet[3], Caffee[4].
#
# 1: https://... | w_fan = (np.prod(self.filter_size)*nchan_in, np.prod(self.filter_size)*nchan_out) |
Using the snippet: <|code_start|>
class Module(object):
def __init__(self):
self._mode = 'train'
# The functions are stored in a dictionary whose keys correspond to the
# values that `self._mode` can take.
<|code_end|>
, determine the next line of code. You have imports:
import DeepFried... | self._fn_forward = {} |
Given the code snippet: <|code_start|> params = getattr(self, '_params', [])
if learnable_only:
params = [p for p in params if p.learnable()]
return params
def evaluate(self):
self._mode = 'eval'
def training(self):
self._mode = 'train'
def symb_forward(... | ) |
Based on the snippet: <|code_start|> self.nchan_out = nchan_out
self.filter_size = filter_size
self.mode = mode
self.imshape = expand(imshape, len(filter_size), 'imshape', expand_nonnum=True)
self.stride = expand(stride, len(filter_size), 'stride')
self.border = expand(bor... | if len(self.filter_size) == 3: |
Based on the snippet: <|code_start|>
if __name__ == "__main__":
print("THIS IS JUST AN EXAMPLE; DO NOT BASE DECISIONS ON THIS.")
print("Please don't take these numbers as a benchmark.")
print("A fair comparison would run all experiments multiple times AND RUN MORE THAN FIVE EPOCHS.")
batch_size = 64... | train(Xtrain, ytrain, model, optim, criterion, batch_size, 'stats') |
Next line prediction: <|code_start|>
cost = self.symb_forward(symb_input, symb_target)
self._per_sample_cost = cost
if symb_weights is not None:
cost = symb_weights * cost
# Criteria may return per-sample cost which we will average
# (optionally weighted) across sam... | def enable_weights(self): |
Given the following code snippet before the placeholder: <|code_start|>
class Criterion(object):
def __init__(self):
self.penalties = []
self.with_weights = False
self._ret_per_sample = False
self._nonzero_averaging = False
self._fn_forward = {}
def _assert_same_dim(se... | self.penalties.append((weight, pen)) |
Predict the next line for this snippet: <|code_start|>
CHOICES = 'abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&(-_=+)'
def random_passphrase():
return ''.join([choice(CHOICES) for i in range(50)])
def auth_check_func(username, password, request):
user = User.by_username(username, request)
if user and u... | authtkt_policy = AuthTktAuthenticationPolicy( |
Continue the code snippet: <|code_start|>
CHOICES = 'abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&(-_=+)'
def random_passphrase():
return ''.join([choice(CHOICES) for i in range(50)])
def auth_check_func(username, password, request):
user = User.by_username(username, request)
if user and user.password_... | config.set_authorization_policy(authz_policy) |
Here is a snippet: <|code_start|>
def __getitem__(self, release_file_name):
return self.release_files[format_key(release_file_name)]
def __setitem__(self, key, value):
key = format_key(key)
self.release_files[key] = value
self.release_files[key].__parent__ = self
@classmeth... | def set_content(self, content): |
Using the snippet: <|code_start|> )
return manager
def format_key(key):
return pkg_resources.safe_name(key.lower())
def get_connection(settings):
uri = settings.get('zodbconn.uri', None)
db = db_from_uri(uri, 'unamed', None)
return db.open()
class SnapshotModel(object):
def __setstate_... | registry = get_current_registry() |
Predict the next line for this snippet: <|code_start|> def __init__(self, name):
self.__name__ = name
self.name = name
self.releases = OOBTree()
def __getitem__(self, release_name):
return self.releases[release_name]
def __setitem__(self, key, value):
key = format_ke... | if not last_remote_release: |
Using the snippet: <|code_start|> return manager
def format_key(key):
return pkg_resources.safe_name(key.lower())
def get_connection(settings):
uri = settings.get('zodbconn.uri', None)
db = db_from_uri(uri, 'unamed', None)
return db.open()
class SnapshotModel(object):
def __setstate__(self... | anonymous_install = registry.settings.get('papaye.anonymous_install') |
Here is a snippet: <|code_start|> settings = {
'papaye.proxy': False,
'papaye.packages_directory': tmpdir.strpath,
'pyramid.incluces': 'pyramid_zodbconn',
}
env['settings'].update(settings)
env['config'].include('pyramid_zodbconn')
def clean_tmp_dir():
if os.path.exis... | env['config'].add_route( |
Here is a snippet: <|code_start|> 'config': config,
'settings': settings,
}
@pytest.fixture
def packages_directory(env, tmpdir, request):
settings = {
'papaye.proxy': False,
'papaye.packages_directory': tmpdir.strpath,
'pyramid.incluces': 'pyramid_zodbconn',
}
en... | shutil.rmtree(tmpdir.strpath) |
Given the following code snippet before the placeholder: <|code_start|> def test_smart_merge_with_different_release_file(self):
# Given
release_file1 = factories.ReleaseFileFactory(
release__version='1.5',
filename='pyramid-1.5.tar.gz',
md5_digest='12345',
... | package2['1.5'] = Release(version='1.5', metadata={}) |
Given snippet: <|code_start|> # When
result = proxy.get_remote_informations(url)
# Then
self.assertIsNone(result)
@patch('requests.get')
def test_get_remote_package_name(self, mock):
# Given
mock.side_effect = ConnectionError
url = "http://pypi.python.org... | md5_digest='12345', |
Given snippet: <|code_start|> assert len(list(result)) == 1
assert len(list(result['1.5'])) == 2
assert repository_root_factory(self.request) is not result.root
def test_smart_merge_with_new_package(self):
package1 = Package(name='pyramid')
package2 = Package(name='pyramid')... | ) |
Next line prediction: <|code_start|> context="papaye.models.Package",
traverse='{package_name}',
)
package_version = Service(
name="package_by_version",
path="/api/compat/package/{package_name}/{version}/json",
description="Package service",
factory=repository_root_factory,
)
package_version_file... | return list(root) |
Here is a snippet: <|code_start|>@package.get(schema=GetPackageSchema(), validators=(colander_validator))
def get_package(request):
return request.context.get_last_release()
@packages.get()
def list_packages(request):
root = request.context
return list(root)
@package_version.get(schema=GetPackageSchema(... | 'repository_route_url': request.static_url( |
Predict the next line after this snippet: <|code_start|>
__doc__ = ''.join('Data migration. Get model \'__parent__\' '
'previous attributes and set the new by model'
' specific attribute')
@load_model('papaye.evolve.models.snapshot2')
def evolve(root, config):
context = contex... | return context |
Using the snippet: <|code_start|>
__doc__ = ''.join('Data migration. Get model \'__parent__\' '
'previous attributes and set the new by model'
' specific attribute')
@load_model('papaye.evolve.models.snapshot2')
def evolve(root, config):
context = context_from_root(root)
r... | release_file.release = release_file.__parent__ |
Based on the snippet: <|code_start|>
serializer = TestSerializer('Fake request')
self.assertTrue(getattr(serializer, 'schema', None))
def test_schema(self):
class TestSerializer(DummySerializer, Serializer):
pass
serializer = TestSerializer(None)
schema = geta... | def setUp(self): |
Here is a snippet: <|code_start|>
class RootFactory(factory.Factory):
name = factory.Sequence(lambda n: 'Root{}'.format(n))
class Meta:
model = models.Root
class PackageFactory(factory.Factory):
name = factory.Sequence(lambda n: 'Package{}'.format(n))
root = factory.SubFactory(RootFactory)
... | release = factory.SubFactory(ReleaseFactory) |
Next line prediction: <|code_start|>
def includeme(config):
config.add_route('login', '/login/', factory=user_root_factory)
config.add_route('logout', '/logout/')
config.add_route('home', '/', factory=application_factory)
config.add_route('api', '/api/compat/', factory=user_root_factory)
config.add... | factory='papaye.factories.root:repository_root_factory', |
Continue the code snippet: <|code_start|>
def set_database_version(request, version):
root = default_root_factory(request)
root['repoze.evolution'] = {'papaye.evolve': version}
<|code_end|>
. Use current file imports:
import functools
import transaction
from papaye.factories.root import user_root_factory, re... | transaction.commit() |
Next line prediction: <|code_start|>
def set_database_version(request, version):
root = default_root_factory(request)
root['repoze.evolution'] = {'papaye.evolve': version}
<|code_end|>
. Use current file imports:
(import functools
import transaction
from papaye.factories.root import user_root_factory, reposi... | transaction.commit() |
Next line prediction: <|code_start|>
def create_repository(nb_release_file):
root = factories.RootFactory()
packages = []
for index in range(1, nb_release_file + 1):
release_file = factories.ReleaseFileFactory(
release__metadata={
'summary': 'The package {}'.format(ind... | ) |
Given snippet: <|code_start|>
def create_app_root(dbconn):
zodb_root = get_database_root(dbconn)
manager = get_manager(None)
if manager.key not in zodb_root:
zodb_root[manager.key] = {manager.package_name: manager.sw_version}
if '{}_root'.format(APP_NAME) not in zodb_root:
zodb_root['{}_... | return parser.parse_args() |
Given the code snippet: <|code_start|> user.username for user in zodb_root['{}_root'.format(APP_NAME)]['user']
if user.username == username
)
def create_app_root(dbconn):
zodb_root = get_database_root(dbconn)
manager = get_manager(None)
if manager.key not in zodb_root:
zodb_root... | parser.add_argument('--user', type=str, help='Admin username') |
Using the snippet: <|code_start|>
def admin_already_exists(dbconn, username):
zodb_root = get_database_root(dbconn)
if not '{}_root'.format(APP_NAME) in zodb_root:
return False
return any(
user.username for user in zodb_root['{}_root'.format(APP_NAME)]['user']
if user.username == us... | root[username] = admin |
Given the following code snippet before the placeholder: <|code_start|>
def get_database_root(dbconn):
zodb_root = dbconn.root()
return zodb_root
def app_root_exists(dbconn):
zodb_root = get_database_root(dbconn)
if not '{}_root'.format(APP_NAME) in zodb_root:
return False
return True
... | if 'group:admin' in user.groups |
Given the code snippet: <|code_start|> return False
if not len([
user for user in zodb_root['{}_root'.format(APP_NAME)]['user']
if 'group:admin' in user.groups
]):
return False
return True
def admin_already_exists(dbconn, username):
zodb_root = get_database_root(dbconn)
... | 'repository_root' |
Given the following code snippet before the placeholder: <|code_start|>
def create_app_root(dbconn):
zodb_root = get_database_root(dbconn)
manager = get_manager(None)
if manager.key not in zodb_root:
zodb_root[manager.key] = {manager.package_name: manager.sw_version}
if '{}_root'.format(APP_NAM... | parser.add_argument('-q', help='Quiet mode', dest="quiet", action='store_true') |
Next line prediction: <|code_start|>
def get_database_root(dbconn):
zodb_root = dbconn.root()
return zodb_root
def app_root_exists(dbconn):
zodb_root = get_database_root(dbconn)
if not '{}_root'.format(APP_NAME) in zodb_root:
return False
return True
def database_already_initialized(dbc... | return any( |
Given the code snippet: <|code_start|>class TestDownloadTask(unittest.TestCase):
def setUp(self):
self.blob_dir = tempfile.mkdtemp()
self.conn = get_db_connection(self.blob_dir)
self.root = self.conn.root()['papaye_root']['repository']
self.maxDiff = None
def tearDown(self):
... | release_file = self.root['pyramid']['1.5']['pyramid-1.5.tar.gz'] |
Based on the snippet: <|code_start|>
class TestDownloadTask(unittest.TestCase):
def setUp(self):
self.blob_dir = tempfile.mkdtemp()
self.conn = get_db_connection(self.blob_dir)
self.root = self.conn.root()['papaye_root']['repository']
<|code_end|>
, predict the immediate next line with t... | self.maxDiff = None |
Predict the next line for this snippet: <|code_start|>
__doc__ = 'blablabla blablabla'
@load_model('papaye.evolve.models.snapshot2')
def evolve(root, config=None):
new_root = Root()
new_root['repository'] = Root()
context = context_from_root(root)
for package_name in context.get('repository', tuple()... | user = context['user'][username] |
Using the snippet: <|code_start|>
__doc__ = 'blablabla blablabla'
@load_model('papaye.evolve.models.snapshot2')
def evolve(root, config=None):
new_root = Root()
new_root['repository'] = Root()
context = context_from_root(root)
for package_name in context.get('repository', tuple()):
package = ... | new_root['user'] = Root() |
Given the following code snippet before the placeholder: <|code_start|> new_root = Root()
new_root['repository'] = Root()
context = context_from_root(root)
for package_name in context.get('repository', tuple()):
package = context['repository'][package_name]
new_root['repository'][package_... | context.evolved = 6 |
Predict the next line after this snippet: <|code_start|>
HERE = os.path.abspath(os.path.dirname(__name__))
TEST_RESOURCES = os.path.join('..', '..', HERE, 'test-resources')
def get_resource(*args):
return os.path.join(TEST_RESOURCES, *args)
class FakeGRequestResponse():
def __init__(self, status_code, c... | class TestRequest(testing.DummyRequest): |
Given the code snippet: <|code_start|>
HERE = os.path.abspath(os.path.dirname(__name__))
TEST_RESOURCES = os.path.join('..', '..', HERE, 'test-resources')
def get_resource(*args):
return os.path.join(TEST_RESOURCES, *args)
class FakeGRequestResponse():
def __init__(self, status_code, content, url="https... | self.url = url |
Using the snippet: <|code_start|>
HERE = os.path.abspath(os.path.dirname(__name__))
TEST_RESOURCES = os.path.join('..', '..', HERE, 'test-resources')
def get_resource(*args):
return os.path.join(TEST_RESOURCES, *args)
class FakeGRequestResponse():
def __init__(self, status_code, content, url="https://fa... | def __init__(self, name): |
Continue the code snippet: <|code_start|> if appstruct is None:
appstruct = colander.null
return super().serialize(node, appstruct)
class Tags(object):
def serialize(self, node, appstruct):
if appstruct is None:
return colander.null
elif isinstance(appstruct... | def deserialize(self, node, cstruct): |
Given the following code snippet before the placeholder: <|code_start|> author_email = colander.SchemaNode(colander.String(), missing=None)
home_page = colander.SchemaNode(colander.String(), missing=None)
keywords = colander.SchemaNode(Tags(), missing=None)
license = colander.SchemaNode(colander.String()... | def evolve(root, config=None): |
Continue the code snippet: <|code_start|>
@patch('requests.get')
def test_not_found_view_package_not_found(mock):
settings = {'papaye.proxy': 'true'}
settings = disable_cache(settings)
request = testing.DummyRequest()
request.matchdict = {'traverse': ('package',)}
request.root = {}
testing.setUp... | assert result == { |
Based on the snippet: <|code_start|> # Create initial release
package = factories.PackageFactory(name='my-package', root=root)
release = factories.ReleaseFactory(
version='1.0', metadata={}, package=package,
)
factories.ReleaseFileFactory(
filename='foo.tar... | def test_list_release(self): |
Here is a snippet: <|code_start|> version='1.0', metadata={}, package=package,
)
factories.ReleaseFileFactory(
filename='foo.tar.gz', content=b'Fake Content', release=release,
)
view = UploadView(root, self.request)
result = view()
self.assertIsIn... | root = repository_root_factory(self.request) |
Given the code snippet: <|code_start|> def test_list_packages_without_package(self):
root = factories.RootFactory()
view = ListPackagesView(root, self.request)
response = view()
self.assertIsInstance(response, dict)
self.assertIn('objects', response)
self.assertIsIns... | ) |
Continue the code snippet: <|code_start|> factories.ReleaseFactory(package=package, version='1.2')
result = package.get_last_release()
self.assertEqual(result.version, '1.2')
def test_get_last_release_with_alpha(self):
package = factories.PackageFactory()
factories.ReleaseF... | result = iter(package) |
Predict the next line after this snippet: <|code_start|> result = release['bad releasefile name']
assert result is None
class ReleaseFileTest(unittest.TestCase):
def setUp(self):
self.request = get_current_request()
def test__init__(self):
with open(get_resource('pyramid-1.5... | assert hasattr(result, 'status') |
Predict the next line after this snippet: <|code_start|> def test_hash_password(self):
expected = 'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a'
expected += '2ea6d103fd07c95385ffab0cacbc86'
result = User('a_user', 'password')
self... | def test_get(self): |
Based on the snippet: <|code_start|> with open(get_resource('pyramid-1.5.tar.gz'), 'rb') as tar_gz:
release_file = ReleaseFile('pyramid-1.5.tar.gz', tar_gz.read())
result = ReleaseFile.clone(release_file)
assert result is not release_file
assert result.filename == release_fi... | self.assertEqual(result.password, expected) |
Given the code snippet: <|code_start|> self.assertEqual(mock.call_count, 0)
self.assertIsNone(result)
@patch('requests.get')
def test_get_last_remote_version_with_proxy(self, mock):
fake_response = FakeGRequestResponse(status_code=200, content=b'{"info": {"version": "1.0"}}')
moc... | def test_repository_is_up_to_date(self): |
Using the snippet: <|code_start|>
result = Release.by_packagename('package1', self.request)
self.assertEqual(result, None)
def test_iter(self):
release = factories.ReleaseFactory(version='1.0')
release_file = ReleaseFile('filename.tar.gz', b'')
release['filename.tar.gz'] = ... | release_file = ReleaseFile('filename.tar.gz', b'') |
Continue the code snippet: <|code_start|>
def test_get_with_default(self):
model_instance = self.Model(name='test')
model_instance.attribute = {'test': 'ok'}
result = model_instance.get('test', None)
self.assertEqual(result, 'ok')
def test_get_with_default_returned(self):
... | assert result.attr1 == 'one' |
Using the snippet: <|code_start|> cstruct = self.schema.serialize(data)
return self.schema.deserialize(cstruct)
def get_data(self, obj):
return {key: getattr(obj, key) for key in self.fields.keys() if getattr(obj, key, None) is not None}
class PackageListSerializer(Serializer):
name = ... | self.request = request |
Based on the snippet: <|code_start|>
class Serializer(object):
fields = None
_schema = None
def __new__(cls, *args, **kwargs):
attributes = {attribute_name: getattr(cls, attribute_name) for attribute_name in dir(cls)}
cls.fields = {attribute_name: attribute for attribute_name, attribute ... | @property |
Here is a snippet: <|code_start|>
class Serializer(object):
fields = None
_schema = None
def __new__(cls, *args, **kwargs):
attributes = {attribute_name: getattr(cls, attribute_name) for attribute_name in dir(cls)}
cls.fields = {attribute_name: attribute for attribute_name, attribute in ... | if nodes: |
Continue the code snippet: <|code_start|> if isinstance(attribute, colander.SchemaNode)}
return super(Serializer, cls).__new__(cls)
@property
def schema(self):
if self._schema is None:
schema = colander.SchemaNode(colander.Mapping())
nodes = {name: n... | if package.metadata and 'summary' in package.metadata: |
Given snippet: <|code_start|>
class Serializer(object):
fields = None
_schema = None
def __new__(cls, *args, **kwargs):
attributes = {attribute_name: getattr(cls, attribute_name) for attribute_name in dir(cls)}
cls.fields = {attribute_name: attribute for attribute_name, attribute in attr... | schema.add(node) |
Using the snippet: <|code_start|>
@load_model('papaye.evolve.models.snapshot1')
def evolve(root, config=None):
context = context_from_root(root)
repository = context.get('repository', tuple())
for package_name in repository:
package = repository[package_name]
for release_name in package.re... | print(release_file.__name__ + ' --> cached') |
Given snippet: <|code_start|>
@load_model('papaye.evolve.models.snapshot1')
def evolve(root, config=None):
context = context_from_root(root)
repository = context.get('repository', tuple())
for package_name in repository:
package = repository[package_name]
for release_name in package.releas... | print(release_file.__name__ + ' --> local') |
Continue the code snippet: <|code_start|>
@load_model('papaye.evolve.models.snapshot1')
def evolve(root, config=None):
context = context_from_root(root)
repository = context.get('repository', tuple())
for package_name in repository:
package = repository[package_name]
for release_name in pa... | release = package[release_name] |
Using the snippet: <|code_start|> )
manager.sw_version = 1
mock.return_value = manager
self.assertRaises(ConfigurationError, check_database_config, self.config)
@patch('papaye.models.get_manager')
def test_check_database_config_without_approot(self, mock):
root = self.ge... | pass |
Here is a snippet: <|code_start|>
class ConfigTest(unittest.TestCase):
def setUp(self):
self.request = testing.DummyRequest()
self.config = testing.setUp(request=self.request)
self.blob_dir = set_database_connection(
self.request,
config=self.config
)
... | root._p_jar = P_jar() |
Next line prediction: <|code_start|> else:
return cstruct.split(' ')
class Classifiers(colander.List):
def deserialize(self, node, cstruct):
if cstruct == colander.null:
return None
elif isinstance(cstruct, (str, bytes)):
return [value for value in (valu... | raise colander.Invalid(node, '%r is not a string' % cstruct) |
Based on the snippet: <|code_start|>class Description(object):
def serialize(self, node, appstruct):
if appstruct is None:
return colander.null
if not isinstance(appstruct, (str, bytes)):
raise colander.Invalid(node, '%r is not a string' % appstruct)
return appstruct... | size = colander.SchemaNode(colander.String()) |
Based on the snippet: <|code_start|>
def cleanup():
del(sys.modules['papaye.app_models'])
del(sys.modules['papaye.models'])
sys.modules['papaye.models'] = importlib.import_module('papaye.models')
def load_model(model_name):
def decorated(func):
func.load_model = importlib.import_module(mode... | def wrapped(root): |
Given the following code snippet before the placeholder: <|code_start|> self.assertEqual(result['keywords'], ['web', 'wsgi', 'bfg', 'pylons', 'pyramid'])
self.assertEqual(result['license'], 'UNKNOWN')
self.assertEqual(result['summary'], cstruct['summary'])
self.assertEqual(result['mainta... | 'classifiers', |
Based on the snippet: <|code_start|>
def compute_release_file_directory(release_file):
time_low = release_file.uuid.time_low
path = list(map(lambda x: hex(int(x)), str(time_low)))
return os.path.join(*path)
@load_model('papaye.evolve.models.snapshot2')
def evolve(root, config):
context = context_from_... | archive.write(release_file.content.open().read()) |
Next line prediction: <|code_start|>
__doc__ = ''.join('Data migration. Migrate release files into a directory '
'instead of managed with ZODB blob storage')
def compute_release_file_directory(release_file):
time_low = release_file.uuid.time_low
path = list(map(lambda x: hex(int(x)), str(ti... | for package in context['repository']: |
Given the following code snippet before the placeholder: <|code_start|>
@view_config(route_name='home', renderer='index.jinja2', request_method='GET')
def index_view(context, request):
username = request.session.get('username', '')
app_context = {
'username': username,
'papaye': {
'... | def __call__(self): |
Using the snippet: <|code_start|>
class String(colander.String):
def serialize(self, node, appstruct):
if appstruct is None:
appstruct = colander.null
return super().serialize(node, appstruct)
class Tags(object):
def serialize(self, node, appstruct):
if appstruct is No... | return colander.null |
Predict the next line after this snippet: <|code_start|>
def deserialize(self, node, cstruct):
if cstruct == colander.null or cstruct == {}:
return None
return super(NullableMapping, self).deserialize(node, cstruct)
class APIDescription(colander.MappingSchema):
content = colander.S... | release_files = ReleaseFile() |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.