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"):
customs.append("custom: {}".format(f_name))
<|code_end|>
using the current file's imports:
import os
import traceback
import re
import yaml
from sam import constants
and any relevant context from other files:
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
. Output only the next line. | 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 the next line using the imports in this file:
import os
import json
from spec.python import db_connection
from sam import constants, update_portLUT
from py._path.local import LocalPath
and context (functions, classes, or occasionally code) from other files:
# Path: spec/python/db_connection.py
# TEST_DATABASE_MYSQL = 'samapper_test'
# TEST_DATABASE_SQLITE = '/tmp/sam_test.db'
# class Mocker(object):
# class Session(dict):
# class env(object):
# def __init__(self, *args, **kwargs):
# def __getitem__(self, k):
# def __setitem__(self, k, v):
# def __getattr__(self, name):
# def receiver(*args, **kwargs):
# def __call__(self, *args, **kwargs):
# def clear(self):
# def was_called(self, name, *args, **kwargs):
# def kill(self):
# def __init__(self, mock_input=False, login_active=None, mock_session=False, mock_render=False, lang='en'):
# def __enter__(self):
# def __exit__(self, type, value, traceback):
# def make_timestamp(timestring):
# def unix_timestamp_to_datetime(stamp):
# def get_test_db_connection():
# def setup_datasources(db, sub_id):
# def template_sql(path, *args):
# def setup_network(db, sub_id, ds_id):
# def setup_node_extras(sub_id):
#
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
. Output only the next line. | 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", vars={'start': t_low, 'end': t_high})
ips = m_nodes.get_all()
test_set = set(map(common.IPStringtoInt, ['99.99.99.99', '99.99.99', '99.99', '99']))
test_set_chopped = set(map(common.IPStringtoInt, ['99.99.99', '99.99', '99']))
assert not test_set.issubset(set(ips))
db.insert(m_nodes.table_nodes, **ipToNode("99.99.99.99"))
db.insert(m_nodes.table_nodes, **ipToNode("99.99.99"))
db.insert(m_nodes.table_nodes, **ipToNode("99.99"))
db.insert(m_nodes.table_nodes, **ipToNode("99"))
ips = m_nodes.get_all()
assert test_set.issubset(set(ips))
m_nodes.delete_hosts([common.IPStringtoInt("99.99.99.99")])
ips = m_nodes.get_all()
assert not test_set.issubset(set(ips))
assert test_set_chopped.issubset(set(ips))
finally:
db.delete(m_nodes.table_nodes, where="ipstart BETWEEN $start AND $end", vars={'start': t_low, 'end': t_high})
def test_del_collection():
m_nodes = nodes.Nodes(db, sub_id)
<|code_end|>
, generate the next line using the imports in this file:
from spec.python import db_connection
from sam import common
from sam.models import nodes
and context (functions, classes, or occasionally code) from other files:
# Path: spec/python/db_connection.py
# TEST_DATABASE_MYSQL = 'samapper_test'
# TEST_DATABASE_SQLITE = '/tmp/sam_test.db'
# class Mocker(object):
# class Session(dict):
# class env(object):
# def __init__(self, *args, **kwargs):
# def __getitem__(self, k):
# def __setitem__(self, k, v):
# def __getattr__(self, name):
# def receiver(*args, **kwargs):
# def __call__(self, *args, **kwargs):
# def clear(self):
# def was_called(self, name, *args, **kwargs):
# def kill(self):
# def __init__(self, mock_input=False, login_active=None, mock_session=False, mock_render=False, lang='en'):
# def __enter__(self):
# def __exit__(self, type, value, traceback):
# def make_timestamp(timestring):
# def unix_timestamp_to_datetime(stamp):
# def get_test_db_connection():
# def setup_datasources(db, sub_id):
# def template_sql(path, *args):
# def setup_network(db, sub_id, ds_id):
# def setup_node_extras(sub_id):
. Output only the next line. | 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_session=False, mock_render=False, lang='en'):
self.input_real = web.input
self.active_old = sam.constants.access_control['active']
self.session = sam.common.session
self.renderer = sam.common.renderer
self.lang = lang
self.mock_input = mock_input
self.mock_login = login_active
self.mock_render = mock_render
self.mock_session = mock_session
def __enter__(self):
if self.mock_input:
web.input = lambda: {}
if self.mock_login is True:
sam.constants.access_control['active'] = True
elif self.mock_login is False:
sam.constants.access_control['active'] = False
<|code_end|>
, predict the next line using imports from the current file:
import os
import time
import sam.constants
import sam.common
import sam.integrity
import sam.models.datasources
import web.template
import sam.importers.import_base
import sam.preprocess
import sam.models.links
import sam.models.nodes
from datetime import datetime
from sam.models.subscriptions import Subscriptions
and context including class names, function names, and sometimes code from other files:
# Path: sam/models/subscriptions.py
# class Subscriptions:
# CREATE_MYSQL = os.path.join(constants.base_path, 'sql/setup_subscription_tables_mysql.sql')
# CREATE_SQLITE = os.path.join(constants.base_path, 'sql/setup_subscription_tables_sqlite.sql')
# DROP_SQL = os.path.join(constants.base_path, 'sql/drop_subscription.sql')
# table = "Subscriptions"
#
# def __init__(self, db):
# """
# :type db: web.DB
# """
# self.db = db
#
# def get_all(self):
# rows = self.db.select(Subscriptions.table)
# return list(rows)
#
# def get_id_list(self):
# rows = self.db.select(Subscriptions.table, what="subscription")
# return [row['subscription'] for row in rows]
#
# def get_by_email(self, email):
# qvars = {
# 'email': email
# }
# rows = self.db.select(Subscriptions.table, where='email=$email', vars=qvars)
# return rows.first()
#
# def get(self, sub_id):
# qvars = {
# 'sid': sub_id
# }
# rows = self.db.select(Subscriptions.table, where='subscription=$sid', vars=qvars)
# return rows.first()
#
# def set(self, sub_id, **kwargs):
# qvars = {
# 'sub': sub_id,
# }
# rows_updated = self.db.update(Subscriptions.table, "subscription=$sub", vars=qvars, **kwargs)
# return rows_updated == 1
#
# def create_subscription_tables(self, sub_id):
# replacements = {"acct": sub_id}
# if self.db.dbname == 'mysql':
# common.exec_sql(self.db, self.CREATE_MYSQL, replacements)
# else:
# common.exec_sql(self.db, self.CREATE_SQLITE, replacements)
#
# # replicate port data
# portsModel = sam.models.ports.Ports(self.db, sub_id)
# portsModel.reset()
#
# def create_default_subscription(self):
# email = constants.subscription['default_email']
# name = constants.subscription['default_name']
# plan = 'admin'
# active = True
# sub_id = self.db.insert(self.table, email=email, name=name, plan=plan, groups='read write admin', active=active)
# return sub_id
#
# def decode_sub(self, key):
# """
# :param key: a subscription id (string or int) or an email address that identify a subscription
# :type key: int or unicode
# :return: Subscription id (integer) or None on failure
# :rtype: int or None
# """
# subs = self.get_all()
# numbers = {sub['subscription'] for sub in subs}
#
# response = None
# sub_num = -1
# try:
# sub_num = int(key)
# except:
# sought_sub = None
# for sub in subs:
# if sub['email'] == key:
# sought_sub = sub
# break
# if sought_sub:
# sub_num = sought_sub['subscription']
#
# if sub_num in numbers:
# response = sub_num
# elif constants.access_control['active'] is False:
# sought_sub = None
# for sub in subs:
# if sub['email'] == constants.subscription['default_email']:
# sought_sub = sub
# break
# if sought_sub:
# response = sought_sub['subscription']
#
# return response
#
# def get_plugin_data(self, sub_id, plugin_name):
# qvars = {'sid': sub_id}
# rows = self.db.select(self.table, what="plugins", where="subscription=$sid", vars=qvars)
# row = rows.first()
# if not row:
# raise ValueError("invalid subscription id")
# try:
# if row['plugins'] is not None:
# plugins = cPickle.loads(str(row['plugins']))
# else:
# plugins = {}
# except:
# logger.warning("error decoding plugins: plugins was {}".format(repr(row['plugins'])))
# plugins = {}
# data = plugins.get(plugin_name, {})
# return data
#
# def set_plugin_data(self, sub_id, plugin_name, data):
# qvars = {'sid': int(sub_id)}
# rows = self.db.select(self.table, what="plugins", where="subscription=$sid", vars=qvars)
# row = rows.first()
# if not row:
# raise ValueError("invalid subscription id")
# try:
# plugins = cPickle.loads(str(row['plugins']))
# except:
# plugins = {}
#
# try:
# plugins[plugin_name] = data
# self.db.update(self.table, where="subscription=$sid", vars=qvars, plugins=cPickle.dumps(plugins))
# except:
# logger.error("cannot encode data")
# raise
. Output only the next line. | 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'
web.ctx.path = "/sam/testpage"
dummy = p.GET()
calls = common.renderer.calls
tags = []
envs = {'dev', 'inherit', 'production'}
dses = [{'flat': 0, 'subscription': 1L, 'ar_active': 0, 'ar_interval': 300L, 'id': 1L, 'name': u'default'},
{'flat': 0, 'subscription': 1L, 'ar_active': 0, 'ar_interval': 300L, 'id': 2L, 'name': u'short'},
{'flat': 0, 'subscription': 1L, 'ar_active': 0, 'ar_interval': 300L, 'id': 3L, 'name': u'live'}]
assert calls[0] == ('render', ('_head', page_title,), {'lang': 'en', 'stylesheets': p.styles, 'scripts': p.scripts})
assert calls[1] == ('render', ('en/_header', constants.get_navbar('en'), page_title, p.page.user, constants.debug, "/sam/testpage", constants.access_control, ('version française', '/fr/sam/testpage')), {})
assert calls[2] == ('render', ('en/metadata', tags, envs, dses), {})
assert calls[3] == ('render', ('_tail', ), {})
<|code_end|>
, predict the next line using imports from the current file:
from spec.python import db_connection
from sam import common
from sam import constants
import web
import sam.pages.metadata
and context including class names, function names, and sometimes code from other files:
# Path: spec/python/db_connection.py
# TEST_DATABASE_MYSQL = 'samapper_test'
# TEST_DATABASE_SQLITE = '/tmp/sam_test.db'
# class Mocker(object):
# class Session(dict):
# class env(object):
# def __init__(self, *args, **kwargs):
# def __getitem__(self, k):
# def __setitem__(self, k, v):
# def __getattr__(self, name):
# def receiver(*args, **kwargs):
# def __call__(self, *args, **kwargs):
# def clear(self):
# def was_called(self, name, *args, **kwargs):
# def kill(self):
# def __init__(self, mock_input=False, login_active=None, mock_session=False, mock_render=False, lang='en'):
# def __enter__(self):
# def __exit__(self, type, value, traceback):
# def make_timestamp(timestring):
# def unix_timestamp_to_datetime(stamp):
# def get_test_db_connection():
# def setup_datasources(db, sub_id):
# def template_sql(path, *args):
# def setup_network(db, sub_id, ds_id):
# def setup_node_extras(sub_id):
#
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
. Output only the next line. | 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'}
request = p.decode_get_request(data)
expected = {'addresses': ['10.20.30', '150.20', '59'], 'flat': False, 'ds': 13}
assert request == expected
data = {'address': '50.60.70.80', 'ds': 'ds_13'}
request = p.decode_get_request(data)
expected = {'addresses': ['50.60.70.80'], 'flat': False, 'ds': 13}
assert request == expected
data = {'ds': '53'}
request = p.decode_get_request(data)
expected = {'addresses': [], 'flat': False, 'ds': 53}
assert request == expected
data = {'horseradish': 'pickles', 'ds': 'ds_13'}
request = p.decode_get_request(data)
expected = {'addresses': [], 'flat': False, 'ds': 13}
assert request == expected
data = {'horseradish': 'pickles', 'ds': 'ds_13', 'flat': 'true'}
request = p.decode_get_request(data)
expected = {'addresses': [], 'flat': True, 'ds': 13}
<|code_end|>
, determine the next line of code. You have imports:
from spec.python import db_connection
import sam.pages.nodes
and context (class names, function names, or code) available:
# Path: spec/python/db_connection.py
# TEST_DATABASE_MYSQL = 'samapper_test'
# TEST_DATABASE_SQLITE = '/tmp/sam_test.db'
# class Mocker(object):
# class Session(dict):
# class env(object):
# def __init__(self, *args, **kwargs):
# def __getitem__(self, k):
# def __setitem__(self, k, v):
# def __getattr__(self, name):
# def receiver(*args, **kwargs):
# def __call__(self, *args, **kwargs):
# def clear(self):
# def was_called(self, name, *args, **kwargs):
# def kill(self):
# def __init__(self, mock_input=False, login_active=None, mock_session=False, mock_render=False, lang='en'):
# def __enter__(self):
# def __exit__(self, type, value, traceback):
# def make_timestamp(timestring):
# def unix_timestamp_to_datetime(stamp):
# def get_test_db_connection():
# def setup_datasources(db, sub_id):
# def template_sql(path, *args):
# def setup_network(db, sub_id, ds_id):
# def setup_node_extras(sub_id):
. Output only the next line. | 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)
assert parsed == {
'format': 'asasyslog',
'port': None,
'target': 'local',
'whois': True,
'wsgi': False,
'dest': 'default',
'sub': None
}
assert args == []
argv = 'launcher.py --local --port=8421'.split()
parsed, args = launcher.parse_args(argv)
assert parsed == {
'format': None,
'port': '8421',
'target': 'local',
'whois': False,
'wsgi': False,
'dest': 'default',
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import sys
import signal
import multiprocessing
import time
from spec.python import db_connection
from sam import constants, launcher, preprocess
from sam import server_webserver
from sam import server_collector
from sam import server_aggregator
from sam.importers import import_base
from sam.models.livekeys import LiveKeys
from sam.models.datasources import Datasources
from sam.models import nodes
and context (classes, functions, sometimes code) from other files:
# Path: spec/python/db_connection.py
# TEST_DATABASE_MYSQL = 'samapper_test'
# TEST_DATABASE_SQLITE = '/tmp/sam_test.db'
# class Mocker(object):
# class Session(dict):
# class env(object):
# def __init__(self, *args, **kwargs):
# def __getitem__(self, k):
# def __setitem__(self, k, v):
# def __getattr__(self, name):
# def receiver(*args, **kwargs):
# def __call__(self, *args, **kwargs):
# def clear(self):
# def was_called(self, name, *args, **kwargs):
# def kill(self):
# def __init__(self, mock_input=False, login_active=None, mock_session=False, mock_render=False, lang='en'):
# def __enter__(self):
# def __exit__(self, type, value, traceback):
# def make_timestamp(timestring):
# def unix_timestamp_to_datetime(stamp):
# def get_test_db_connection():
# def setup_datasources(db, sub_id):
# def template_sql(path, *args):
# def setup_network(db, sub_id, ds_id):
# def setup_node_extras(sub_id):
#
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
#
# Path: sam/launcher.py
# VALID_ARGS = ['format=', 'port=', 'target=', 'dest=', 'sub=', 'local', 'whois', 'wsgi']
# VALID_TARGETS = ['local', 'aggregator', 'collector', 'collector_stream',
# 'webserver', 'import', 'test_dummy', 'template']
# def main(argv=None):
# def parse_args(argv):
# def launch_webserver(parsed, args):
# def launch_collector(parsed, args):
# def launch_collector_stream(parsed, args):
# def launch_aggregator(parsed, args):
# def launch_importer(parsed, args):
# def launch_template_tester(parsed, args):
# def create_local_settings(db, sub, ds_key):
# def check_database():
# def launch_whois_service(db, sub):
# def launch_localmode(parsed, args):
# def spawn_coll(stdin):
# def testing_entrypoint(environment, argv):
#
# Path: sam/server_webserver.py
# def check_database():
# def create_session(app):
# def localization_hook():
# def start_server(port):
# def start_wsgi():
. Output only the next line. | '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.py', '--target=test_dummy']
assert launcher.main(argv) == 3
argv = ['launcher.py', '--target=import']
assert launcher.main(argv) == 0
def test_parse_args():
argv = 'launcher.py'.split()
parsed, args = launcher.parse_args(argv)
assert parsed == {
'format': None,
<|code_end|>
. Use current file imports:
(import os
import sys
import signal
import multiprocessing
import time
from spec.python import db_connection
from sam import constants, launcher, preprocess
from sam import server_webserver
from sam import server_collector
from sam import server_aggregator
from sam.importers import import_base
from sam.models.livekeys import LiveKeys
from sam.models.datasources import Datasources
from sam.models import nodes)
and context including class names, function names, or small code snippets from other files:
# Path: spec/python/db_connection.py
# TEST_DATABASE_MYSQL = 'samapper_test'
# TEST_DATABASE_SQLITE = '/tmp/sam_test.db'
# class Mocker(object):
# class Session(dict):
# class env(object):
# def __init__(self, *args, **kwargs):
# def __getitem__(self, k):
# def __setitem__(self, k, v):
# def __getattr__(self, name):
# def receiver(*args, **kwargs):
# def __call__(self, *args, **kwargs):
# def clear(self):
# def was_called(self, name, *args, **kwargs):
# def kill(self):
# def __init__(self, mock_input=False, login_active=None, mock_session=False, mock_render=False, lang='en'):
# def __enter__(self):
# def __exit__(self, type, value, traceback):
# def make_timestamp(timestring):
# def unix_timestamp_to_datetime(stamp):
# def get_test_db_connection():
# def setup_datasources(db, sub_id):
# def template_sql(path, *args):
# def setup_network(db, sub_id, ds_id):
# def setup_node_extras(sub_id):
#
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
#
# Path: sam/launcher.py
# VALID_ARGS = ['format=', 'port=', 'target=', 'dest=', 'sub=', 'local', 'whois', 'wsgi']
# VALID_TARGETS = ['local', 'aggregator', 'collector', 'collector_stream',
# 'webserver', 'import', 'test_dummy', 'template']
# def main(argv=None):
# def parse_args(argv):
# def launch_webserver(parsed, args):
# def launch_collector(parsed, args):
# def launch_collector_stream(parsed, args):
# def launch_aggregator(parsed, args):
# def launch_importer(parsed, args):
# def launch_template_tester(parsed, args):
# def create_local_settings(db, sub, ds_key):
# def check_database():
# def launch_whois_service(db, sub):
# def launch_localmode(parsed, args):
# def spawn_coll(stdin):
# def testing_entrypoint(environment, argv):
#
# Path: sam/server_webserver.py
# def check_database():
# def create_session(app):
# def localization_hook():
# def start_server(port):
# def start_wsgi():
. Output only the next line. | '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.calls[0][2] == {'format': 'paloalto'}
finally:
server_collector.Collector = old_collector
def test_launch_aggregator():
old_start_wsgi = server_aggregator.start_wsgi
old_start_server = server_aggregator.start_server
try:
server_aggregator.start_wsgi = db_connection.Mocker()
server_aggregator.start_server = db_connection.Mocker()
parsed = {'port': '8040', 'wsgi': False}
launcher.launch_aggregator(parsed, None)
assert len(server_aggregator.start_wsgi.calls) == 0
assert len(server_aggregator.start_server.calls) == 1
assert server_aggregator.start_server.calls[0][2] == {'port': '8040'}
parsed = {'port': None, 'wsgi': False}
launcher.launch_aggregator(parsed, None)
assert len(server_aggregator.start_wsgi.calls) == 0
assert len(server_aggregator.start_server.calls) == 2
assert server_aggregator.start_server.calls[1][2] == {'port': constants.aggregator['listen_port']}
<|code_end|>
, determine the next line of code. You have imports:
import os
import sys
import signal
import multiprocessing
import time
from spec.python import db_connection
from sam import constants, launcher, preprocess
from sam import server_webserver
from sam import server_collector
from sam import server_aggregator
from sam.importers import import_base
from sam.models.livekeys import LiveKeys
from sam.models.datasources import Datasources
from sam.models import nodes
and context (class names, function names, or code) available:
# Path: spec/python/db_connection.py
# TEST_DATABASE_MYSQL = 'samapper_test'
# TEST_DATABASE_SQLITE = '/tmp/sam_test.db'
# class Mocker(object):
# class Session(dict):
# class env(object):
# def __init__(self, *args, **kwargs):
# def __getitem__(self, k):
# def __setitem__(self, k, v):
# def __getattr__(self, name):
# def receiver(*args, **kwargs):
# def __call__(self, *args, **kwargs):
# def clear(self):
# def was_called(self, name, *args, **kwargs):
# def kill(self):
# def __init__(self, mock_input=False, login_active=None, mock_session=False, mock_render=False, lang='en'):
# def __enter__(self):
# def __exit__(self, type, value, traceback):
# def make_timestamp(timestring):
# def unix_timestamp_to_datetime(stamp):
# def get_test_db_connection():
# def setup_datasources(db, sub_id):
# def template_sql(path, *args):
# def setup_network(db, sub_id, ds_id):
# def setup_node_extras(sub_id):
#
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
#
# Path: sam/launcher.py
# VALID_ARGS = ['format=', 'port=', 'target=', 'dest=', 'sub=', 'local', 'whois', 'wsgi']
# VALID_TARGETS = ['local', 'aggregator', 'collector', 'collector_stream',
# 'webserver', 'import', 'test_dummy', 'template']
# def main(argv=None):
# def parse_args(argv):
# def launch_webserver(parsed, args):
# def launch_collector(parsed, args):
# def launch_collector_stream(parsed, args):
# def launch_aggregator(parsed, args):
# def launch_importer(parsed, args):
# def launch_template_tester(parsed, args):
# def create_local_settings(db, sub, ds_key):
# def check_database():
# def launch_whois_service(db, sub):
# def launch_localmode(parsed, args):
# def spawn_coll(stdin):
# def testing_entrypoint(environment, argv):
#
# Path: sam/server_webserver.py
# def check_database():
# def create_session(app):
# def localization_hook():
# def start_server(port):
# def start_wsgi():
. Output only the next line. | 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 = launcher.parse_args(argv)
assert parsed == {
'format': None,
'port': None,
'target': 'collector_stream',
'whois': False,
'wsgi': False,
'dest': 'default',
'sub': None
}
assert args == []
argv = 'launcher.py --target=import ../data/syslog'.split()
parsed, args = launcher.parse_args(argv)
assert parsed == {
'format': None,
'port': None,
'target': 'import',
'whois': False,
<|code_end|>
. Use current file imports:
import os
import sys
import signal
import multiprocessing
import time
from spec.python import db_connection
from sam import constants, launcher, preprocess
from sam import server_webserver
from sam import server_collector
from sam import server_aggregator
from sam.importers import import_base
from sam.models.livekeys import LiveKeys
from sam.models.datasources import Datasources
from sam.models import nodes
and context (classes, functions, or code) from other files:
# Path: spec/python/db_connection.py
# TEST_DATABASE_MYSQL = 'samapper_test'
# TEST_DATABASE_SQLITE = '/tmp/sam_test.db'
# class Mocker(object):
# class Session(dict):
# class env(object):
# def __init__(self, *args, **kwargs):
# def __getitem__(self, k):
# def __setitem__(self, k, v):
# def __getattr__(self, name):
# def receiver(*args, **kwargs):
# def __call__(self, *args, **kwargs):
# def clear(self):
# def was_called(self, name, *args, **kwargs):
# def kill(self):
# def __init__(self, mock_input=False, login_active=None, mock_session=False, mock_render=False, lang='en'):
# def __enter__(self):
# def __exit__(self, type, value, traceback):
# def make_timestamp(timestring):
# def unix_timestamp_to_datetime(stamp):
# def get_test_db_connection():
# def setup_datasources(db, sub_id):
# def template_sql(path, *args):
# def setup_network(db, sub_id, ds_id):
# def setup_node_extras(sub_id):
#
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
#
# Path: sam/launcher.py
# VALID_ARGS = ['format=', 'port=', 'target=', 'dest=', 'sub=', 'local', 'whois', 'wsgi']
# VALID_TARGETS = ['local', 'aggregator', 'collector', 'collector_stream',
# 'webserver', 'import', 'test_dummy', 'template']
# def main(argv=None):
# def parse_args(argv):
# def launch_webserver(parsed, args):
# def launch_collector(parsed, args):
# def launch_collector_stream(parsed, args):
# def launch_aggregator(parsed, args):
# def launch_importer(parsed, args):
# def launch_template_tester(parsed, args):
# def create_local_settings(db, sub, ds_key):
# def check_database():
# def launch_whois_service(db, sub):
# def launch_localmode(parsed, args):
# def spawn_coll(stdin):
# def testing_entrypoint(environment, argv):
#
# Path: sam/server_webserver.py
# def check_database():
# def create_session(app):
# def localization_hook():
# def start_server(port):
# def start_wsgi():
. Output only the next line. | '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_template.RuleTemplate)
def test_yml_dos():
s = 'dos.yml'
dfn = rule_template.get_definition(rule_template.abs_rule_path(s))
assert isinstance(dfn, rule_template.RuleTemplate)
def test_yml_netscan():
s = 'netscan.yml'
dfn = rule_template.get_definition(rule_template.abs_rule_path(s))
assert isinstance(dfn, rule_template.RuleTemplate)
def test_yml_portscan():
s = 'portscan.yml'
dfn = rule_template.get_definition(rule_template.abs_rule_path(s))
assert isinstance(dfn, rule_template.RuleTemplate)
def test_yml_suspicious():
<|code_end|>
. Write the next line using the current file imports:
import os
import yaml
import pytest
from sam import constants
from sam.models.security import rule_template
and context from other files:
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
#
# Path: sam/models/security/rule_template.py
# def get_all():
# def abs_rule_path(path):
# def get_definition(path, cache={}):
# def __init__(self, path, yml):
# def import_yml(self, data):
# def load_exposed(yml):
# def load_inclusions(self, yml):
# def load_action_defaults(yml):
# def get_exposed(self):
# def get_action_defaults(self):
# def get_inclusions(self):
# class RuleTemplate(object):
, which may include functions, classes, or code. Output only the next line. | 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]?[0-9][0-9]|2[0-4][0-9]|25[0-5])){3}$"
port:
format: text
label: temp label 3
default: "(80,443)"
severity:
format: text
label: Alert severity
default: 2
regex: "[1-8]"
sendmail:
format: checkbox
label: Send email?
default: 0
color:
format: dropdown
label: Favorite Color
default: blue
options:
- red
- blue
- green
actions:
alert_severity: 8
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import yaml
import pytest
from sam import constants
from sam.models.security import rule_template
and context (classes, functions, sometimes code) from other files:
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
#
# Path: sam/models/security/rule_template.py
# def get_all():
# def abs_rule_path(path):
# def get_definition(path, cache={}):
# def __init__(self, path, yml):
# def import_yml(self, data):
# def load_exposed(yml):
# def load_inclusions(self, yml):
# def load_action_defaults(yml):
# def get_exposed(self):
# def get_action_defaults(self):
# def get_inclusions(self):
# class RuleTemplate(object):
. Output only the next line. | 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.sort()
return l_envs[:10]
def get_hosts_preview(self):
hosts = self.nodes_model.get_hostnames_preview()
hosts.sort()
return hosts
# handle HTTP GET requests here. Name gets value from routing rules above.
def GET(self):
self.page.require_group('read')
self.settingsModel = sam.models.settings.Settings(common.db, self.page.session, self.page.user.viewing)
self.dsModel = sam.models.datasources.Datasources(common.db, self.page.session, self.page.user.viewing)
self.livekeyModel = sam.models.livekeys.LiveKeys(common.db, self.page.user.viewing)
self.nodes_model = sam.models.nodes.Nodes(common.db, self.page.user.viewing)
settings = self.settingsModel.copy()
datasources = self.dsModel.sorted_list()
importers = self.get_available_importers()
livekeys = self.livekeyModel.read()
tags_preview = self.get_tags_preview()
<|code_end|>
. Use current file imports:
import os
import re
import base
import sam.models.settings
import sam.models.datasources
import sam.models.livekeys
import sam.models.nodes
import pprint
from sam import constants
from sam import common
and context (classes, functions, or code) from other files:
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
. Output only the next line. | 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_session=True):
for component in ['quick_info', 'inputs', 'outputs', 'ports', 'children', 'summary']:
input_data = {'address': test_ip, 'ds': ds_full, 'component': component}
GET_data = urllib.urlencode(input_data)
req = app.request('/details?{0}'.format(GET_data), 'GET')
assert req.status == "200 OK"
assert req.headers['Content-Type'] == "application/json"
data = json.loads(req.data)
assert data.keys() == [component]
assert type(data[component]) == dict
def test_multiple_components():
app = web.application(constants.urls)
test_ip = '59.69.79.89'
input_data = {'address': test_ip, 'ds': ds_full, 'component': 'quick_info,ports,summary'}
GET_data = urllib.urlencode(input_data)
with db_connection.env(mock_session=True):
req = app.request('/details?{0}'.format(GET_data), 'GET')
assert req.status == "200 OK"
assert req.headers['Content-Type'] == "application/json"
data = json.loads(req.data)
<|code_end|>
, determine the next line of code. You have imports:
from spec.python import db_connection
from sam.local import en as strings
from sam import constants
import web
import sam.pages.details
import json
import urllib
and context (class names, function names, or code) available:
# Path: spec/python/db_connection.py
# TEST_DATABASE_MYSQL = 'samapper_test'
# TEST_DATABASE_SQLITE = '/tmp/sam_test.db'
# class Mocker(object):
# class Session(dict):
# class env(object):
# def __init__(self, *args, **kwargs):
# def __getitem__(self, k):
# def __setitem__(self, k, v):
# def __getattr__(self, name):
# def receiver(*args, **kwargs):
# def __call__(self, *args, **kwargs):
# def clear(self):
# def was_called(self, name, *args, **kwargs):
# def kill(self):
# def __init__(self, mock_input=False, login_active=None, mock_session=False, mock_render=False, lang='en'):
# def __enter__(self):
# def __exit__(self, type, value, traceback):
# def make_timestamp(timestring):
# def unix_timestamp_to_datetime(stamp):
# def get_test_db_connection():
# def setup_datasources(db, sub_id):
# def template_sql(path, *args):
# def setup_network(db, sub_id, ds_id):
# def setup_node_extras(sub_id):
#
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
. Output only the next line. | 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 = '50.60.70.80'
with db_connection.env(mock_session=True):
input_data = {"address": test_ip, 'ds': ds_full, 'tstart': time_all[0], 'tend': time_all[1]}
GET_data = urllib.urlencode(input_data)
req = app.request('/details?{0}'.format(GET_data), 'GET')
assert req.status == "200 OK"
assert req.headers['Content-Type'] == "application/json"
data = json.loads(req.data)
assert simplify(data) == (9, 12, 11, 14, 17, 11)
input_data = {"address": test_ip, 'ds': ds_full, 'tstart': time_crop[0], 'tend': time_crop[1]}
GET_data = urllib.urlencode(input_data)
req = app.request('/details?{0}'.format(GET_data), 'GET')
assert req.status == "200 OK"
assert req.headers['Content-Type'] == "application/json"
data = json.loads(req.data)
assert simplify(data) == (9, 12, 11, 14, 17, 11)
input_data = {"address": test_ip, 'ds': ds_full, 'tstart': time_tiny[0], 'tend': time_tiny[1]}
GET_data = urllib.urlencode(input_data)
req = app.request('/details?{0}'.format(GET_data), 'GET')
assert req.status == "200 OK"
<|code_end|>
. Use current file imports:
(from spec.python import db_connection
from sam.local import en as strings
from sam import constants
import web
import sam.pages.details
import json
import urllib)
and context including class names, function names, or small code snippets from other files:
# Path: spec/python/db_connection.py
# TEST_DATABASE_MYSQL = 'samapper_test'
# TEST_DATABASE_SQLITE = '/tmp/sam_test.db'
# class Mocker(object):
# class Session(dict):
# class env(object):
# def __init__(self, *args, **kwargs):
# def __getitem__(self, k):
# def __setitem__(self, k, v):
# def __getattr__(self, name):
# def receiver(*args, **kwargs):
# def __call__(self, *args, **kwargs):
# def clear(self):
# def was_called(self, name, *args, **kwargs):
# def kill(self):
# def __init__(self, mock_input=False, login_active=None, mock_session=False, mock_render=False, lang='en'):
# def __enter__(self):
# def __exit__(self, type, value, traceback):
# def make_timestamp(timestring):
# def unix_timestamp_to_datetime(stamp):
# def get_test_db_connection():
# def setup_datasources(db, sub_id):
# def template_sql(path, *args):
# def setup_network(db, sub_id, ds_id):
# def setup_node_extras(sub_id):
#
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
. Output only the next line. | 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
time5 = now - 60*60*24*7 # 1 week ago
time6 = now - 60*60*24*28 # 4 weeks ago
time7 = now - 31556926 # last year
statA = "uncategorized"
statB = "accepted"
statC = "rejected"
statD = "ignored"
def populate_db_warnings():
entries = [
{"warning_id": 1, "host": host1, "log_time": time1, 'reason': "test1", 'status': statA, "details": cPickle.dumps(details1)},
{"warning_id": 2, "host": host2, "log_time": time1, 'reason': "test1", 'status': statB, "details": cPickle.dumps(details2)},
{"warning_id": 3, "host": host2, "log_time": time2, 'reason': "test1", 'status': statC, "details": cPickle.dumps(details1)},
{"warning_id": 4, "host": host3, "log_time": time2, 'reason': "test1", 'status': statD, "details": cPickle.dumps(details1)},
{"warning_id": 5, "host": host3, "log_time": time3, 'reason': "test1", 'status': statA, "details": cPickle.dumps(details2)},
{"warning_id": 6, "host": host4, "log_time": time3, 'reason': "test1", 'status': statB, "details": cPickle.dumps(details2)},
{"warning_id": 7, "host": host4, "log_time": time4, 'reason': "test1", 'status': statC, "details": cPickle.dumps(details1)},
{"warning_id": 8, "host": host5, "log_time": time4, 'reason': "test1", 'status': statA, "details": cPickle.dumps(details1)},
{"warning_id": 9, "host": host5, "log_time": time5, 'reason': "test1", 'status': statB, "details": cPickle.dumps(details1)},
{"warning_id": 10, "host": host4, "log_time": time5, 'reason': "test1", 'status': statA, "details": cPickle.dumps(details2)},
{"warning_id": 11, "host": host4, "log_time": time6, 'reason': "test1", 'status': statD, "details": cPickle.dumps(details2)},
{"warning_id": 12, "host": host3, "log_time": time6, 'reason': "test1", 'status': statC, "details": cPickle.dumps(details2)},
<|code_end|>
. Use current file imports:
(import pytest
import cPickle
from spec.python import db_connection
from sam import common
from sam.models.security import warnings)
and context including class names, function names, or small code snippets from other files:
# Path: spec/python/db_connection.py
# TEST_DATABASE_MYSQL = 'samapper_test'
# TEST_DATABASE_SQLITE = '/tmp/sam_test.db'
# class Mocker(object):
# class Session(dict):
# class env(object):
# def __init__(self, *args, **kwargs):
# def __getitem__(self, k):
# def __setitem__(self, k, v):
# def __getattr__(self, name):
# def receiver(*args, **kwargs):
# def __call__(self, *args, **kwargs):
# def clear(self):
# def was_called(self, name, *args, **kwargs):
# def kill(self):
# def __init__(self, mock_input=False, login_active=None, mock_session=False, mock_render=False, lang='en'):
# def __enter__(self):
# def __exit__(self, type, value, traceback):
# def make_timestamp(timestring):
# def unix_timestamp_to_datetime(stamp):
# def get_test_db_connection():
# def setup_datasources(db, sub_id):
# def template_sql(path, *args):
# def setup_network(db, sub_id, ds_id):
# def setup_node_extras(sub_id):
. Output only the next line. | {"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.loads(response)
assert timerange == {"max": 1521498300, "min": 1453065600}
web.input = lambda: {'q': 'timerange', 'ds': 'ds{}'.format(ds_empty)}
web.ctx['headers'] = []
p = sam.pages.stats.Stats()
response = p.GET()
timerange = json.loads(response)
now = int(time.mktime(datetime.now().timetuple()))
assert timerange == {"max": now, "min": now}
def test_protocols():
with db_connection.env(mock_input=True, login_active=False, mock_session=True):
web.input = lambda: {'q': 'protocols', 'ds': 'ds{}'.format(ds_full)}
web.ctx['headers'] = []
p = sam.pages.stats.Stats()
response = p.GET()
protocols = json.loads(response)
assert set(protocols) == {u'TCP', u'UDP', u'ICMP'}
web.input = lambda: {'q': 'protocols', 'ds': 'ds{}'.format(ds_empty)}
web.ctx['headers'] = []
p = sam.pages.stats.Stats()
response = p.GET()
<|code_end|>
. Use current file imports:
(from spec.python import db_connection
from sam import common
from sam import constants
from datetime import datetime
import web
import sam.pages.stats
import web
import json
import time)
and context including class names, function names, or small code snippets from other files:
# Path: spec/python/db_connection.py
# TEST_DATABASE_MYSQL = 'samapper_test'
# TEST_DATABASE_SQLITE = '/tmp/sam_test.db'
# class Mocker(object):
# class Session(dict):
# class env(object):
# def __init__(self, *args, **kwargs):
# def __getitem__(self, k):
# def __setitem__(self, k, v):
# def __getattr__(self, name):
# def receiver(*args, **kwargs):
# def __call__(self, *args, **kwargs):
# def clear(self):
# def was_called(self, name, *args, **kwargs):
# def kill(self):
# def __init__(self, mock_input=False, login_active=None, mock_session=False, mock_render=False, lang='en'):
# def __enter__(self):
# def __exit__(self, type, value, traceback):
# def make_timestamp(timestring):
# def unix_timestamp_to_datetime(stamp):
# def get_test_db_connection():
# def setup_datasources(db, sub_id):
# def template_sql(path, *args):
# def setup_network(db, sub_id, ds_id):
# def setup_node_extras(sub_id):
#
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
. Output only the next line. | 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()
timerange = json.loads(response)
assert timerange == {"max": 1521498300, "min": 1453065600}
web.input = lambda: {'q': 'timerange', 'ds': 'ds{}'.format(ds_empty)}
web.ctx['headers'] = []
p = sam.pages.stats.Stats()
response = p.GET()
timerange = json.loads(response)
now = int(time.mktime(datetime.now().timetuple()))
assert timerange == {"max": now, "min": now}
def test_protocols():
with db_connection.env(mock_input=True, login_active=False, mock_session=True):
web.input = lambda: {'q': 'protocols', 'ds': 'ds{}'.format(ds_full)}
web.ctx['headers'] = []
p = sam.pages.stats.Stats()
response = p.GET()
protocols = json.loads(response)
assert set(protocols) == {u'TCP', u'UDP', u'ICMP'}
web.input = lambda: {'q': 'protocols', 'ds': 'ds{}'.format(ds_empty)}
web.ctx['headers'] = []
<|code_end|>
. Use current file imports:
from spec.python import db_connection
from sam import common
from sam import constants
from datetime import datetime
import web
import sam.pages.stats
import web
import json
import time
and context (classes, functions, or code) from other files:
# Path: spec/python/db_connection.py
# TEST_DATABASE_MYSQL = 'samapper_test'
# TEST_DATABASE_SQLITE = '/tmp/sam_test.db'
# class Mocker(object):
# class Session(dict):
# class env(object):
# def __init__(self, *args, **kwargs):
# def __getitem__(self, k):
# def __setitem__(self, k, v):
# def __getattr__(self, name):
# def receiver(*args, **kwargs):
# def __call__(self, *args, **kwargs):
# def clear(self):
# def was_called(self, name, *args, **kwargs):
# def kill(self):
# def __init__(self, mock_input=False, login_active=None, mock_session=False, mock_render=False, lang='en'):
# def __enter__(self):
# def __exit__(self, type, value, traceback):
# def make_timestamp(timestring):
# def unix_timestamp_to_datetime(stamp):
# def get_test_db_connection():
# def setup_datasources(db, sub_id):
# def template_sql(path, *args):
# def setup_network(db, sub_id, ds_id):
# def setup_node_extras(sub_id):
#
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
. Output only the next line. | 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() == "netflow":
collector = netflow_collector.Collector()
collector.run(port=port)
else:
collector = server_collector.Collector()
if parsed['format'] is None:
parsed['format'] = constants.collector['format']
collector.run(port=port, format=parsed['format'])
logger.info('collector shut down.')
return collector
def launch_collector_stream(parsed, args):
logger.info('launching stdin collector')
collector = server_collector.Collector()
if parsed['format'] is None:
parsed['format'] = constants.collector['format']
collector.run_streamreader(sys.stdin, format=parsed['format'])
logger.info('collector shut down.')
return collector
<|code_end|>
. Use current file imports:
(import sys
import os
import getopt
import multiprocessing
import errors
import logging
import traceback
import sam.server_webserver
import server_collector
import server_collector
import server_aggregator
import common
import sam.importers.import_base
import sam.models.subscriptions
import common
import sam.models.subscriptions
import sam.models.security.rule
import integrity
import models.whois
import server_collector
import common
import sam.models.subscriptions
import models.whois
from sam import constants
from web.wsgiserver import CherryPyWSGIServer
from sam.importers import netflow_collector
from sam.models.datasources import Datasources
from sam.preprocess import Preprocessor
from sam.models.datasources import Datasources
from sam.models.settings import Settings
from sam.models.datasources import Datasources
from sam.models.livekeys import LiveKeys)
and context including class names, function names, or small code snippets from other files:
# Path: sam/constants.py
# LDAP = {
# 'connection_string': config.get('LDAP', 'connection_string', default='')
# }
# def enable_local_mode():
# def init_urls():
# def find_url(target):
# def get_navbar(lang):
. Output only the next line. | 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, parent=None, return_=True):
if alias is None:
alias = name
if self.__import_dict.get(alias, None) is not None and return_:
<|code_end|>
, generate the next line using the imports in this file:
import importlib
from .settings import singleton
and context (functions, classes, or occasionally code) from other files:
# Path: E3_Distill_ESRGAN/libs/settings.py
# def singleton(cls):
# instances = {}
#
# def getinstance(*args, **kwargs):
# distill_config = kwargs.get("use_student_settings", "")
# key = cls.__name__
# if distill_config:
# key = "%s_student" % (cls.__name__)
# if key not in instances:
# instances[key] = cls(*args, **kwargs)
# return instances[key]
# return getinstance
. Output only the next line. | 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 ibatch in range(len(Xtrain) // 2 // batch_size):
<|code_end|>
using the current file's imports:
import DeepFried2 as df
import numpy as np
from examples.utils import make_progressbar
and any relevant context from other files:
# Path: examples/utils.py
# def make_progressbar(prefix, data_size):
# widgets = [prefix, ', processed ', _pb.Counter(), ' of ', str(data_size),
# ' (', _pb.Percentage(), ')', ' ', _pb.Bar(), ' ', _pb.ETA()]
# return _pb.ProgressBar(maxval=data_size, widgets=widgets)
. Output only the next line. | 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)
imgdir = 'iccv09Data/images/'
with _taropen(fname, 'r') as f:
f.extractall(where)
ids = [_p.basename(n)[:-4] for n in f.getnames() if n.startswith(imgdir)]
X = [imread(_p.join(where, imgdir, i) + '.jpg') for i in ids]
y = [_np.loadtxt(_p.join(where, 'iccv09Data/labels', i) + '.regions.txt', dtype=_np.int32) for i in ids]
# I personally don't believe in the other label types.
le = _np.array(['sky', 'tree', 'road', 'grass', 'water', 'building', 'mountain', 'foreground', 'object'])
try:
<|code_end|>
. Use current file imports:
(import DeepFried2 as df
import numpy as _np
import os.path as _p
from .images import imread
from tarfile import open as _taropen
from sklearn.preprocessing import LabelEncoder)
and context including class names, function names, or small code snippets from other files:
# Path: DeepFried2/datasets/images.py
# def imread(fname, dtype=_np.float32):
# im = _cv2.imread(fname, flags=_cv2.IMREAD_UNCHANGED)
# if im is None:
# raise IOError("Couldn't open image file {}".format(fname))
# # Convert BGR to RGB. OpenCV is weird like that.
# if im.ndim == 3 and im.shape[-1] == 3:
# im = im[:,:,::-1]
# return im.astype(dtype)
. Output only the next line. | 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', '--model', choices=['vgg16', 'vgg19'], default='vgg19')
parser.add_argument('-r', '--raw', action='store_true', help="Do not subtract the trainset's channel-mean")
parser.add_argument('image', nargs='?')
args = parser.parse_args()
<|code_end|>
, predict the immediate next line with the help of imports:
import sys, os, json, argparse, collections
import numpy as np
import DeepFried2 as df
from DeepFried2.datasets.images import imread, imresizecrop
from examples.utils import printnow
and context (classes, functions, sometimes code) from other files:
# Path: DeepFried2/datasets/images.py
# def imread(fname, dtype=_np.float32):
# im = _cv2.imread(fname, flags=_cv2.IMREAD_UNCHANGED)
# if im is None:
# raise IOError("Couldn't open image file {}".format(fname))
# # Convert BGR to RGB. OpenCV is weird like that.
# if im.ndim == 3 and im.shape[-1] == 3:
# im = im[:,:,::-1]
# return im.astype(dtype)
#
# def imresizecrop(img, size):
# assert not isinstance(size, tuple), "For now, `size` needs to be a single integer, i.e. it's being squared."
#
# # First, resize the smallest side to `size`.
# img = imresize(img, h=img.shape[0]*size//min(img.shape[:2]),
# w=img.shape[1]*size//min(img.shape[:2]))
#
# # Then, crop-out the central part of the largest side.
# return img[(img.shape[0]-size)//2:img.shape[0]-(img.shape[0]-size)//2,
# (img.shape[1]-size)//2:img.shape[1]-(img.shape[1]-size)//2,
# :]
#
# Path: examples/utils.py
# def printnow(fmt, *a, **kw):
# _sys.stdout.write(fmt.format(*a, **kw))
# _sys.stdout.flush()
. Output only the next line. | 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 = np.array([img])
minibatch224 = np.array([img224])
printnow("Done\n")
# And send them through the networks.
printnow("Regular model:\n")
preds = np.array(model.forward(minibatch224))
printnow(" - shape of predictions: {}\n", preds.shape)
top1 = np.argmax(preds[0])
printnow(" - top-1 prediction: {}\n", top1)
top5 = np.argsort(preds[0])[-5:][::-1]
printnow(" - top-5 prediction: {}\n", top5)
printnow("Fully-conv model:\n")
predsFC = np.array(modelFC.forward(minibatch))
top1FC = np.argmax(predsFC[0], axis=0)
printnow(" - shape of predictions: {}\n", predsFC.shape)
printnow(" - top-1 of average: {}\n", np.argmax(np.mean(predsFC, axis=(2,3))[0]))
printnow(" - top-1 map:\n{}\n", top1FC)
# Now, we want to print the relevant words that occured as predictions.
<|code_end|>
, determine the next line of code. You have imports:
import sys, os, json, argparse, collections
import numpy as np
import DeepFried2 as df
from DeepFried2.datasets.images import imread, imresizecrop
from examples.utils import printnow
and context (class names, function names, or code) available:
# Path: DeepFried2/datasets/images.py
# def imread(fname, dtype=_np.float32):
# im = _cv2.imread(fname, flags=_cv2.IMREAD_UNCHANGED)
# if im is None:
# raise IOError("Couldn't open image file {}".format(fname))
# # Convert BGR to RGB. OpenCV is weird like that.
# if im.ndim == 3 and im.shape[-1] == 3:
# im = im[:,:,::-1]
# return im.astype(dtype)
#
# def imresizecrop(img, size):
# assert not isinstance(size, tuple), "For now, `size` needs to be a single integer, i.e. it's being squared."
#
# # First, resize the smallest side to `size`.
# img = imresize(img, h=img.shape[0]*size//min(img.shape[:2]),
# w=img.shape[1]*size//min(img.shape[:2]))
#
# # Then, crop-out the central part of the largest side.
# return img[(img.shape[0]-size)//2:img.shape[0]-(img.shape[0]-size)//2,
# (img.shape[1]-size)//2:img.shape[1]-(img.shape[1]-size)//2,
# :]
#
# Path: examples/utils.py
# def printnow(fmt, *a, **kw):
# _sys.stdout.write(fmt.format(*a, **kw))
# _sys.stdout.flush()
. Output only the next line. | 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):
# Note: numpy correctly handles the size of the last minibatch.
<|code_end|>
, predict the next line using imports from the current file:
import DeepFried2 as df
import numpy as np
from examples.utils import make_progressbar
and context including class names, function names, and sometimes code from other files:
# Path: examples/utils.py
# def make_progressbar(prefix, data_size):
# widgets = [prefix, ', processed ', _pb.Counter(), ' of ', str(data_size),
# ' (', _pb.Percentage(), ')', ' ', _pb.Bar(), ' ', _pb.ETA()]
# return _pb.ProgressBar(maxval=data_size, widgets=widgets)
. Output only the next line. | 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://github.com/Lasagne/Lasagne/blob/63d44a0d/lasagne/layers/dnn.py#L299
# 2: https://github.com/soumith/cudnn.torch/blob/840f0228/SpatialConvolution.lua#L83
# 3: https://github.com/vlfeat/matconvnet/blob/b7dd9c96/matlab/src/bits/impl/nnconv_cudnn.cu#L133
# 4: https://github.com/BVLC/caffe/blob/50ab52cb/include/caffe/util/cudnn.hpp#L104
df.Module.__init__(self)
# Catch a probably common bug while we transition the API.
assert isinstance(filter_size, (list, tuple)), "New conv API: filter_size needs to be a tuple!"
self.nchan_in = nchan_in
self.nchan_out = nchan_out
self.filter_size = filter_size
self.mode = mode
self.stride = expand(stride, len(filter_size), 'stride')
self.border = expand(border, len(filter_size), 'border')
# 'same' is a (common) shortcut for "zero-padding so that outshape == inshape".
if self.border == 'same':
assert all(k % 2 == 1 for k in self.filter_size), "'same' convolution only supports odd filter sizes."
self.border = tuple( (k - 1)//2 for k in self.filter_size )
w_shape = (nchan_out, nchan_in) + self.filter_size
<|code_end|>
. Write the next line using the current file imports:
import DeepFried2 as df
import numpy as np
from DeepFried2.utils import expand
from theano.sandbox.cuda import dnn
and context from other files:
# Path: DeepFried2/utils.py
# def expand(tup, ndim, name=None, expand_nonnum=False):
# if isinstance(tup, (tuple, list)) and len(tup) == ndim:
# return tup
#
# if isinstance(tup, _Number) or expand_nonnum:
# return (tup,) * ndim
#
# if not expand_nonnum:
# return tup
#
# raise ValueError("Bad number of dimensions{}: is {} but should be {}.".format((" for " + name) if name else "", len(tup), ndim))
, which may include functions, classes, or code. Output only the next line. | 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 DeepFried2 as df
import numpy as _np
from DeepFried2.utils import tensors_for_ndarrays, flatten
and context (class names, function names, or code) available:
# Path: DeepFried2/utils.py
# def tensors_for_ndarrays(datas, basename):
# #if isinstance(datas, _np.ndarray):
# try:
# dtype, ndim = datas.dtype, datas.ndim
# except AttributeError:
# pass # Not an array-like
# else:
# return make_tensor(dtype, ndim, basename)
#
# if isinstance(datas, (list, tuple)):
# return [tensors_for_ndarrays(data, "{}_{}".format(basename, i)) for i, data in enumerate(datas)]
# # Could potentially make it "any iterable" by removing above check.
# # But would need to guarantee we never iterate over it twice, which is harder!
# raise TypeError("I only understand lists or tuples of numpy arrays! (possibly nested)")
#
# def flatten(what, types=(list, tuple), none_to_empty=False):
# if what is None and none_to_empty:
# return []
#
# if not isinstance(what, types):
# return [what]
#
# # NOTE: I actually timed that this is faster than the comprehension,
# # even though it probably doesn't matter :)
# # 350us vs 250us
# ret = []
# for sub in what:
# ret += flatten(sub, types=types, none_to_empty=none_to_empty)
# return ret
. Output only the next line. | 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(self, symb_input):
raise NotImplementedError("`{}` needs to implement `symb_forward` method.".format(df.utils.typename(self)))
def __call__(self, symb_input):
# Keep track of the symbolic inputs/outputs for things such as `Backward` layer.
self._last_symb_inp[self._mode] = symb_input
self._last_symb_out[self._mode] = self.symb_forward(symb_input)
return self._last_symb_out[self._mode]
def forward(self, data):
if self._mode not in self._fn_forward:
symb_in = tensors_for_ndarrays(data, 'X')
symb_out = self(symb_in)
extra_out = self.get_extra_outputs()
extra_up = self.get_extra_updates()
fn = self._fn_forward[self._mode] = df.th.function(
inputs=flatten(symb_in),
outputs=flatten(symb_out) + flatten(extra_out),
updates=flatten(extra_up, types=list),
<|code_end|>
, generate the next line using the imports in this file:
import DeepFried2 as df
import numpy as _np
from DeepFried2.utils import tensors_for_ndarrays, flatten
and context (functions, classes, or occasionally code) from other files:
# Path: DeepFried2/utils.py
# def tensors_for_ndarrays(datas, basename):
# #if isinstance(datas, _np.ndarray):
# try:
# dtype, ndim = datas.dtype, datas.ndim
# except AttributeError:
# pass # Not an array-like
# else:
# return make_tensor(dtype, ndim, basename)
#
# if isinstance(datas, (list, tuple)):
# return [tensors_for_ndarrays(data, "{}_{}".format(basename, i)) for i, data in enumerate(datas)]
# # Could potentially make it "any iterable" by removing above check.
# # But would need to guarantee we never iterate over it twice, which is harder!
# raise TypeError("I only understand lists or tuples of numpy arrays! (possibly nested)")
#
# def flatten(what, types=(list, tuple), none_to_empty=False):
# if what is None and none_to_empty:
# return []
#
# if not isinstance(what, types):
# return [what]
#
# # NOTE: I actually timed that this is faster than the comprehension,
# # even though it probably doesn't matter :)
# # 350us vs 250us
# ret = []
# for sub in what:
# ret += flatten(sub, types=types, none_to_empty=none_to_empty)
# return ret
. Output only the next line. | ) |
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(border, len(filter_size), 'border')
if len(self.filter_size) == 3 and any(s != 1 for s in self.stride):
raise NotImplementedError('stride != 1 is not implemented for 3D convolutions')
if len(self.filter_size) == 3 and imshape is not None:
raise NotImplementedError('imshape is not implemented for 3D convolutions')
if len(self.filter_size) == 3 and mode != 'conv':
raise NotImplementedError('mode="cross" is not implemented for 3D convolutions')
if mode not in ('conv', 'cross'):
raise NotImplementedError('Only "conv" and "cross" modes are implemented')
self.w_shape = (nchan_out, nchan_in) + self.filter_size
w_fan = (nchan_in*np.prod(self.filter_size), nchan_out*np.prod(self.filter_size))
w_name = ('Wconv_{},{}@{}' + 'x{}'*(len(self.w_shape) - 3)).format(*self.w_shape)
self.W = self._addparam(self.w_shape, init, fan=w_fan, name=w_name)
self.b = self._addparam_optional(nchan_out, bias, decay=False, name='bconv_{}'.format(nchan_out))
def symb_forward(self, symb_input):
mode = self.border
input_shape = symb_input.shape
<|code_end|>
, predict the immediate next line with the help of imports:
import DeepFried2 as df
import numpy as np
from DeepFried2.utils import expand
from theano.tensor.nnet import conv3d2d
and context (classes, functions, sometimes code) from other files:
# Path: DeepFried2/utils.py
# def expand(tup, ndim, name=None, expand_nonnum=False):
# if isinstance(tup, (tuple, list)) and len(tup) == ndim:
# return tup
#
# if isinstance(tup, _Number) or expand_nonnum:
# return (tup,) * ndim
#
# if not expand_nonnum:
# return tup
#
# raise ValueError("Bad number of dimensions{}: is {} but should be {}.".format((" for " + name) if name else "", len(tup), ndim))
. Output only the next line. | 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
(Xtrain, ytrain), (Xval, yval), (Xtest, ytest) = df.datasets.mnist.data()
criterion = df.ClassNLLCriterion()
def run(optim):
progress = make_progressbar('Training with ' + str(optim), 5)
progress.start()
model = net()
model.training()
for epoch in range(5):
train(Xtrain, ytrain, model, optim, criterion, batch_size, 'train')
<|code_end|>
, predict the immediate next line with the help of imports:
import DeepFried2 as df
from examples.utils import make_progressbar
from train import train
from test import test
from model import net, lenet2
and context (classes, functions, sometimes code) from other files:
# Path: examples/utils.py
# def make_progressbar(prefix, data_size):
# widgets = [prefix, ', processed ', _pb.Counter(), ' of ', str(data_size),
# ' (', _pb.Percentage(), ')', ' ', _pb.Bar(), ' ', _pb.ETA()]
# return _pb.ProgressBar(maxval=data_size, widgets=widgets)
. Output only the next line. | 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 samples, if necessary.
if cost.ndim != 0:
# The default is to average the batch, regardless of the loss values.
# But we also allow to average only over non-zero losses, for some
# applications. Especially in margin-losses, this may make sense as
# it effectively weights the "rare non-zero" losses higher.
if self._nonzero_averaging:
cost = df.T.mean(cost)
else:
nnz = df.th.gradient.disconnected_grad(cost.nonzero_values().shape[0])
cost = df.T.sum(cost)/(1e-8 + nnz)
if symb_weights is not None:
# Need a very small eps to avoid 0/0 when all weights are 0!
cost = cost / (1e-8 + df.T.mean(symb_weights))
if with_penalties:
for w, p in self.penalties:
cost = cost + w*p.symb_forward()
return cost
<|code_end|>
. Use current file imports:
(import DeepFried2 as df
from DeepFried2.utils import tensors_for_ndarrays, flatten)
and context including class names, function names, or small code snippets from other files:
# Path: DeepFried2/utils.py
# def tensors_for_ndarrays(datas, basename):
# #if isinstance(datas, _np.ndarray):
# try:
# dtype, ndim = datas.dtype, datas.ndim
# except AttributeError:
# pass # Not an array-like
# else:
# return make_tensor(dtype, ndim, basename)
#
# if isinstance(datas, (list, tuple)):
# return [tensors_for_ndarrays(data, "{}_{}".format(basename, i)) for i, data in enumerate(datas)]
# # Could potentially make it "any iterable" by removing above check.
# # But would need to guarantee we never iterate over it twice, which is harder!
# raise TypeError("I only understand lists or tuples of numpy arrays! (possibly nested)")
#
# def flatten(what, types=(list, tuple), none_to_empty=False):
# if what is None and none_to_empty:
# return []
#
# if not isinstance(what, types):
# return [what]
#
# # NOTE: I actually timed that this is faster than the comprehension,
# # even though it probably doesn't matter :)
# # 350us vs 250us
# ret = []
# for sub in what:
# ret += flatten(sub, types=types, none_to_empty=none_to_empty)
# return ret
. Output only the next line. | 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(self, symb_input, symb_target):
# A classic mistake, at least for myself.
assert symb_target.ndim == symb_input.ndim, "The targets of `{}` should have the same dimensionality as the net's output. You likely want to do something like `tgt[:,None]`.".format(df.utils.typename(self))
def symb_forward(self, symb_input, symb_target):
raise NotImplementedError("`{}` needs to implement `symb_forward` method.".format(df.utils.typename(self)))
# TODO: Might actually want the weights to be shared variables so we can change their values on-the-fly!
def add_penalty(self, weight_or_pen, pen=None):
if pen is None:
weight, pen = 1.0, weight_or_pen
else:
weight, pen = weight_or_pen, pen
<|code_end|>
, predict the next line using imports from the current file:
import DeepFried2 as df
from DeepFried2.utils import tensors_for_ndarrays, flatten
and context including class names, function names, and sometimes code from other files:
# Path: DeepFried2/utils.py
# def tensors_for_ndarrays(datas, basename):
# #if isinstance(datas, _np.ndarray):
# try:
# dtype, ndim = datas.dtype, datas.ndim
# except AttributeError:
# pass # Not an array-like
# else:
# return make_tensor(dtype, ndim, basename)
#
# if isinstance(datas, (list, tuple)):
# return [tensors_for_ndarrays(data, "{}_{}".format(basename, i)) for i, data in enumerate(datas)]
# # Could potentially make it "any iterable" by removing above check.
# # But would need to guarantee we never iterate over it twice, which is harder!
# raise TypeError("I only understand lists or tuples of numpy arrays! (possibly nested)")
#
# def flatten(what, types=(list, tuple), none_to_empty=False):
# if what is None and none_to_empty:
# return []
#
# if not isinstance(what, types):
# return [what]
#
# # NOTE: I actually timed that this is faster than the comprehension,
# # even though it probably doesn't matter :)
# # 350us vs 250us
# ret = []
# for sub in what:
# ret += flatten(sub, types=types, none_to_empty=none_to_empty)
# return ret
. Output only the next line. | 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 user.password_verify(password):
return user.groups
return None
def includeme(config):
session_factory = SignedCookieSessionFactory(random_passphrase())
<|code_end|>
with the help of current file imports:
from random import choice
from pyramid.authentication import AuthTktAuthenticationPolicy
from pyramid.authentication import BasicAuthAuthenticationPolicy
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.session import SignedCookieSessionFactory
from papaye.authentification import RouteNameAuthPolicy
from papaye.models import User
and context from other files:
# Path: papaye/authentification.py
# class RouteNameAuthPolicy(AuthTktAuthenticationPolicy):
#
# def __init__(self, **policies):
# self.policies = policies
#
# def get_policy(self, request):
# if request.matched_route is None:
# return self.policies.get('default')
# else:
# route_name = request.matched_route.name
# return self.policies.get(route_name, self.policies.get('default'))
#
# def authenticated_userid(self, request):
# return self.get_policy(request).authenticated_userid(request)
#
# def unauthenticated_userid(self, request):
# return self.get_policy(request).unauthenticated_userid(request)
#
# def effective_principals(self, request):
# return self.get_policy(request).effective_principals(request)
#
# def remember(self, request, principal, **kw):
# return self.get_policy(request).remember(request, principal, **kw)
#
# def forget(self, request):
# return self.get_policy(request).forget(request)
#
# Path: papaye/models.py
# class User(Model):
#
# def __init__(self, username, password, **kwargs):
# self.username = username
# self.password = self.hash_password(password)
# self.groups = kwargs.get('groups', [])
#
# def hash_password(self, password):
# return hashlib.sha512(password.encode('utf-8')).hexdigest()
#
# def password_verify(self, clear_password):
# return self.hash_password(clear_password) == self.password
#
# def __repr__(self):
# return '<{}.{} "{}" at {}>'.format(self.__module__, self.__class__.__name__, self.username, id(self))
#
# @classmethod
# def by_username(cls, username, request):
# """Return user instance by username"""
# root = user_root_factory(request)
# if username in [user.username for user in root]:
# return root[username]
# return None
, which may contain function names, class names, or code. Output only the next line. | 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_verify(password):
return user.groups
return None
def includeme(config):
session_factory = SignedCookieSessionFactory(random_passphrase())
authtkt_policy = AuthTktAuthenticationPolicy(
random_passphrase(), hashalg='sha512',
)
authn_policy = RouteNameAuthPolicy(
default=authtkt_policy,
simple=BasicAuthAuthenticationPolicy(check=auth_check_func),
)
authz_policy = ACLAuthorizationPolicy()
config.set_authentication_policy(authn_policy)
<|code_end|>
. Use current file imports:
from random import choice
from pyramid.authentication import AuthTktAuthenticationPolicy
from pyramid.authentication import BasicAuthAuthenticationPolicy
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.session import SignedCookieSessionFactory
from papaye.authentification import RouteNameAuthPolicy
from papaye.models import User
and context (classes, functions, or code) from other files:
# Path: papaye/authentification.py
# class RouteNameAuthPolicy(AuthTktAuthenticationPolicy):
#
# def __init__(self, **policies):
# self.policies = policies
#
# def get_policy(self, request):
# if request.matched_route is None:
# return self.policies.get('default')
# else:
# route_name = request.matched_route.name
# return self.policies.get(route_name, self.policies.get('default'))
#
# def authenticated_userid(self, request):
# return self.get_policy(request).authenticated_userid(request)
#
# def unauthenticated_userid(self, request):
# return self.get_policy(request).unauthenticated_userid(request)
#
# def effective_principals(self, request):
# return self.get_policy(request).effective_principals(request)
#
# def remember(self, request, principal, **kw):
# return self.get_policy(request).remember(request, principal, **kw)
#
# def forget(self, request):
# return self.get_policy(request).forget(request)
#
# Path: papaye/models.py
# class User(Model):
#
# def __init__(self, username, password, **kwargs):
# self.username = username
# self.password = self.hash_password(password)
# self.groups = kwargs.get('groups', [])
#
# def hash_password(self, password):
# return hashlib.sha512(password.encode('utf-8')).hexdigest()
#
# def password_verify(self, clear_password):
# return self.hash_password(clear_password) == self.password
#
# def __repr__(self):
# return '<{}.{} "{}" at {}>'.format(self.__module__, self.__class__.__name__, self.username, id(self))
#
# @classmethod
# def by_username(cls, username, request):
# """Return user instance by username"""
# root = user_root_factory(request)
# if username in [user.username for user in root]:
# return root[username]
# return None
. Output only the next line. | 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
@classmethod
def by_packagename(cls, package, request):
root = repository_root_factory(request)
if package not in root:
return None
return list(root[package].releases.values())
class ReleaseFile(Persistent):
def __init__(self, filename, content, md5_digest=None):
self.filename = self.__name__ = filename
self.md5_digest = md5_digest
self.set_content(content)
self.upload_date = datetime.datetime.now(tz=utc)
def get_content_type(self, content):
buf = io.BytesIO(content)
with magic.Magic(flags=magic.MAGIC_MIME_TYPE) as m:
self.content_type = m.id_buffer(buf.read())
<|code_end|>
. Write the next line using the current file imports:
import datetime
import hashlib
import io
import json
import logging
import magic
import pkg_resources
import requests
from BTrees.OOBTree import OOBTree
from ZODB.blob import Blob
from beaker.cache import cache_region
from persistent import Persistent
from pkg_resources import parse_version
from pyramid.security import Allow, ALL_PERMISSIONS, Everyone
from pyramid.threadlocal import get_current_registry
from pyramid_zodbconn import db_from_uri
from repoze.evolution import ZODBEvolutionManager
from requests.exceptions import ConnectionError
from pytz import utc
from papaye.factories.root import user_root_factory, repository_root_factory, APP_ROOT_NAME
from papaye.schemas import Metadata
and context from other files:
# Path: papaye/factories/root.py
# def user_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['user']
#
# def repository_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['repository']
#
# APP_ROOT_NAME = '{}_root'.format(APP_NAME)
#
# Path: papaye/schemas.py
# class Metadata(colander.MappingSchema):
# version = colander.SchemaNode(String(), missing=None)
# author = colander.SchemaNode(String(), missing=None)
# author_email = colander.SchemaNode(String(), missing=None)
# home_page = colander.SchemaNode(String(), missing=None)
# keywords = colander.SchemaNode(Tags(), default=[])
# license = colander.SchemaNode(String(), missing=None)
# summary = colander.SchemaNode(String(), missing=None)
# maintainer = colander.SchemaNode(String(), missing=None)
# maintainer_email = colander.SchemaNode(String(), missing=None)
# description = colander.SchemaNode(Description(), default=None)
# platform = colander.SchemaNode(String(), missing=None)
# classifiers = colander.SchemaNode(Classifiers(), default=[])
# name = colander.SchemaNode(String(), missing=None)
, which may include functions, classes, or code. Output only the next line. | 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__(self, state):
if state is None:
state = {}
self.__dict__ = state
class Root(SnapshotModel, OOBTree):
__name__ = __parent__ = None
def __acl__(self):
acl = [
(Allow, 'group:installer', 'install'),
(Allow, 'group:admin', ALL_PERMISSIONS)
]
<|code_end|>
, determine the next line of code. You have imports:
import datetime
import hashlib
import io
import json
import logging
import magic
import pkg_resources
import requests
from BTrees.OOBTree import OOBTree
from ZODB.blob import Blob
from beaker.cache import cache_region
from persistent import Persistent
from pkg_resources import parse_version
from pyramid.security import Allow, ALL_PERMISSIONS, Everyone
from pyramid.threadlocal import get_current_registry
from pyramid_zodbconn import db_from_uri
from repoze.evolution import ZODBEvolutionManager
from requests.exceptions import ConnectionError
from pytz import utc
from papaye.factories.root import user_root_factory, repository_root_factory, APP_ROOT_NAME
from papaye.schemas import Metadata
and context (class names, function names, or code) available:
# Path: papaye/factories/root.py
# def user_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['user']
#
# def repository_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['repository']
#
# APP_ROOT_NAME = '{}_root'.format(APP_NAME)
#
# Path: papaye/schemas.py
# class Metadata(colander.MappingSchema):
# version = colander.SchemaNode(String(), missing=None)
# author = colander.SchemaNode(String(), missing=None)
# author_email = colander.SchemaNode(String(), missing=None)
# home_page = colander.SchemaNode(String(), missing=None)
# keywords = colander.SchemaNode(Tags(), default=[])
# license = colander.SchemaNode(String(), missing=None)
# summary = colander.SchemaNode(String(), missing=None)
# maintainer = colander.SchemaNode(String(), missing=None)
# maintainer_email = colander.SchemaNode(String(), missing=None)
# description = colander.SchemaNode(Description(), default=None)
# platform = colander.SchemaNode(String(), missing=None)
# classifiers = colander.SchemaNode(Classifiers(), default=[])
# name = colander.SchemaNode(String(), missing=None)
. Output only the next line. | 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_key(key)
self.releases[key] = value
self.releases[key].__parent__ = self
@classmethod
@cache_region('pypi', 'get_last_remote_filename')
def get_last_remote_version(cls, proxy, package_name):
logger.debug('Not in cache')
if not proxy:
return None
try:
result = requests.get('http://pypi.python.org/pypi/{}/json'.format(package_name))
if not result.status_code == 200:
return None
result = json.loads(result.content.decode('utf-8'))
return result['info']['version']
except ConnectionError:
pass
return None
def repository_is_up_to_date(self, last_remote_release):
<|code_end|>
with the help of current file imports:
import datetime
import hashlib
import io
import json
import logging
import magic
import pkg_resources
import requests
from BTrees.OOBTree import OOBTree
from ZODB.blob import Blob
from beaker.cache import cache_region
from persistent import Persistent
from pkg_resources import parse_version
from pyramid.security import Allow, ALL_PERMISSIONS, Everyone
from pyramid.threadlocal import get_current_registry
from pyramid_zodbconn import db_from_uri
from repoze.evolution import ZODBEvolutionManager
from requests.exceptions import ConnectionError
from pytz import utc
from papaye.factories.root import user_root_factory, repository_root_factory, APP_ROOT_NAME
from papaye.schemas import Metadata
and context from other files:
# Path: papaye/factories/root.py
# def user_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['user']
#
# def repository_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['repository']
#
# APP_ROOT_NAME = '{}_root'.format(APP_NAME)
#
# Path: papaye/schemas.py
# class Metadata(colander.MappingSchema):
# version = colander.SchemaNode(String(), missing=None)
# author = colander.SchemaNode(String(), missing=None)
# author_email = colander.SchemaNode(String(), missing=None)
# home_page = colander.SchemaNode(String(), missing=None)
# keywords = colander.SchemaNode(Tags(), default=[])
# license = colander.SchemaNode(String(), missing=None)
# summary = colander.SchemaNode(String(), missing=None)
# maintainer = colander.SchemaNode(String(), missing=None)
# maintainer_email = colander.SchemaNode(String(), missing=None)
# description = colander.SchemaNode(Description(), default=None)
# platform = colander.SchemaNode(String(), missing=None)
# classifiers = colander.SchemaNode(Classifiers(), default=[])
# name = colander.SchemaNode(String(), missing=None)
, which may contain function names, class names, or code. Output only the next line. | 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, state):
if state is None:
state = {}
self.__dict__ = state
class Root(SnapshotModel, OOBTree):
__name__ = __parent__ = None
def __acl__(self):
acl = [
(Allow, 'group:installer', 'install'),
(Allow, 'group:admin', ALL_PERMISSIONS)
]
registry = get_current_registry()
<|code_end|>
, determine the next line of code. You have imports:
import datetime
import hashlib
import io
import json
import logging
import magic
import pkg_resources
import requests
from BTrees.OOBTree import OOBTree
from ZODB.blob import Blob
from beaker.cache import cache_region
from persistent import Persistent
from pkg_resources import parse_version
from pyramid.security import Allow, ALL_PERMISSIONS, Everyone
from pyramid.threadlocal import get_current_registry
from pyramid_zodbconn import db_from_uri
from repoze.evolution import ZODBEvolutionManager
from requests.exceptions import ConnectionError
from pytz import utc
from papaye.factories.root import user_root_factory, repository_root_factory, APP_ROOT_NAME
from papaye.schemas import Metadata
and context (class names, function names, or code) available:
# Path: papaye/factories/root.py
# def user_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['user']
#
# def repository_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['repository']
#
# APP_ROOT_NAME = '{}_root'.format(APP_NAME)
#
# Path: papaye/schemas.py
# class Metadata(colander.MappingSchema):
# version = colander.SchemaNode(String(), missing=None)
# author = colander.SchemaNode(String(), missing=None)
# author_email = colander.SchemaNode(String(), missing=None)
# home_page = colander.SchemaNode(String(), missing=None)
# keywords = colander.SchemaNode(Tags(), default=[])
# license = colander.SchemaNode(String(), missing=None)
# summary = colander.SchemaNode(String(), missing=None)
# maintainer = colander.SchemaNode(String(), missing=None)
# maintainer_email = colander.SchemaNode(String(), missing=None)
# description = colander.SchemaNode(Description(), default=None)
# platform = colander.SchemaNode(String(), missing=None)
# classifiers = colander.SchemaNode(Classifiers(), default=[])
# name = colander.SchemaNode(String(), missing=None)
. Output only the next line. | 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.exists(tmpdir.strpath):
shutil.rmtree(tmpdir.strpath)
request.addfinalizer(clean_tmp_dir)
return tmpdir.strpath
@pytest.fixture
def tmp_repo_dir(tmpdir):
@contextlib.contextmanager
def tmp_dir():
yield tmpdir.strpath
if os.path.exists(tmpdir.strpath):
shutil.rmtree(tmpdir.strpath)
return tmp_dir
@pytest.fixture
def routes(env, packages_directory):
<|code_end|>
. Write the next line using the current file imports:
import contextlib
import os
import pytest
import shutil
from pyramid import testing
from pyramid.interfaces import ISettings
from papaye.tests.tools import set_database_connection, disable_cache
and context from other files:
# Path: papaye/tests/tools.py
# def set_database_connection(request, blob_dir=None, config=None):
# if not blob_dir:
# blob_dir = tempfile.mkdtemp('blobs')
# conn = get_db_connection(blob_dir)
# request._primary_zodb_conn = conn
# if config:
# import transaction
# conn.root()['repository'] = {}
# conn.root()['user'] = {}
# transaction.commit()
# config.registry._zodb_databases = {'': conn._db}
# return blob_dir
#
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
, which may include functions, classes, or code. Output only the next line. | 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',
}
env['settings'].update(settings)
env['config'].include('pyramid_zodbconn')
def clean_tmp_dir():
if os.path.exists(tmpdir.strpath):
shutil.rmtree(tmpdir.strpath)
request.addfinalizer(clean_tmp_dir)
return tmpdir.strpath
@pytest.fixture
def tmp_repo_dir(tmpdir):
@contextlib.contextmanager
def tmp_dir():
yield tmpdir.strpath
if os.path.exists(tmpdir.strpath):
<|code_end|>
. Write the next line using the current file imports:
import contextlib
import os
import pytest
import shutil
from pyramid import testing
from pyramid.interfaces import ISettings
from papaye.tests.tools import set_database_connection, disable_cache
and context from other files:
# Path: papaye/tests/tools.py
# def set_database_connection(request, blob_dir=None, config=None):
# if not blob_dir:
# blob_dir = tempfile.mkdtemp('blobs')
# conn = get_db_connection(blob_dir)
# request._primary_zodb_conn = conn
# if config:
# import transaction
# conn.root()['repository'] = {}
# conn.root()['user'] = {}
# transaction.commit()
# config.registry._zodb_databases = {'': conn._db}
# return blob_dir
#
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
, which may include functions, classes, or code. Output only the next line. | 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',
release__package__name='pyramid',
)
release_file2 = factories.ReleaseFileFactory(
release__version='1.5',
filename='pyramid-1.5.whl',
md5_digest='12345',
release__package__name='pyramid',
)
package1 = release_file1.release.package
package2 = release_file2.release.package
# When
result = smart_merge(package1, package2)
# Then
assert isinstance(result, Package)
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')
<|code_end|>
, predict the next line using imports from the current file:
import unittest
from mock import patch
from pyramid.threadlocal import get_current_request
from requests.exceptions import ConnectionError
from papaye.factories import models as factories
from papaye.tests.tools import FakeGRequestResponse
from papaye.tests.tools import mock_proxy_response
from papaye.proxy import PyPiProxy
from papaye.proxy import PyPiProxy
from papaye.proxy import PyPiProxy
from papaye.proxy import PyPiProxy
from papaye.factories.root import repository_root_factory
from papaye.models import Package, Release, ReleaseFile
from papaye.proxy import smart_merge
from papaye.models import Package, Release, ReleaseFile
from papaye.proxy import smart_merge
from papaye.factories.root import repository_root_factory
from papaye.models import Package, Release, ReleaseFile
from papaye.proxy import smart_merge
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import smart_merge
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import smart_merge
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import smart_merge
from papaye.models import Root
from papaye.proxy import PyPiProxy
from papaye.models import Root
from papaye.proxy import PyPiProxy
from papaye.models import Root
from papaye.proxy import PyPiProxy
from papaye.proxy import PyPiProxy
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import PyPiProxy
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import PyPiProxy
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import PyPiProxy
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import PyPiProxy
from papaye.proxy import clone
from papaye.models import Package, Release, ReleaseFile
from papaye.proxy import clone
from papaye.models import Package, Release, ReleaseFile
and context including class names, function names, and sometimes code from other files:
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
#
# Path: papaye/tests/tools.py
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# Path: papaye/tests/tools.py
# def mock_proxy_response(mock, response=None, side_effect=False):
# if response is None:
# with open(get_resource('pyramid.json'), 'rb') as pyramid_json:
# pypi_response = FakeGRequestResponse(200, pyramid_json.read())
# mock.return_value = pypi_response
# else:
# attr = 'side_effect' if side_effect else 'return_value'
# setattr(mock, attr, response)
. Output only the next line. | 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/pypi/pyramid/json"
proxy = PyPiProxy()
# When
result = proxy.get_remote_package_name(url)
# Then
self.assertIsNone(result)
def test_smart_merge_with_other_release(self):
# Given
release1 = factories.ReleaseFactory(
version='1.5',
filename='pyramid-1.5.tar.gz',
md5_digest='12345',
package__name='pyramid',
)
release2 = factories.ReleaseFactory(
version='1.6',
filename='pyramid-1.6.tar.gz',
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import unittest
from mock import patch
from pyramid.threadlocal import get_current_request
from requests.exceptions import ConnectionError
from papaye.factories import models as factories
from papaye.tests.tools import FakeGRequestResponse
from papaye.tests.tools import mock_proxy_response
from papaye.proxy import PyPiProxy
from papaye.proxy import PyPiProxy
from papaye.proxy import PyPiProxy
from papaye.proxy import PyPiProxy
from papaye.factories.root import repository_root_factory
from papaye.models import Package, Release, ReleaseFile
from papaye.proxy import smart_merge
from papaye.models import Package, Release, ReleaseFile
from papaye.proxy import smart_merge
from papaye.factories.root import repository_root_factory
from papaye.models import Package, Release, ReleaseFile
from papaye.proxy import smart_merge
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import smart_merge
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import smart_merge
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import smart_merge
from papaye.models import Root
from papaye.proxy import PyPiProxy
from papaye.models import Root
from papaye.proxy import PyPiProxy
from papaye.models import Root
from papaye.proxy import PyPiProxy
from papaye.proxy import PyPiProxy
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import PyPiProxy
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import PyPiProxy
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import PyPiProxy
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import PyPiProxy
from papaye.proxy import clone
from papaye.models import Package, Release, ReleaseFile
from papaye.proxy import clone
from papaye.models import Package, Release, ReleaseFile
and context:
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
#
# Path: papaye/tests/tools.py
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# Path: papaye/tests/tools.py
# def mock_proxy_response(mock, response=None, side_effect=False):
# if response is None:
# with open(get_resource('pyramid.json'), 'rb') as pyramid_json:
# pypi_response = FakeGRequestResponse(200, pyramid_json.read())
# mock.return_value = pypi_response
# else:
# attr = 'side_effect' if side_effect else 'return_value'
# setattr(mock, attr, response)
which might include code, classes, or functions. Output only the next line. | 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')
package2['1.5'] = Release(version='1.5', metadata={})
package2['1.5']['pyramid-1.5.whl'] = ReleaseFile(
filename='pyramid-1.5.whl',
content=b'',
md5_digest='12345'
)
root = Root(name='root')
result = smart_merge(package1, package2, root=root)
assert isinstance(result, Package)
assert len(list(result)) == 1
assert len(list(result['1.5'])) == 1
assert result.__parent__ is root
def test_smart_merge_with_none_remote_package(self):
package = Package(name='pyramid')
package['1.5'] = Release(version='1.5', metadata={})
package['1.5']['pyramid-1.5.whl'] = ReleaseFile(
filename='pyramid-1.5.whl',
content=b'',
md5_digest='12345'
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import unittest
from mock import patch
from pyramid.threadlocal import get_current_request
from requests.exceptions import ConnectionError
from papaye.factories import models as factories
from papaye.tests.tools import FakeGRequestResponse
from papaye.tests.tools import mock_proxy_response
from papaye.proxy import PyPiProxy
from papaye.proxy import PyPiProxy
from papaye.proxy import PyPiProxy
from papaye.proxy import PyPiProxy
from papaye.factories.root import repository_root_factory
from papaye.models import Package, Release, ReleaseFile
from papaye.proxy import smart_merge
from papaye.models import Package, Release, ReleaseFile
from papaye.proxy import smart_merge
from papaye.factories.root import repository_root_factory
from papaye.models import Package, Release, ReleaseFile
from papaye.proxy import smart_merge
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import smart_merge
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import smart_merge
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import smart_merge
from papaye.models import Root
from papaye.proxy import PyPiProxy
from papaye.models import Root
from papaye.proxy import PyPiProxy
from papaye.models import Root
from papaye.proxy import PyPiProxy
from papaye.proxy import PyPiProxy
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import PyPiProxy
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import PyPiProxy
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import PyPiProxy
from papaye.models import Package, Release, ReleaseFile, Root
from papaye.proxy import PyPiProxy
from papaye.proxy import clone
from papaye.models import Package, Release, ReleaseFile
from papaye.proxy import clone
from papaye.models import Package, Release, ReleaseFile
and context:
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
#
# Path: papaye/tests/tools.py
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# Path: papaye/tests/tools.py
# def mock_proxy_response(mock, response=None, side_effect=False):
# if response is None:
# with open(get_resource('pyramid.json'), 'rb') as pyramid_json:
# pypi_response = FakeGRequestResponse(200, pyramid_json.read())
# mock.return_value = pypi_response
# else:
# attr = 'side_effect' if side_effect else 'return_value'
# setattr(mock, attr, response)
which might include code, classes, or functions. Output only the next line. | ) |
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_filename = Service(
name="filename_by_package_version",
path="/api/compat/package/{package_name}/{version}/{filename}/json",
description="Package service",
factory=repository_root_factory,
)
vars = Service(
name="vars",
path="/api/compat/vars/json",
description="Server variables",
)
@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
<|code_end|>
. Use current file imports:
(from cornice import Service
from pyramid.httpexceptions import HTTPNotFound
from pyramid.interfaces import ISettings
from cornice.validators import colander_validator
from papaye.factories.root import repository_root_factory
from .schemas import GetPackageSchema)
and context including class names, function names, or small code snippets from other files:
# Path: papaye/factories/root.py
# def repository_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['repository']
#
# Path: papaye/views/api/compat/schemas.py
# class GetPackageSchema(colander.MappingSchema):
# path = Path()
. Output only the next line. | 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(), validators=(colander_validator))
def get_package_by_version(request):
package_name = request.validated['path']['package_name']
version = request.validated['path']['version']
packages = [package.__name__ for package in request.context]
if package_name in packages:
versions = request.context[package_name].releases.keys()
if version in versions:
return request.context[package_name][version]
return HTTPNotFound()
@vars.get()
def get_variables(request):
papaye_settings = request.registry.getUtility(
ISettings,
name='settings'
)['papaye']
return {
<|code_end|>
. Write the next line using the current file imports:
from cornice import Service
from pyramid.httpexceptions import HTTPNotFound
from pyramid.interfaces import ISettings
from cornice.validators import colander_validator
from papaye.factories.root import repository_root_factory
from .schemas import GetPackageSchema
and context from other files:
# Path: papaye/factories/root.py
# def repository_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['repository']
#
# Path: papaye/views/api/compat/schemas.py
# class GetPackageSchema(colander.MappingSchema):
# path = Path()
, which may include functions, classes, or code. Output only the next line. | '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 = context_from_root(root)
repository = context.get('repository', tuple())
for package in repository:
package.root = package.__parent__
delattr(package, '__parent__')
for release in package:
release.package = release.__parent__
delattr(release, '__parent__')
for release_file in release:
release_file.release = release_file.__parent__
delattr(release_file, '__parent__')
context.evolved = 8
<|code_end|>
using the current file's imports:
from papaye.evolve.managers import load_model, context_from_root
and any relevant context from other files:
# Path: papaye/evolve/managers.py
# def load_model(model_name):
# def decorated(func):
# func.load_model = importlib.import_module(model_name)
# return func
# return decorated
#
# def context_from_root(root):
# return root[APP_ROOT_NAME]
. Output only the next line. | 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)
repository = context.get('repository', tuple())
for package in repository:
package.root = package.__parent__
delattr(package, '__parent__')
for release in package:
release.package = release.__parent__
delattr(release, '__parent__')
for release_file in release:
<|code_end|>
, determine the next line of code. You have imports:
from papaye.evolve.managers import load_model, context_from_root
and context (class names, function names, or code) available:
# Path: papaye/evolve/managers.py
# def load_model(model_name):
# def decorated(func):
# func.load_model = importlib.import_module(model_name)
# return func
# return decorated
#
# def context_from_root(root):
# return root[APP_ROOT_NAME]
. Output only the next line. | 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 = getattr(serializer, 'schema')
self.assertTrue(schema)
self.assertIsInstance(serializer.schema, colander.SchemaNode)
self.assertEqual(len(serializer.schema.children), 2)
def test_schema_without_node(self):
class TestSerializer(Serializer):
pass
serializer = TestSerializer(None)
schema = getattr(serializer, 'schema')
self.assertFalse(schema)
class ReleaseAPISerializerTest(unittest.TestCase):
<|code_end|>
, predict the immediate next line with the help of imports:
import colander
import unittest
from pyramid import testing
from pyramid.threadlocal import get_current_request
from papaye.factories import models as factories
from papaye.serializers import Serializer
from papaye.serializers import Serializer
from papaye.serializers import Serializer
from papaye.serializers import ReleaseAPISerializer
from papaye.serializers import ReleaseAPISerializer
from papaye.serializers import ReleaseAPISerializer
and context (classes, functions, sometimes code) from other files:
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
. Output only the next line. | 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)
class Meta:
model = models.Package
class ReleaseFactory(factory.Factory):
version = factory.Sequence(lambda n: 'Release{}'.format(n))
metadata = {}
deserialize_metadata = True
package = factory.SubFactory(PackageFactory)
class Meta:
model = models.Release
class ReleaseFileFactory(factory.Factory):
filename = factory.Sequence(lambda n: 'ReleaseFile{}.tar.gz'.format(n))
content = b'a content'
status = models.STATUS.local
<|code_end|>
. Write the next line using the current file imports:
import factory
from papaye import models
and context from other files:
# Path: papaye/models.py
# SW_VERSION = 8
# STATUS = status_type(*range(0, len(status_type._fields)))
# def get_manager(config):
# def get_connection(settings):
# def chunk(iterable, step):
# def _p_resolveConflict(self, old_state, stored_state, new_state):
# def __repr__(self):
# def __init__(self, *args, **kwargs):
# def __getattr__(self, attribute):
# def clone(cls, model_obj):
# def __init__(self, name, *args, **kwargs):
# def __name__(self):
# def __parent__(self):
# def subobjects(self):
# def get(self, key, default=None):
# def child(self, subobject):
# def __contains__(self, obj_or_name):
# def __iter__(self):
# def __len__(self):
# def __delitem__(self, key):
# def keys(self):
# def format_key(self, key):
# def __init__(self, name):
# def __parent__(self):
# def __acl__(self):
# def __iter__(self):
# def __getitem__(self, name_or_index):
# def __setitem__(self, key, package):
# def __init__(self, name, root=None, **kwargs):
# def format_key(self, key):
# def __getitem__(self, release_name_or_index):
# def __setitem__(self, key, value):
# def get_last_remote_version(cls, proxy, package_name):
# def repository_is_up_to_date(self, last_remote_release):
# def by_name(cls, name, request):
# def get_last_release(self):
# def metadata(self):
# def __json__(self, request):
# def __init__(self, version, metadata={},
# deserialize_metadata=True, package=None, **kwargs):
# def __getitem__(self, version_or_index):
# def __setitem__(self, key, value):
# def by_packagename(cls, package_name, request):
# def by_releasename(cls, package_name, release, request):
# def __json__(self, request):
# def __init__(self, filename, content, md5_digest=None,
# status=None, release=None, **kwargs):
# def __name__(self):
# def __parent__(self):
# def _compute_release_file_directory(self):
# def get_content_type(self, content):
# def _packages_directory(self):
# def set_content(self, content):
# def path(self):
# def set_path(self, path):
# def full_path(self):
# def clone(cls, model_obj):
# def by_releasefilename(cls, package, release, releasefile, request):
# def format_key(self, key):
# def __init__(self, username, password, **kwargs):
# def hash_password(self, password):
# def password_verify(self, clear_password):
# def __repr__(self):
# def by_username(cls, username, request):
# def __acl__(self):
# def __acl__(self):
# class MyOOBTree(OOBTree):
# class Model(Persistent):
# class ClonableModelMixin(object):
# class SubscriptableMixin(object):
# class Root(ClonableModelMixin, SubscriptableBaseModel, Model):
# class Package(SubscriptableMixin, ClonableModelMixin, Model):
# class Release(SubscriptableMixin, ClonableModelMixin, Model):
# class ReleaseFile(ClonableModelMixin, Model):
# class User(Model):
# class RestrictedContext(object):
# class Application(object):
, which may include functions, classes, or code. Output only the next line. | 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_route(
'simple',
'/simple*traverse',
<|code_end|>
. Use current file imports:
(from papaye.factories.root import (
user_root_factory,
application_factory,
))
and context including class names, function names, or small code snippets from other files:
# Path: papaye/factories/root.py
# def user_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['user']
#
# def application_factory(request):
# from papaye.models import Application
# return Application()
. Output only the next line. | 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, repository_root_factory, default_root_factory
and context (classes, functions, or code) from other files:
# Path: papaye/factories/root.py
# def user_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['user']
#
# def repository_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['repository']
#
# def default_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# return zodb_root
. Output only the next line. | 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, repository_root_factory, default_root_factory)
and context including class names, function names, or small code snippets from other files:
# Path: papaye/factories/root.py
# def user_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['user']
#
# def repository_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['repository']
#
# def default_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# return zodb_root
. Output only the next line. | 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(index),
'description': 'A description',
},
release__version='1.0',
release__package__root=root,
<|code_end|>
. Use current file imports:
(import os
import pytest
import shutil
import tempfile
from pyramid import testing
from pyramid.httpexceptions import HTTPNotFound
from pyramid.threadlocal import get_current_request
from papaye.tests.tools import set_database_connection
from papaye.factories import models as factories
from papaye.views.api.compat.api import list_packages
from papaye.views.api.compat.api import list_packages
from papaye.views.api.compat.api import get_package
from papaye.models import Release
from papaye.views.api.compat.api import get_package_by_version
from papaye.models import Release
from papaye.views.api.compat.api import get_package_by_version
from papaye.views.api.compat.api import get_package_by_version)
and context including class names, function names, or small code snippets from other files:
# Path: papaye/tests/tools.py
# def set_database_connection(request, blob_dir=None, config=None):
# if not blob_dir:
# blob_dir = tempfile.mkdtemp('blobs')
# conn = get_db_connection(blob_dir)
# request._primary_zodb_conn = conn
# if config:
# import transaction
# conn.root()['repository'] = {}
# conn.root()['user'] = {}
# transaction.commit()
# config.registry._zodb_databases = {'': conn._db}
# return blob_dir
#
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
. Output only the next line. | ) |
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['{}_root'.format(APP_NAME)] = Root('{}_root'.format(APP_NAME))
if 'user' not in zodb_root['{}_root'.format(APP_NAME)]:
zodb_root['{}_root'.format(APP_NAME)]['user'] = Root('user_root')
if 'repository' not in zodb_root['{}_root'.format(APP_NAME)]:
zodb_root['{}_root'.format(APP_NAME)]['repository'] = Root(
'repository_root'
)
def create_admin_user(dbconn, username, password):
admin = User(username, password, groups=['group:admin'])
root = user_root_factory(dbconn)
root[username] = admin
transaction.commit()
def parse_arguments():
parser = argparse.ArgumentParser(description='Initialize the Papaye database.')
parser.add_argument('file.ini', type=str, nargs='+', help='configuration INI file')
parser.add_argument('--user', type=str, help='Admin username')
parser.add_argument('--password', type=str, help='Admin password')
parser.add_argument('--replace', help='Replace the existing admin user if exists', action='store_true')
parser.add_argument('-q', help='Quiet mode', dest="quiet", action='store_true')
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import argparse
import getpass
import os
import sys
import transaction
from papaye.scripts.common import get_settings
from papaye.factories.root import user_root_factory, APP_NAME
from papaye.models import User, Root, get_connection, get_manager
and context:
# Path: papaye/scripts/common.py
# def get_settings(inifile):
# parser = configparser.ConfigParser()
# current_dir = os.path.abspath(os.path.curdir)
# parser.read(inifile)
# return dict(parser.items('app:main', vars={"here": current_dir}))
#
# Path: papaye/factories/root.py
# def user_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['user']
#
# APP_NAME = __import__(__name__).__name__
#
# Path: papaye/models.py
# class User(Model):
#
# def __init__(self, username, password, **kwargs):
# self.username = username
# self.password = self.hash_password(password)
# self.groups = kwargs.get('groups', [])
#
# def hash_password(self, password):
# return hashlib.sha512(password.encode('utf-8')).hexdigest()
#
# def password_verify(self, clear_password):
# return self.hash_password(clear_password) == self.password
#
# def __repr__(self):
# return '<{}.{} "{}" at {}>'.format(self.__module__, self.__class__.__name__, self.username, id(self))
#
# @classmethod
# def by_username(cls, username, request):
# """Return user instance by username"""
# root = user_root_factory(request)
# if username in [user.username for user in root]:
# return root[username]
# return None
#
# class Root(ClonableModelMixin, SubscriptableBaseModel, Model):
# _subobjects_attr = 'packages'
# __name__ = ''
#
# def __init__(self, name):
# self.name = name
# self.packages = MyOOBTree()
#
# @property
# def __parent__(self):
# """Root object has no parent"""
# return None
#
# def __acl__(self):
# acl = [
# # (Allow, 'group:installer', 'install'),
# # (Allow, 'group:admin', ALL_PERMISSIONS)
# (Allow, Authenticated, 'view'),
# ]
# registry = get_current_registry()
# anonymous_install = registry.settings.get('papaye.anonymous_install')
# acl.append((Allow, Everyone, 'install')) if anonymous_install and anonymous_install == 'true' else False
# return acl
#
# def __iter__(self):
# return (package for package in self.subobjects.values())
#
# def __getitem__(self, name_or_index):
# if isinstance(name_or_index, int):
# return next(itertools.islice(self.__iter__(), name_or_index, name_or_index + 1))
# keys = [key for key in self.subobjects.keys()
# if self.format_key(key) == self.format_key(name_or_index)]
# if len(keys) == 1:
# return self.subobjects[keys[0]]
#
# def __setitem__(self, key, package):
# if not hasattr(self, '_p_updated_keys'):
# self._p_updated_keys = []
# self._p_updated_keys.append(key)
# # if isinstance(package, Package):
# # package.__parent__ = self
# self.subobjects[key] = package
#
# def get_connection(settings):
# uri = settings.get('zodbconn.uri', None)
# db = db_from_uri(uri, 'unamed', None)
# return db.open()
#
# def get_manager(config):
# manager = PapayeEvolutionManager(
# config,
# evolve_packagename='papaye.evolve',
# sw_version=SW_VERSION,
# initial_db_version=0
# )
# return manager
which might include code, classes, or functions. Output only the next line. | 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[manager.key] = {manager.package_name: manager.sw_version}
if '{}_root'.format(APP_NAME) not in zodb_root:
zodb_root['{}_root'.format(APP_NAME)] = Root('{}_root'.format(APP_NAME))
if 'user' not in zodb_root['{}_root'.format(APP_NAME)]:
zodb_root['{}_root'.format(APP_NAME)]['user'] = Root('user_root')
if 'repository' not in zodb_root['{}_root'.format(APP_NAME)]:
zodb_root['{}_root'.format(APP_NAME)]['repository'] = Root(
'repository_root'
)
def create_admin_user(dbconn, username, password):
admin = User(username, password, groups=['group:admin'])
root = user_root_factory(dbconn)
root[username] = admin
transaction.commit()
def parse_arguments():
parser = argparse.ArgumentParser(description='Initialize the Papaye database.')
parser.add_argument('file.ini', type=str, nargs='+', help='configuration INI file')
<|code_end|>
, generate the next line using the imports in this file:
import argparse
import getpass
import os
import sys
import transaction
from papaye.scripts.common import get_settings
from papaye.factories.root import user_root_factory, APP_NAME
from papaye.models import User, Root, get_connection, get_manager
and context (functions, classes, or occasionally code) from other files:
# Path: papaye/scripts/common.py
# def get_settings(inifile):
# parser = configparser.ConfigParser()
# current_dir = os.path.abspath(os.path.curdir)
# parser.read(inifile)
# return dict(parser.items('app:main', vars={"here": current_dir}))
#
# Path: papaye/factories/root.py
# def user_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['user']
#
# APP_NAME = __import__(__name__).__name__
#
# Path: papaye/models.py
# class User(Model):
#
# def __init__(self, username, password, **kwargs):
# self.username = username
# self.password = self.hash_password(password)
# self.groups = kwargs.get('groups', [])
#
# def hash_password(self, password):
# return hashlib.sha512(password.encode('utf-8')).hexdigest()
#
# def password_verify(self, clear_password):
# return self.hash_password(clear_password) == self.password
#
# def __repr__(self):
# return '<{}.{} "{}" at {}>'.format(self.__module__, self.__class__.__name__, self.username, id(self))
#
# @classmethod
# def by_username(cls, username, request):
# """Return user instance by username"""
# root = user_root_factory(request)
# if username in [user.username for user in root]:
# return root[username]
# return None
#
# class Root(ClonableModelMixin, SubscriptableBaseModel, Model):
# _subobjects_attr = 'packages'
# __name__ = ''
#
# def __init__(self, name):
# self.name = name
# self.packages = MyOOBTree()
#
# @property
# def __parent__(self):
# """Root object has no parent"""
# return None
#
# def __acl__(self):
# acl = [
# # (Allow, 'group:installer', 'install'),
# # (Allow, 'group:admin', ALL_PERMISSIONS)
# (Allow, Authenticated, 'view'),
# ]
# registry = get_current_registry()
# anonymous_install = registry.settings.get('papaye.anonymous_install')
# acl.append((Allow, Everyone, 'install')) if anonymous_install and anonymous_install == 'true' else False
# return acl
#
# def __iter__(self):
# return (package for package in self.subobjects.values())
#
# def __getitem__(self, name_or_index):
# if isinstance(name_or_index, int):
# return next(itertools.islice(self.__iter__(), name_or_index, name_or_index + 1))
# keys = [key for key in self.subobjects.keys()
# if self.format_key(key) == self.format_key(name_or_index)]
# if len(keys) == 1:
# return self.subobjects[keys[0]]
#
# def __setitem__(self, key, package):
# if not hasattr(self, '_p_updated_keys'):
# self._p_updated_keys = []
# self._p_updated_keys.append(key)
# # if isinstance(package, Package):
# # package.__parent__ = self
# self.subobjects[key] = package
#
# def get_connection(settings):
# uri = settings.get('zodbconn.uri', None)
# db = db_from_uri(uri, 'unamed', None)
# return db.open()
#
# def get_manager(config):
# manager = PapayeEvolutionManager(
# config,
# evolve_packagename='papaye.evolve',
# sw_version=SW_VERSION,
# initial_db_version=0
# )
# return manager
. Output only the next line. | 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 == 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[manager.key] = {manager.package_name: manager.sw_version}
if '{}_root'.format(APP_NAME) not in zodb_root:
zodb_root['{}_root'.format(APP_NAME)] = Root('{}_root'.format(APP_NAME))
if 'user' not in zodb_root['{}_root'.format(APP_NAME)]:
zodb_root['{}_root'.format(APP_NAME)]['user'] = Root('user_root')
if 'repository' not in zodb_root['{}_root'.format(APP_NAME)]:
zodb_root['{}_root'.format(APP_NAME)]['repository'] = Root(
'repository_root'
)
def create_admin_user(dbconn, username, password):
admin = User(username, password, groups=['group:admin'])
root = user_root_factory(dbconn)
<|code_end|>
, determine the next line of code. You have imports:
import argparse
import getpass
import os
import sys
import transaction
from papaye.scripts.common import get_settings
from papaye.factories.root import user_root_factory, APP_NAME
from papaye.models import User, Root, get_connection, get_manager
and context (class names, function names, or code) available:
# Path: papaye/scripts/common.py
# def get_settings(inifile):
# parser = configparser.ConfigParser()
# current_dir = os.path.abspath(os.path.curdir)
# parser.read(inifile)
# return dict(parser.items('app:main', vars={"here": current_dir}))
#
# Path: papaye/factories/root.py
# def user_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['user']
#
# APP_NAME = __import__(__name__).__name__
#
# Path: papaye/models.py
# class User(Model):
#
# def __init__(self, username, password, **kwargs):
# self.username = username
# self.password = self.hash_password(password)
# self.groups = kwargs.get('groups', [])
#
# def hash_password(self, password):
# return hashlib.sha512(password.encode('utf-8')).hexdigest()
#
# def password_verify(self, clear_password):
# return self.hash_password(clear_password) == self.password
#
# def __repr__(self):
# return '<{}.{} "{}" at {}>'.format(self.__module__, self.__class__.__name__, self.username, id(self))
#
# @classmethod
# def by_username(cls, username, request):
# """Return user instance by username"""
# root = user_root_factory(request)
# if username in [user.username for user in root]:
# return root[username]
# return None
#
# class Root(ClonableModelMixin, SubscriptableBaseModel, Model):
# _subobjects_attr = 'packages'
# __name__ = ''
#
# def __init__(self, name):
# self.name = name
# self.packages = MyOOBTree()
#
# @property
# def __parent__(self):
# """Root object has no parent"""
# return None
#
# def __acl__(self):
# acl = [
# # (Allow, 'group:installer', 'install'),
# # (Allow, 'group:admin', ALL_PERMISSIONS)
# (Allow, Authenticated, 'view'),
# ]
# registry = get_current_registry()
# anonymous_install = registry.settings.get('papaye.anonymous_install')
# acl.append((Allow, Everyone, 'install')) if anonymous_install and anonymous_install == 'true' else False
# return acl
#
# def __iter__(self):
# return (package for package in self.subobjects.values())
#
# def __getitem__(self, name_or_index):
# if isinstance(name_or_index, int):
# return next(itertools.islice(self.__iter__(), name_or_index, name_or_index + 1))
# keys = [key for key in self.subobjects.keys()
# if self.format_key(key) == self.format_key(name_or_index)]
# if len(keys) == 1:
# return self.subobjects[keys[0]]
#
# def __setitem__(self, key, package):
# if not hasattr(self, '_p_updated_keys'):
# self._p_updated_keys = []
# self._p_updated_keys.append(key)
# # if isinstance(package, Package):
# # package.__parent__ = self
# self.subobjects[key] = package
#
# def get_connection(settings):
# uri = settings.get('zodbconn.uri', None)
# db = db_from_uri(uri, 'unamed', None)
# return db.open()
#
# def get_manager(config):
# manager = PapayeEvolutionManager(
# config,
# evolve_packagename='papaye.evolve',
# sw_version=SW_VERSION,
# initial_db_version=0
# )
# return manager
. Output only the next line. | 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
def database_already_initialized(dbconn):
zodb_root = get_database_root(dbconn)
if not '{}_root'.format(APP_NAME) in zodb_root:
return False
if not len([
user for user in zodb_root['{}_root'.format(APP_NAME)]['user']
<|code_end|>
, predict the next line using imports from the current file:
import argparse
import getpass
import os
import sys
import transaction
from papaye.scripts.common import get_settings
from papaye.factories.root import user_root_factory, APP_NAME
from papaye.models import User, Root, get_connection, get_manager
and context including class names, function names, and sometimes code from other files:
# Path: papaye/scripts/common.py
# def get_settings(inifile):
# parser = configparser.ConfigParser()
# current_dir = os.path.abspath(os.path.curdir)
# parser.read(inifile)
# return dict(parser.items('app:main', vars={"here": current_dir}))
#
# Path: papaye/factories/root.py
# def user_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['user']
#
# APP_NAME = __import__(__name__).__name__
#
# Path: papaye/models.py
# class User(Model):
#
# def __init__(self, username, password, **kwargs):
# self.username = username
# self.password = self.hash_password(password)
# self.groups = kwargs.get('groups', [])
#
# def hash_password(self, password):
# return hashlib.sha512(password.encode('utf-8')).hexdigest()
#
# def password_verify(self, clear_password):
# return self.hash_password(clear_password) == self.password
#
# def __repr__(self):
# return '<{}.{} "{}" at {}>'.format(self.__module__, self.__class__.__name__, self.username, id(self))
#
# @classmethod
# def by_username(cls, username, request):
# """Return user instance by username"""
# root = user_root_factory(request)
# if username in [user.username for user in root]:
# return root[username]
# return None
#
# class Root(ClonableModelMixin, SubscriptableBaseModel, Model):
# _subobjects_attr = 'packages'
# __name__ = ''
#
# def __init__(self, name):
# self.name = name
# self.packages = MyOOBTree()
#
# @property
# def __parent__(self):
# """Root object has no parent"""
# return None
#
# def __acl__(self):
# acl = [
# # (Allow, 'group:installer', 'install'),
# # (Allow, 'group:admin', ALL_PERMISSIONS)
# (Allow, Authenticated, 'view'),
# ]
# registry = get_current_registry()
# anonymous_install = registry.settings.get('papaye.anonymous_install')
# acl.append((Allow, Everyone, 'install')) if anonymous_install and anonymous_install == 'true' else False
# return acl
#
# def __iter__(self):
# return (package for package in self.subobjects.values())
#
# def __getitem__(self, name_or_index):
# if isinstance(name_or_index, int):
# return next(itertools.islice(self.__iter__(), name_or_index, name_or_index + 1))
# keys = [key for key in self.subobjects.keys()
# if self.format_key(key) == self.format_key(name_or_index)]
# if len(keys) == 1:
# return self.subobjects[keys[0]]
#
# def __setitem__(self, key, package):
# if not hasattr(self, '_p_updated_keys'):
# self._p_updated_keys = []
# self._p_updated_keys.append(key)
# # if isinstance(package, Package):
# # package.__parent__ = self
# self.subobjects[key] = package
#
# def get_connection(settings):
# uri = settings.get('zodbconn.uri', None)
# db = db_from_uri(uri, 'unamed', None)
# return db.open()
#
# def get_manager(config):
# manager = PapayeEvolutionManager(
# config,
# evolve_packagename='papaye.evolve',
# sw_version=SW_VERSION,
# initial_db_version=0
# )
# return manager
. Output only the next line. | 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)
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 == 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[manager.key] = {manager.package_name: manager.sw_version}
if '{}_root'.format(APP_NAME) not in zodb_root:
zodb_root['{}_root'.format(APP_NAME)] = Root('{}_root'.format(APP_NAME))
if 'user' not in zodb_root['{}_root'.format(APP_NAME)]:
zodb_root['{}_root'.format(APP_NAME)]['user'] = Root('user_root')
if 'repository' not in zodb_root['{}_root'.format(APP_NAME)]:
zodb_root['{}_root'.format(APP_NAME)]['repository'] = Root(
<|code_end|>
, generate the next line using the imports in this file:
import argparse
import getpass
import os
import sys
import transaction
from papaye.scripts.common import get_settings
from papaye.factories.root import user_root_factory, APP_NAME
from papaye.models import User, Root, get_connection, get_manager
and context (functions, classes, or occasionally code) from other files:
# Path: papaye/scripts/common.py
# def get_settings(inifile):
# parser = configparser.ConfigParser()
# current_dir = os.path.abspath(os.path.curdir)
# parser.read(inifile)
# return dict(parser.items('app:main', vars={"here": current_dir}))
#
# Path: papaye/factories/root.py
# def user_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['user']
#
# APP_NAME = __import__(__name__).__name__
#
# Path: papaye/models.py
# class User(Model):
#
# def __init__(self, username, password, **kwargs):
# self.username = username
# self.password = self.hash_password(password)
# self.groups = kwargs.get('groups', [])
#
# def hash_password(self, password):
# return hashlib.sha512(password.encode('utf-8')).hexdigest()
#
# def password_verify(self, clear_password):
# return self.hash_password(clear_password) == self.password
#
# def __repr__(self):
# return '<{}.{} "{}" at {}>'.format(self.__module__, self.__class__.__name__, self.username, id(self))
#
# @classmethod
# def by_username(cls, username, request):
# """Return user instance by username"""
# root = user_root_factory(request)
# if username in [user.username for user in root]:
# return root[username]
# return None
#
# class Root(ClonableModelMixin, SubscriptableBaseModel, Model):
# _subobjects_attr = 'packages'
# __name__ = ''
#
# def __init__(self, name):
# self.name = name
# self.packages = MyOOBTree()
#
# @property
# def __parent__(self):
# """Root object has no parent"""
# return None
#
# def __acl__(self):
# acl = [
# # (Allow, 'group:installer', 'install'),
# # (Allow, 'group:admin', ALL_PERMISSIONS)
# (Allow, Authenticated, 'view'),
# ]
# registry = get_current_registry()
# anonymous_install = registry.settings.get('papaye.anonymous_install')
# acl.append((Allow, Everyone, 'install')) if anonymous_install and anonymous_install == 'true' else False
# return acl
#
# def __iter__(self):
# return (package for package in self.subobjects.values())
#
# def __getitem__(self, name_or_index):
# if isinstance(name_or_index, int):
# return next(itertools.islice(self.__iter__(), name_or_index, name_or_index + 1))
# keys = [key for key in self.subobjects.keys()
# if self.format_key(key) == self.format_key(name_or_index)]
# if len(keys) == 1:
# return self.subobjects[keys[0]]
#
# def __setitem__(self, key, package):
# if not hasattr(self, '_p_updated_keys'):
# self._p_updated_keys = []
# self._p_updated_keys.append(key)
# # if isinstance(package, Package):
# # package.__parent__ = self
# self.subobjects[key] = package
#
# def get_connection(settings):
# uri = settings.get('zodbconn.uri', None)
# db = db_from_uri(uri, 'unamed', None)
# return db.open()
#
# def get_manager(config):
# manager = PapayeEvolutionManager(
# config,
# evolve_packagename='papaye.evolve',
# sw_version=SW_VERSION,
# initial_db_version=0
# )
# return manager
. Output only the next line. | '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_NAME) not in zodb_root:
zodb_root['{}_root'.format(APP_NAME)] = Root('{}_root'.format(APP_NAME))
if 'user' not in zodb_root['{}_root'.format(APP_NAME)]:
zodb_root['{}_root'.format(APP_NAME)]['user'] = Root('user_root')
if 'repository' not in zodb_root['{}_root'.format(APP_NAME)]:
zodb_root['{}_root'.format(APP_NAME)]['repository'] = Root(
'repository_root'
)
def create_admin_user(dbconn, username, password):
admin = User(username, password, groups=['group:admin'])
root = user_root_factory(dbconn)
root[username] = admin
transaction.commit()
def parse_arguments():
parser = argparse.ArgumentParser(description='Initialize the Papaye database.')
parser.add_argument('file.ini', type=str, nargs='+', help='configuration INI file')
parser.add_argument('--user', type=str, help='Admin username')
parser.add_argument('--password', type=str, help='Admin password')
parser.add_argument('--replace', help='Replace the existing admin user if exists', action='store_true')
<|code_end|>
, predict the next line using imports from the current file:
import argparse
import getpass
import os
import sys
import transaction
from papaye.scripts.common import get_settings
from papaye.factories.root import user_root_factory, APP_NAME
from papaye.models import User, Root, get_connection, get_manager
and context including class names, function names, and sometimes code from other files:
# Path: papaye/scripts/common.py
# def get_settings(inifile):
# parser = configparser.ConfigParser()
# current_dir = os.path.abspath(os.path.curdir)
# parser.read(inifile)
# return dict(parser.items('app:main', vars={"here": current_dir}))
#
# Path: papaye/factories/root.py
# def user_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['user']
#
# APP_NAME = __import__(__name__).__name__
#
# Path: papaye/models.py
# class User(Model):
#
# def __init__(self, username, password, **kwargs):
# self.username = username
# self.password = self.hash_password(password)
# self.groups = kwargs.get('groups', [])
#
# def hash_password(self, password):
# return hashlib.sha512(password.encode('utf-8')).hexdigest()
#
# def password_verify(self, clear_password):
# return self.hash_password(clear_password) == self.password
#
# def __repr__(self):
# return '<{}.{} "{}" at {}>'.format(self.__module__, self.__class__.__name__, self.username, id(self))
#
# @classmethod
# def by_username(cls, username, request):
# """Return user instance by username"""
# root = user_root_factory(request)
# if username in [user.username for user in root]:
# return root[username]
# return None
#
# class Root(ClonableModelMixin, SubscriptableBaseModel, Model):
# _subobjects_attr = 'packages'
# __name__ = ''
#
# def __init__(self, name):
# self.name = name
# self.packages = MyOOBTree()
#
# @property
# def __parent__(self):
# """Root object has no parent"""
# return None
#
# def __acl__(self):
# acl = [
# # (Allow, 'group:installer', 'install'),
# # (Allow, 'group:admin', ALL_PERMISSIONS)
# (Allow, Authenticated, 'view'),
# ]
# registry = get_current_registry()
# anonymous_install = registry.settings.get('papaye.anonymous_install')
# acl.append((Allow, Everyone, 'install')) if anonymous_install and anonymous_install == 'true' else False
# return acl
#
# def __iter__(self):
# return (package for package in self.subobjects.values())
#
# def __getitem__(self, name_or_index):
# if isinstance(name_or_index, int):
# return next(itertools.islice(self.__iter__(), name_or_index, name_or_index + 1))
# keys = [key for key in self.subobjects.keys()
# if self.format_key(key) == self.format_key(name_or_index)]
# if len(keys) == 1:
# return self.subobjects[keys[0]]
#
# def __setitem__(self, key, package):
# if not hasattr(self, '_p_updated_keys'):
# self._p_updated_keys = []
# self._p_updated_keys.append(key)
# # if isinstance(package, Package):
# # package.__parent__ = self
# self.subobjects[key] = package
#
# def get_connection(settings):
# uri = settings.get('zodbconn.uri', None)
# db = db_from_uri(uri, 'unamed', None)
# return db.open()
#
# def get_manager(config):
# manager = PapayeEvolutionManager(
# config,
# evolve_packagename='papaye.evolve',
# sw_version=SW_VERSION,
# initial_db_version=0
# )
# return manager
. Output only the next line. | 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(dbconn):
zodb_root = get_database_root(dbconn)
if not '{}_root'.format(APP_NAME) in zodb_root:
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)
if not '{}_root'.format(APP_NAME) in zodb_root:
return False
<|code_end|>
. Use current file imports:
(import argparse
import getpass
import os
import sys
import transaction
from papaye.scripts.common import get_settings
from papaye.factories.root import user_root_factory, APP_NAME
from papaye.models import User, Root, get_connection, get_manager)
and context including class names, function names, or small code snippets from other files:
# Path: papaye/scripts/common.py
# def get_settings(inifile):
# parser = configparser.ConfigParser()
# current_dir = os.path.abspath(os.path.curdir)
# parser.read(inifile)
# return dict(parser.items('app:main', vars={"here": current_dir}))
#
# Path: papaye/factories/root.py
# def user_root_factory(request_or_connection):
# if isinstance(request_or_connection, (Request, DummyRequest)):
# conn = get_connection(request_or_connection)
# else:
# conn = request_or_connection
# zodb_root = conn.root()
# if not '{}_root'.format(APP_NAME) in zodb_root:
# return None
# return zodb_root[APP_ROOT_NAME]['user']
#
# APP_NAME = __import__(__name__).__name__
#
# Path: papaye/models.py
# class User(Model):
#
# def __init__(self, username, password, **kwargs):
# self.username = username
# self.password = self.hash_password(password)
# self.groups = kwargs.get('groups', [])
#
# def hash_password(self, password):
# return hashlib.sha512(password.encode('utf-8')).hexdigest()
#
# def password_verify(self, clear_password):
# return self.hash_password(clear_password) == self.password
#
# def __repr__(self):
# return '<{}.{} "{}" at {}>'.format(self.__module__, self.__class__.__name__, self.username, id(self))
#
# @classmethod
# def by_username(cls, username, request):
# """Return user instance by username"""
# root = user_root_factory(request)
# if username in [user.username for user in root]:
# return root[username]
# return None
#
# class Root(ClonableModelMixin, SubscriptableBaseModel, Model):
# _subobjects_attr = 'packages'
# __name__ = ''
#
# def __init__(self, name):
# self.name = name
# self.packages = MyOOBTree()
#
# @property
# def __parent__(self):
# """Root object has no parent"""
# return None
#
# def __acl__(self):
# acl = [
# # (Allow, 'group:installer', 'install'),
# # (Allow, 'group:admin', ALL_PERMISSIONS)
# (Allow, Authenticated, 'view'),
# ]
# registry = get_current_registry()
# anonymous_install = registry.settings.get('papaye.anonymous_install')
# acl.append((Allow, Everyone, 'install')) if anonymous_install and anonymous_install == 'true' else False
# return acl
#
# def __iter__(self):
# return (package for package in self.subobjects.values())
#
# def __getitem__(self, name_or_index):
# if isinstance(name_or_index, int):
# return next(itertools.islice(self.__iter__(), name_or_index, name_or_index + 1))
# keys = [key for key in self.subobjects.keys()
# if self.format_key(key) == self.format_key(name_or_index)]
# if len(keys) == 1:
# return self.subobjects[keys[0]]
#
# def __setitem__(self, key, package):
# if not hasattr(self, '_p_updated_keys'):
# self._p_updated_keys = []
# self._p_updated_keys.append(key)
# # if isinstance(package, Package):
# # package.__parent__ = self
# self.subobjects[key] = package
#
# def get_connection(settings):
# uri = settings.get('zodbconn.uri', None)
# db = db_from_uri(uri, 'unamed', None)
# return db.open()
#
# def get_manager(config):
# manager = PapayeEvolutionManager(
# config,
# evolve_packagename='papaye.evolve',
# sw_version=SW_VERSION,
# initial_db_version=0
# )
# return manager
. Output only the next line. | 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):
shutil.rmtree(self.blob_dir)
@patch('requests.get')
@patch('papaye.factories.root.repository_root_factory')
def test_download_release_from_pypi(self, get_connection_mock, request_mock):
get_connection_mock.return_value = self.root
json_request_response = open(get_resource('pyramid1.4.json'), 'rb')
release_file_content = open(get_resource('pyramid-1.5.tar.gz'), 'rb')
request_mock.side_effect = [
FakeGRequestResponse(200, json_request_response.read()),
FakeGRequestResponse(200, release_file_content.read()),
]
download_release_from_pypi(self.conn.db(), 'pyramid', '1.5', 'pyramid-1.5.tar.gz')
self.assertEqual(request_mock.call_count, 2)
self.assertIn('pyramid', self.root)
self.assertIn('1.5', self.root['pyramid'].releases)
self.assertIn('pyramid-1.5.tar.gz', self.root['pyramid']['1.5'].release_files)
<|code_end|>
, generate the next line using the imports in this file:
import io
import os
import pytest
import shutil
import tempfile
import transaction
import unittest
from mock import patch
from pyramid import testing
from papaye.tests.tools import (
FakeGRequestResponse,
disable_cache,
get_db_connection,
get_resource,
)
from papaye.tasks.download import download_release_from_pypi
from papaye.factories.root import repository_root_factory
from papaye.tasks.download import download_release_from_pypi
from papaye.factories.root import repository_root_factory
from papaye.models import Package, Release, ReleaseFile
from papaye.tasks.download import download_release_from_pypi
from papaye.models import Package, Release, ReleaseFile
from papaye.tasks.download import download_release_from_pypi
and context (functions, classes, or occasionally code) from other files:
# Path: papaye/tests/tools.py
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
#
# def get_db_connection(blob_dir):
# storage = MappingStorage('test')
# blob_storage = BlobStorage(blob_dir, storage)
# db = DB(blob_storage)
# conn = db.open()
# create_app_root(conn)
# return conn
#
# def get_resource(*args):
# return os.path.join(TEST_RESOURCES, *args)
. Output only the next line. | 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 the help of imports:
import io
import os
import pytest
import shutil
import tempfile
import transaction
import unittest
from mock import patch
from pyramid import testing
from papaye.tests.tools import (
FakeGRequestResponse,
disable_cache,
get_db_connection,
get_resource,
)
from papaye.tasks.download import download_release_from_pypi
from papaye.factories.root import repository_root_factory
from papaye.tasks.download import download_release_from_pypi
from papaye.factories.root import repository_root_factory
from papaye.models import Package, Release, ReleaseFile
from papaye.tasks.download import download_release_from_pypi
from papaye.models import Package, Release, ReleaseFile
from papaye.tasks.download import download_release_from_pypi
and context (classes, functions, sometimes code) from other files:
# Path: papaye/tests/tools.py
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
#
# def get_db_connection(blob_dir):
# storage = MappingStorage('test')
# blob_storage = BlobStorage(blob_dir, storage)
# db = DB(blob_storage)
# conn = db.open()
# create_app_root(conn)
# return conn
#
# def get_resource(*args):
# return os.path.join(TEST_RESOURCES, *args)
. Output only the next line. | 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()):
package = context['repository'][package_name]
new_root['repository'][package_name] = Package(package.name)
for release_name in package.releases:
release = package[release_name]
try:
new_root['repository'][package_name][release_name] = Release(
release.__name__, release.__name__, release.original_metadata
)
for release_filename in release.release_files:
release_file = release[release_filename]
new_root['repository'][package_name][release_name][release_filename] = ReleaseFile(
release_file.filename, release_file.content.open().read(), release_file.md5_digest,
release_file.status,
)
except:
print('{} v{} is corrupt! He won\'t be imported'.format(package.__name__, release.__name__))
new_root['user'] = Root()
for username in context.get('user', tuple()):
<|code_end|>
with the help of current file imports:
from papaye.evolve.managers import load_model, context_from_root, APP_ROOT_NAME
from papaye.models import Root, Package, Release, ReleaseFile, User
and context from other files:
# Path: papaye/evolve/managers.py
# def cleanup():
# def load_model(model_name):
# def decorated(func):
# def out_model(model_name):
# def wrapper(func):
# def wrapped(root):
# def context_from_root(root):
# def error(msg):
# def __init__(self, config, evolve_packagename, sw_version,
# initial_db_version=None):
# def _get_root(self, version=None, old_model_module=None):
# def get_sw_version(self):
# def get_db_version(self):
# def set_db_version(self, root, version):
# def evolve_to(self, version):
# def task(self, string):
# def step(self, version, evmodule):
# def information(self, title, string):
# def evolve_to_current(self):
# class EvolveError(BaseException):
# class PapayeEvolutionManager(object):
, which may contain function names, class names, or code. Output only the next line. | 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 = context['repository'][package_name]
new_root['repository'][package_name] = Package(package.name)
for release_name in package.releases:
release = package[release_name]
try:
new_root['repository'][package_name][release_name] = Release(
release.__name__, release.__name__, release.original_metadata
)
for release_filename in release.release_files:
release_file = release[release_filename]
new_root['repository'][package_name][release_name][release_filename] = ReleaseFile(
release_file.filename, release_file.content.open().read(), release_file.md5_digest,
release_file.status,
)
except:
print('{} v{} is corrupt! He won\'t be imported'.format(package.__name__, release.__name__))
<|code_end|>
, determine the next line of code. You have imports:
from papaye.evolve.managers import load_model, context_from_root, APP_ROOT_NAME
from papaye.models import Root, Package, Release, ReleaseFile, User
and context (class names, function names, or code) available:
# Path: papaye/evolve/managers.py
# def cleanup():
# def load_model(model_name):
# def decorated(func):
# def out_model(model_name):
# def wrapper(func):
# def wrapped(root):
# def context_from_root(root):
# def error(msg):
# def __init__(self, config, evolve_packagename, sw_version,
# initial_db_version=None):
# def _get_root(self, version=None, old_model_module=None):
# def get_sw_version(self):
# def get_db_version(self):
# def set_db_version(self, root, version):
# def evolve_to(self, version):
# def task(self, string):
# def step(self, version, evmodule):
# def information(self, title, string):
# def evolve_to_current(self):
# class EvolveError(BaseException):
# class PapayeEvolutionManager(object):
. Output only the next line. | 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_name] = Package(package.name)
for release_name in package.releases:
release = package[release_name]
try:
new_root['repository'][package_name][release_name] = Release(
release.__name__, release.__name__, release.original_metadata
)
for release_filename in release.release_files:
release_file = release[release_filename]
new_root['repository'][package_name][release_name][release_filename] = ReleaseFile(
release_file.filename, release_file.content.open().read(), release_file.md5_digest,
release_file.status,
)
except:
print('{} v{} is corrupt! He won\'t be imported'.format(package.__name__, release.__name__))
new_root['user'] = Root()
for username in context.get('user', tuple()):
user = context['user'][username]
new_user = User('', '')
new_user.username = user.username
new_user.password = user.password
new_user.groups = user.groups
new_root['user'][username] = new_user
root[APP_ROOT_NAME] = new_root
<|code_end|>
, predict the next line using imports from the current file:
from papaye.evolve.managers import load_model, context_from_root, APP_ROOT_NAME
from papaye.models import Root, Package, Release, ReleaseFile, User
and context including class names, function names, and sometimes code from other files:
# Path: papaye/evolve/managers.py
# def cleanup():
# def load_model(model_name):
# def decorated(func):
# def out_model(model_name):
# def wrapper(func):
# def wrapped(root):
# def context_from_root(root):
# def error(msg):
# def __init__(self, config, evolve_packagename, sw_version,
# initial_db_version=None):
# def _get_root(self, version=None, old_model_module=None):
# def get_sw_version(self):
# def get_db_version(self):
# def set_db_version(self, root, version):
# def evolve_to(self, version):
# def task(self, string):
# def step(self, version, evmodule):
# def information(self, title, string):
# def evolve_to_current(self):
# class EvolveError(BaseException):
# class PapayeEvolutionManager(object):
. Output only the next line. | 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, content, url="https://fake/url/"):
self.status_code = status_code
self.content = content
self.url = url
class FakeMatchedDict(object):
def __init__(self, name):
self.name = name
<|code_end|>
using the current file's imports:
import colander
import os
import shutil
import tempfile
import transaction
from pyramid import testing
from pyramid_beaker import set_cache_regions_from_settings
from ZODB.blob import BlobStorage
from ZODB.DB import DB
from ZODB.MappingStorage import MappingStorage
from papaye.models import Model
from papaye.scripts.initialize import create_app_root
from papaye.serializers import Serializer
and any relevant context from other files:
# Path: papaye/models.py
# class Model(Persistent):
#
# def __repr__(self):
# return '<{}.{} "{}" at {}>'.format(
# self.__module__,
# self.__class__.__name__,
# self.__name__,
# id(self)
# )
#
# def __init__(self, *args, **kwargs):
# # Breaks the super() calls chain
# pass
#
# def __getattr__(self, attribute):
# # Breaks the super() calls chain
# return self.__getattribute__(attribute)
#
# Path: papaye/scripts/initialize.py
# 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['{}_root'.format(APP_NAME)] = Root('{}_root'.format(APP_NAME))
# if 'user' not in zodb_root['{}_root'.format(APP_NAME)]:
# zodb_root['{}_root'.format(APP_NAME)]['user'] = Root('user_root')
# if 'repository' not in zodb_root['{}_root'.format(APP_NAME)]:
# zodb_root['{}_root'.format(APP_NAME)]['repository'] = Root(
# 'repository_root'
# )
#
# Path: papaye/serializers.py
# 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 attributes.items()
# 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: node for name, node in self.fields.items() if isinstance(node, colander.SchemaNode)}
# if nodes:
# for name, node in nodes.items():
# node.name = name
# schema.add(node)
# self._schema = schema
# return self._schema
#
# def serialize(self, obj):
# data = self.get_data(obj)
# 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}
. Output only the next line. | 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://fake/url/"):
self.status_code = status_code
self.content = content
<|code_end|>
, generate the next line using the imports in this file:
import colander
import os
import shutil
import tempfile
import transaction
from pyramid import testing
from pyramid_beaker import set_cache_regions_from_settings
from ZODB.blob import BlobStorage
from ZODB.DB import DB
from ZODB.MappingStorage import MappingStorage
from papaye.models import Model
from papaye.scripts.initialize import create_app_root
from papaye.serializers import Serializer
and context (functions, classes, or occasionally code) from other files:
# Path: papaye/models.py
# class Model(Persistent):
#
# def __repr__(self):
# return '<{}.{} "{}" at {}>'.format(
# self.__module__,
# self.__class__.__name__,
# self.__name__,
# id(self)
# )
#
# def __init__(self, *args, **kwargs):
# # Breaks the super() calls chain
# pass
#
# def __getattr__(self, attribute):
# # Breaks the super() calls chain
# return self.__getattribute__(attribute)
#
# Path: papaye/scripts/initialize.py
# 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['{}_root'.format(APP_NAME)] = Root('{}_root'.format(APP_NAME))
# if 'user' not in zodb_root['{}_root'.format(APP_NAME)]:
# zodb_root['{}_root'.format(APP_NAME)]['user'] = Root('user_root')
# if 'repository' not in zodb_root['{}_root'.format(APP_NAME)]:
# zodb_root['{}_root'.format(APP_NAME)]['repository'] = Root(
# 'repository_root'
# )
#
# Path: papaye/serializers.py
# 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 attributes.items()
# 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: node for name, node in self.fields.items() if isinstance(node, colander.SchemaNode)}
# if nodes:
# for name, node in nodes.items():
# node.name = name
# schema.add(node)
# self._schema = schema
# return self._schema
#
# def serialize(self, obj):
# data = self.get_data(obj)
# 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}
. Output only the next line. | 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://fake/url/"):
self.status_code = status_code
self.content = content
self.url = url
class FakeMatchedDict(object):
<|code_end|>
, determine the next line of code. You have imports:
import colander
import os
import shutil
import tempfile
import transaction
from pyramid import testing
from pyramid_beaker import set_cache_regions_from_settings
from ZODB.blob import BlobStorage
from ZODB.DB import DB
from ZODB.MappingStorage import MappingStorage
from papaye.models import Model
from papaye.scripts.initialize import create_app_root
from papaye.serializers import Serializer
and context (class names, function names, or code) available:
# Path: papaye/models.py
# class Model(Persistent):
#
# def __repr__(self):
# return '<{}.{} "{}" at {}>'.format(
# self.__module__,
# self.__class__.__name__,
# self.__name__,
# id(self)
# )
#
# def __init__(self, *args, **kwargs):
# # Breaks the super() calls chain
# pass
#
# def __getattr__(self, attribute):
# # Breaks the super() calls chain
# return self.__getattribute__(attribute)
#
# Path: papaye/scripts/initialize.py
# 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['{}_root'.format(APP_NAME)] = Root('{}_root'.format(APP_NAME))
# if 'user' not in zodb_root['{}_root'.format(APP_NAME)]:
# zodb_root['{}_root'.format(APP_NAME)]['user'] = Root('user_root')
# if 'repository' not in zodb_root['{}_root'.format(APP_NAME)]:
# zodb_root['{}_root'.format(APP_NAME)]['repository'] = Root(
# 'repository_root'
# )
#
# Path: papaye/serializers.py
# 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 attributes.items()
# 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: node for name, node in self.fields.items() if isinstance(node, colander.SchemaNode)}
# if nodes:
# for name, node in nodes.items():
# node.name = name
# schema.add(node)
# self._schema = schema
# return self._schema
#
# def serialize(self, obj):
# data = self.get_data(obj)
# 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}
. Output only the next line. | 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, (str, bytes)):
return [str(elem) for elem in appstruct.split(' ')]
elif isinstance(appstruct, list):
return [str(elem) for elem in appstruct]
else:
raise colander.Invalid(node, '%r is not a list or string')
def deserialize(self, node, cstruct):
if cstruct == colander.null:
return None
elif isinstance(cstruct, (tuple, list)):
return cstruct
elif not isinstance(cstruct, (str, bytes)):
raise colander.Invalid(node, '%r is not a string' % cstruct)
else:
return cstruct.split(' ')
class Classifiers(colander.List):
<|code_end|>
. Use current file imports:
import os
import colander
from docutils.core import publish_parts
from papaye.evolve.managers import load_model, context_from_root
and context (classes, functions, or code) from other files:
# Path: papaye/evolve/managers.py
# def load_model(model_name):
# def decorated(func):
# func.load_model = importlib.import_module(model_name)
# return func
# return decorated
#
# def context_from_root(root):
# return root[APP_ROOT_NAME]
. Output only the next line. | 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(), missing=None)
summary = colander.SchemaNode(colander.String(), missing=None)
maintainer = colander.SchemaNode(colander.String(), missing=None)
maintainer_email = colander.SchemaNode(colander.String(), missing=None)
description = colander.SchemaNode(colander.String(), missing=None)
platform = colander.SchemaNode(colander.String(), missing=None)
classifiers = colander.SchemaNode(Classifiers(), missing=None)
name = colander.SchemaNode(colander.String(), missing=None)
class APIMetadata(colander.MappingSchema):
version = colander.SchemaNode(String(), missing=None)
author = colander.SchemaNode(String(), missing=None)
author_email = colander.SchemaNode(String(), missing=None)
home_page = colander.SchemaNode(String(), missing=None)
keywords = colander.SchemaNode(Tags(), default=[])
license = colander.SchemaNode(String(), missing=None)
summary = colander.SchemaNode(String(), missing=None)
maintainer = colander.SchemaNode(String(), missing=None)
maintainer_email = colander.SchemaNode(String(), missing=None)
description = APIDescription()
platform = colander.SchemaNode(colander.String(), missing=None)
classifiers = colander.SchemaNode(Classifiers(), default=[])
name = colander.SchemaNode(colander.String(), missing=None)
@load_model('papaye.evolve.models.snapshot1')
<|code_end|>
, predict the next line using imports from the current file:
import os
import colander
from docutils.core import publish_parts
from papaye.evolve.managers import load_model, context_from_root
and context including class names, function names, and sometimes code from other files:
# Path: papaye/evolve/managers.py
# def load_model(model_name):
# def decorated(func):
# func.load_model = importlib.import_module(model_name)
# return func
# return decorated
#
# def context_from_root(root):
# return root[APP_ROOT_NAME]
. Output only the next line. | 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(request=request, settings=settings)
mock.side_effect = ConnectionError
result = not_found(request)
assert isinstance(result, HTTPNotFound)
assert mock.call_count == 1
def test_parse_matchdict_with_package():
matchdict = {'traverse': ('one', )}
result = parse_matchdict(matchdict)
assert result == {'package': 'one', 'desired_entity': 'package'}
def test_parse_matchdict_with_release():
matchdict = {'traverse': ('one', 'two')}
result = parse_matchdict(matchdict)
<|code_end|>
. Use current file imports:
import io
import json
import types
import unittest
from cgi import FieldStorage
from mock import patch
from pyramid import testing
from pyramid.authentication import AuthTktAuthenticationPolicy
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.httpexceptions import HTTPMovedPermanently
from pyramid.httpexceptions import HTTPNotFound
from pyramid.response import Response
from pyramid.threadlocal import get_current_request
from requests.exceptions import ConnectionError
from papaye.tests.tools import disable_cache, FakeGRequestResponse
from papaye.tests.tools import mock_proxy_response
from papaye.factories import models as factories
from papaye.views.simple import ListPackagesView
from papaye.views.simple import ListPackagesView
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import DownloadReleaseView
from papaye.models import ReleaseFile, Release, Package
from papaye.models import Root, Package, Release, ReleaseFile, STATUS
from papaye.views.simple import UploadView
from papaye.models import Root, Package, Release, ReleaseFile
from papaye.views.simple import UploadView
from papaye.models import Root, Package, Release, ReleaseFile
from papaye.views.simple import UploadView
from papaye.views.simple import ListReleaseFileByReleaseView
from papaye.models import Package, Release, ReleaseFile
from papaye.factories.root import repository_root_factory
from papaye.views.simple import ListReleaseFileByReleaseView
from papaye.models import Package, Release, ReleaseFile
from papaye.factories.root import repository_root_factory
from papaye.models import Root, Package, Release, ReleaseFile
from papaye.views.simple import UploadView
from papaye.models import User, Root
from papaye.views.index import LoginView
from papaye.models import User, Root
from papaye.views.index import LoginView
from papaye.views.simple import not_found
from papaye.views.simple import not_found
from papaye.views.simple import parse_matchdict
from papaye.views.simple import parse_matchdict
from papaye.views.simple import parse_matchdict
and context (classes, functions, or code) from other files:
# Path: papaye/tests/tools.py
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
#
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# Path: papaye/tests/tools.py
# def mock_proxy_response(mock, response=None, side_effect=False):
# if response is None:
# with open(get_resource('pyramid.json'), 'rb') as pyramid_json:
# pypi_response = FakeGRequestResponse(200, pyramid_json.read())
# mock.return_value = pypi_response
# else:
# attr = 'side_effect' if side_effect else 'return_value'
# setattr(mock, attr, response)
#
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
. Output only the next line. | 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.gz', content=b'Fake Content', release=release,
)
view = UploadView(root, self.request)
result = view()
self.assertIsInstance(result, Response)
self.assertEqual(result.status_int, 200)
self.assertTrue('my-package' in root)
self.assertIsInstance(root['my-package'], Package)
self.assertTrue(root['my-package'].releases.get('1.0', False))
self.assertIsInstance(root['my-package']['1.0'], Release)
self.assertTrue(root['my-package']['1.0'].release_files.get('foo.tar.gz', b''))
self.assertIsInstance(root['my-package']['1.0']['foo.tar.gz'], ReleaseFile)
self.assertTrue(root['my-package']['1.0'].release_files.get('foo.zip', b''))
self.assertIsInstance(root['my-package']['1.0']['foo.zip'], ReleaseFile)
self.assertEqual(root['my-package']['1.0'].release_files.get('foo.tar.gz', b'').size, 12)
class ListReleaseFileByReleaseViewTest(unittest.TestCase):
def setUp(self):
self.request = get_current_request()
<|code_end|>
, predict the immediate next line with the help of imports:
import io
import json
import types
import unittest
from cgi import FieldStorage
from mock import patch
from pyramid import testing
from pyramid.authentication import AuthTktAuthenticationPolicy
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.httpexceptions import HTTPMovedPermanently
from pyramid.httpexceptions import HTTPNotFound
from pyramid.response import Response
from pyramid.threadlocal import get_current_request
from requests.exceptions import ConnectionError
from papaye.tests.tools import disable_cache, FakeGRequestResponse
from papaye.tests.tools import mock_proxy_response
from papaye.factories import models as factories
from papaye.views.simple import ListPackagesView
from papaye.views.simple import ListPackagesView
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import DownloadReleaseView
from papaye.models import ReleaseFile, Release, Package
from papaye.models import Root, Package, Release, ReleaseFile, STATUS
from papaye.views.simple import UploadView
from papaye.models import Root, Package, Release, ReleaseFile
from papaye.views.simple import UploadView
from papaye.models import Root, Package, Release, ReleaseFile
from papaye.views.simple import UploadView
from papaye.views.simple import ListReleaseFileByReleaseView
from papaye.models import Package, Release, ReleaseFile
from papaye.factories.root import repository_root_factory
from papaye.views.simple import ListReleaseFileByReleaseView
from papaye.models import Package, Release, ReleaseFile
from papaye.factories.root import repository_root_factory
from papaye.models import Root, Package, Release, ReleaseFile
from papaye.views.simple import UploadView
from papaye.models import User, Root
from papaye.views.index import LoginView
from papaye.models import User, Root
from papaye.views.index import LoginView
from papaye.views.simple import not_found
from papaye.views.simple import not_found
from papaye.views.simple import parse_matchdict
from papaye.views.simple import parse_matchdict
from papaye.views.simple import parse_matchdict
and context (classes, functions, sometimes code) from other files:
# Path: papaye/tests/tools.py
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
#
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# Path: papaye/tests/tools.py
# def mock_proxy_response(mock, response=None, side_effect=False):
# if response is None:
# with open(get_resource('pyramid.json'), 'rb') as pyramid_json:
# pypi_response = FakeGRequestResponse(200, pyramid_json.read())
# mock.return_value = pypi_response
# else:
# attr = 'side_effect' if side_effect else 'return_value'
# setattr(mock, attr, response)
#
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
. Output only the next line. | 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.assertIsInstance(result, Response)
self.assertEqual(result.status_int, 200)
self.assertTrue('my-package' in root)
self.assertIsInstance(root['my-package'], Package)
self.assertTrue(root['my-package'].releases.get('1.0', False))
self.assertIsInstance(root['my-package']['1.0'], Release)
self.assertTrue(root['my-package']['1.0'].release_files.get('foo.tar.gz', b''))
self.assertIsInstance(root['my-package']['1.0']['foo.tar.gz'], ReleaseFile)
self.assertTrue(root['my-package']['1.0'].release_files.get('foo.zip', b''))
self.assertIsInstance(root['my-package']['1.0']['foo.zip'], ReleaseFile)
self.assertEqual(root['my-package']['1.0'].release_files.get('foo.tar.gz', b'').size, 12)
class ListReleaseFileByReleaseViewTest(unittest.TestCase):
def setUp(self):
self.request = get_current_request()
def test_list_release(self):
# Initial data
<|code_end|>
. Write the next line using the current file imports:
import io
import json
import types
import unittest
from cgi import FieldStorage
from mock import patch
from pyramid import testing
from pyramid.authentication import AuthTktAuthenticationPolicy
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.httpexceptions import HTTPMovedPermanently
from pyramid.httpexceptions import HTTPNotFound
from pyramid.response import Response
from pyramid.threadlocal import get_current_request
from requests.exceptions import ConnectionError
from papaye.tests.tools import disable_cache, FakeGRequestResponse
from papaye.tests.tools import mock_proxy_response
from papaye.factories import models as factories
from papaye.views.simple import ListPackagesView
from papaye.views.simple import ListPackagesView
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import DownloadReleaseView
from papaye.models import ReleaseFile, Release, Package
from papaye.models import Root, Package, Release, ReleaseFile, STATUS
from papaye.views.simple import UploadView
from papaye.models import Root, Package, Release, ReleaseFile
from papaye.views.simple import UploadView
from papaye.models import Root, Package, Release, ReleaseFile
from papaye.views.simple import UploadView
from papaye.views.simple import ListReleaseFileByReleaseView
from papaye.models import Package, Release, ReleaseFile
from papaye.factories.root import repository_root_factory
from papaye.views.simple import ListReleaseFileByReleaseView
from papaye.models import Package, Release, ReleaseFile
from papaye.factories.root import repository_root_factory
from papaye.models import Root, Package, Release, ReleaseFile
from papaye.views.simple import UploadView
from papaye.models import User, Root
from papaye.views.index import LoginView
from papaye.models import User, Root
from papaye.views.index import LoginView
from papaye.views.simple import not_found
from papaye.views.simple import not_found
from papaye.views.simple import parse_matchdict
from papaye.views.simple import parse_matchdict
from papaye.views.simple import parse_matchdict
and context from other files:
# Path: papaye/tests/tools.py
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
#
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# Path: papaye/tests/tools.py
# def mock_proxy_response(mock, response=None, side_effect=False):
# if response is None:
# with open(get_resource('pyramid.json'), 'rb') as pyramid_json:
# pypi_response = FakeGRequestResponse(200, pyramid_json.read())
# mock.return_value = pypi_response
# else:
# attr = 'side_effect' if side_effect else 'return_value'
# setattr(mock, attr, response)
#
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
, which may include functions, classes, or code. Output only the next line. | 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.assertIsInstance(response['objects'], types.GeneratorType)
self.assertEqual([package.name for url, package in response['objects']], [])
class ListReleaseViewTest(unittest.TestCase):
def setUp(self):
self.request = get_current_request()
def test_list_releases_files(self):
# Test packages
root = factories.RootFactory()
package = factories.PackageFactory(name='package1', root=root)
release = factories.ReleaseFactory(
version='1.0', metadata={}, package=package
)
factories.ReleaseFileFactory(
filename='releasefile1.tar.gz',
content=b'',
md5_digest='12345',
release=release,
<|code_end|>
, generate the next line using the imports in this file:
import io
import json
import types
import unittest
from cgi import FieldStorage
from mock import patch
from pyramid import testing
from pyramid.authentication import AuthTktAuthenticationPolicy
from pyramid.authorization import ACLAuthorizationPolicy
from pyramid.httpexceptions import HTTPMovedPermanently
from pyramid.httpexceptions import HTTPNotFound
from pyramid.response import Response
from pyramid.threadlocal import get_current_request
from requests.exceptions import ConnectionError
from papaye.tests.tools import disable_cache, FakeGRequestResponse
from papaye.tests.tools import mock_proxy_response
from papaye.factories import models as factories
from papaye.views.simple import ListPackagesView
from papaye.views.simple import ListPackagesView
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import ListReleaseFileView
from papaye.models import Package, Release, Root, ReleaseFile
from papaye.views.simple import DownloadReleaseView
from papaye.models import ReleaseFile, Release, Package
from papaye.models import Root, Package, Release, ReleaseFile, STATUS
from papaye.views.simple import UploadView
from papaye.models import Root, Package, Release, ReleaseFile
from papaye.views.simple import UploadView
from papaye.models import Root, Package, Release, ReleaseFile
from papaye.views.simple import UploadView
from papaye.views.simple import ListReleaseFileByReleaseView
from papaye.models import Package, Release, ReleaseFile
from papaye.factories.root import repository_root_factory
from papaye.views.simple import ListReleaseFileByReleaseView
from papaye.models import Package, Release, ReleaseFile
from papaye.factories.root import repository_root_factory
from papaye.models import Root, Package, Release, ReleaseFile
from papaye.views.simple import UploadView
from papaye.models import User, Root
from papaye.views.index import LoginView
from papaye.models import User, Root
from papaye.views.index import LoginView
from papaye.views.simple import not_found
from papaye.views.simple import not_found
from papaye.views.simple import parse_matchdict
from papaye.views.simple import parse_matchdict
from papaye.views.simple import parse_matchdict
and context (functions, classes, or occasionally code) from other files:
# Path: papaye/tests/tools.py
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
#
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# Path: papaye/tests/tools.py
# def mock_proxy_response(mock, response=None, side_effect=False):
# if response is None:
# with open(get_resource('pyramid.json'), 'rb') as pyramid_json:
# pypi_response = FakeGRequestResponse(200, pyramid_json.read())
# mock.return_value = pypi_response
# else:
# attr = 'side_effect' if side_effect else 'return_value'
# setattr(mock, attr, response)
#
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
. Output only the next line. | ) |
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.ReleaseFactory(package=package, version='1.0')
for minor in ['a1', 'a2', 'b1', 'b2', 'rc1']:
factories.ReleaseFactory(
package=package,
version='1.0{}'.format(minor),
)
result = package.get_last_release()
self.assertEqual(result.version, '1.0')
def test_get_last_release_without_release(self):
package = factories.PackageFactory()
result = package.get_last_release()
self.assertIsNone(result)
def test_iter(self):
release = factories.ReleaseFactory()
package = release.package
<|code_end|>
. Use current file imports:
import types
import unittest
from mock import patch
from pyramid import testing
from pyramid.response import Response
from pyramid.threadlocal import get_current_request
from papaye.tests.tools import (
FakeGRequestResponse,
FakeRoute,
disable_cache,
remove_blob_dir,
set_database_connection,
get_resource,
)
from papaye.factories import models as factories
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Release
from papaye.models import Release
from papaye.models import Release
from papaye.factories.root import repository_root_factory
from papaye.models import Release
from papaye.models import Release
from papaye.models import Release, ReleaseFile
from papaye.models import Release
from papaye.models import Release, ReleaseFile
from papaye.models import Release, ReleaseFile
from papaye.models import ReleaseFile
from papaye.models import ReleaseFile, STATUS
from papaye.models import ReleaseFile, STATUS
from papaye.models import ReleaseFile
from papaye.models import User
from papaye.models import User
from papaye.factories.root import user_root_factory
from papaye.models import User
from papaye.models import SubscriptableBaseModel, Model
from papaye.models import Model, ClonableModelMixin
and context (classes, functions, or code) from other files:
# Path: papaye/tests/tools.py
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# class FakeRoute():
#
# def __init__(self, name):
# self.name = name
#
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
#
# def remove_blob_dir(blob_dir):
# shutil.rmtree(blob_dir)
#
# def set_database_connection(request, blob_dir=None, config=None):
# if not blob_dir:
# blob_dir = tempfile.mkdtemp('blobs')
# conn = get_db_connection(blob_dir)
# request._primary_zodb_conn = conn
# if config:
# import transaction
# conn.root()['repository'] = {}
# conn.root()['user'] = {}
# transaction.commit()
# config.registry._zodb_databases = {'': conn._db}
# return blob_dir
#
# def get_resource(*args):
# return os.path.join(TEST_RESOURCES, *args)
#
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
. Output only the next line. | 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.tar.gz'), 'rb') as tar_gz:
release_file = ReleaseFile('pyramid-1.5.tar.gz', tar_gz.read())
self.assertEqual(release_file.size, 2413504)
def test_instanciate(self):
with open(get_resource('pyramid-1.5.tar.gz'), 'rb') as tar_gz:
result = ReleaseFile('release file', tar_gz.read())
assert hasattr(result, 'status')
assert result.status == STATUS.cached
def test_instanciate_local(self):
with open(get_resource('pyramid-1.5.tar.gz'), 'rb') as tar_gz:
result = ReleaseFile('release file', tar_gz.read(), status=STATUS.local)
<|code_end|>
using the current file's imports:
import types
import unittest
from mock import patch
from pyramid import testing
from pyramid.response import Response
from pyramid.threadlocal import get_current_request
from papaye.tests.tools import (
FakeGRequestResponse,
FakeRoute,
disable_cache,
remove_blob_dir,
set_database_connection,
get_resource,
)
from papaye.factories import models as factories
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Release
from papaye.models import Release
from papaye.models import Release
from papaye.factories.root import repository_root_factory
from papaye.models import Release
from papaye.models import Release
from papaye.models import Release, ReleaseFile
from papaye.models import Release
from papaye.models import Release, ReleaseFile
from papaye.models import Release, ReleaseFile
from papaye.models import ReleaseFile
from papaye.models import ReleaseFile, STATUS
from papaye.models import ReleaseFile, STATUS
from papaye.models import ReleaseFile
from papaye.models import User
from papaye.models import User
from papaye.factories.root import user_root_factory
from papaye.models import User
from papaye.models import SubscriptableBaseModel, Model
from papaye.models import Model, ClonableModelMixin
and any relevant context from other files:
# Path: papaye/tests/tools.py
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# class FakeRoute():
#
# def __init__(self, name):
# self.name = name
#
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
#
# def remove_blob_dir(blob_dir):
# shutil.rmtree(blob_dir)
#
# def set_database_connection(request, blob_dir=None, config=None):
# if not blob_dir:
# blob_dir = tempfile.mkdtemp('blobs')
# conn = get_db_connection(blob_dir)
# request._primary_zodb_conn = conn
# if config:
# import transaction
# conn.root()['repository'] = {}
# conn.root()['user'] = {}
# transaction.commit()
# config.registry._zodb_databases = {'': conn._db}
# return blob_dir
#
# def get_resource(*args):
# return os.path.join(TEST_RESOURCES, *args)
#
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
. Output only the next line. | 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.assertEqual(result.password, expected)
def test_by_username(self):
root = user_root_factory(self.request)
root['a_user'] = User('a_user', 'password')
result = User.by_username('a_user', self.request)
self.assertIsInstance(result, User)
self.assertEqual(result.username, 'a_user')
def test_by_username_without_result(self):
result = User.by_username('a_user', self.request)
self.assertIsNone(result)
class SubscriptableModelTest(unittest.TestCase):
class Model(SubscriptableBaseModel, Model):
_subobjects_attr = 'attribute'
<|code_end|>
using the current file's imports:
import types
import unittest
from mock import patch
from pyramid import testing
from pyramid.response import Response
from pyramid.threadlocal import get_current_request
from papaye.tests.tools import (
FakeGRequestResponse,
FakeRoute,
disable_cache,
remove_blob_dir,
set_database_connection,
get_resource,
)
from papaye.factories import models as factories
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Release
from papaye.models import Release
from papaye.models import Release
from papaye.factories.root import repository_root_factory
from papaye.models import Release
from papaye.models import Release
from papaye.models import Release, ReleaseFile
from papaye.models import Release
from papaye.models import Release, ReleaseFile
from papaye.models import Release, ReleaseFile
from papaye.models import ReleaseFile
from papaye.models import ReleaseFile, STATUS
from papaye.models import ReleaseFile, STATUS
from papaye.models import ReleaseFile
from papaye.models import User
from papaye.models import User
from papaye.factories.root import user_root_factory
from papaye.models import User
from papaye.models import SubscriptableBaseModel, Model
from papaye.models import Model, ClonableModelMixin
and any relevant context from other files:
# Path: papaye/tests/tools.py
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# class FakeRoute():
#
# def __init__(self, name):
# self.name = name
#
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
#
# def remove_blob_dir(blob_dir):
# shutil.rmtree(blob_dir)
#
# def set_database_connection(request, blob_dir=None, config=None):
# if not blob_dir:
# blob_dir = tempfile.mkdtemp('blobs')
# conn = get_db_connection(blob_dir)
# request._primary_zodb_conn = conn
# if config:
# import transaction
# conn.root()['repository'] = {}
# conn.root()['user'] = {}
# transaction.commit()
# config.registry._zodb_databases = {'': conn._db}
# return blob_dir
#
# def get_resource(*args):
# return os.path.join(TEST_RESOURCES, *args)
#
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
. Output only the next line. | 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_file.filename
assert result.md5_digest == release_file.md5_digest
assert result.upload_date == release_file.upload_date
assert result.path == release_file.path
assert result.content_type == release_file.content_type
assert result.size == release_file.size
assert id(result) != id(release_file)
class UserTest(unittest.TestCase):
def setUp(self):
self.request = testing.DummyRequest(matched_route=FakeRoute('simple'))
self.blob_dir = set_database_connection(self.request)
self.config = testing.setUp(request=self.request)
def tearDown(self):
remove_blob_dir(self.blob_dir)
def test_hash_password(self):
expected = 'b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a'
expected += '2ea6d103fd07c95385ffab0cacbc86'
result = User('a_user', 'password')
<|code_end|>
, predict the immediate next line with the help of imports:
import types
import unittest
from mock import patch
from pyramid import testing
from pyramid.response import Response
from pyramid.threadlocal import get_current_request
from papaye.tests.tools import (
FakeGRequestResponse,
FakeRoute,
disable_cache,
remove_blob_dir,
set_database_connection,
get_resource,
)
from papaye.factories import models as factories
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Release
from papaye.models import Release
from papaye.models import Release
from papaye.factories.root import repository_root_factory
from papaye.models import Release
from papaye.models import Release
from papaye.models import Release, ReleaseFile
from papaye.models import Release
from papaye.models import Release, ReleaseFile
from papaye.models import Release, ReleaseFile
from papaye.models import ReleaseFile
from papaye.models import ReleaseFile, STATUS
from papaye.models import ReleaseFile, STATUS
from papaye.models import ReleaseFile
from papaye.models import User
from papaye.models import User
from papaye.factories.root import user_root_factory
from papaye.models import User
from papaye.models import SubscriptableBaseModel, Model
from papaye.models import Model, ClonableModelMixin
and context (classes, functions, sometimes code) from other files:
# Path: papaye/tests/tools.py
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# class FakeRoute():
#
# def __init__(self, name):
# self.name = name
#
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
#
# def remove_blob_dir(blob_dir):
# shutil.rmtree(blob_dir)
#
# def set_database_connection(request, blob_dir=None, config=None):
# if not blob_dir:
# blob_dir = tempfile.mkdtemp('blobs')
# conn = get_db_connection(blob_dir)
# request._primary_zodb_conn = conn
# if config:
# import transaction
# conn.root()['repository'] = {}
# conn.root()['user'] = {}
# transaction.commit()
# config.registry._zodb_databases = {'': conn._db}
# return blob_dir
#
# def get_resource(*args):
# return os.path.join(TEST_RESOURCES, *args)
#
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
. Output only the next line. | 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"}}')
mock.return_value = fake_response
# Test data
package = factories.PackageFactory()
result = Package.get_last_remote_version(True, package.name)
self.assertEqual(mock.call_count, 1)
self.assertIsNotNone(result)
self.assertEqual(result, '1.0')
@patch('requests.get')
def test_get_last_remote_version_with_proxy_404(self, mock):
fake_response = FakeGRequestResponse(status_code=404, content=b'{"info": {"version": "1.0"}}')
mock.return_value = fake_response
# Test data
package = factories.PackageFactory()
result = Package.get_last_remote_version(True, package.name)
self.assertEqual(mock.call_count, 1)
self.assertIsNone(result)
<|code_end|>
, generate the next line using the imports in this file:
import types
import unittest
from mock import patch
from pyramid import testing
from pyramid.response import Response
from pyramid.threadlocal import get_current_request
from papaye.tests.tools import (
FakeGRequestResponse,
FakeRoute,
disable_cache,
remove_blob_dir,
set_database_connection,
get_resource,
)
from papaye.factories import models as factories
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Release
from papaye.models import Release
from papaye.models import Release
from papaye.factories.root import repository_root_factory
from papaye.models import Release
from papaye.models import Release
from papaye.models import Release, ReleaseFile
from papaye.models import Release
from papaye.models import Release, ReleaseFile
from papaye.models import Release, ReleaseFile
from papaye.models import ReleaseFile
from papaye.models import ReleaseFile, STATUS
from papaye.models import ReleaseFile, STATUS
from papaye.models import ReleaseFile
from papaye.models import User
from papaye.models import User
from papaye.factories.root import user_root_factory
from papaye.models import User
from papaye.models import SubscriptableBaseModel, Model
from papaye.models import Model, ClonableModelMixin
and context (functions, classes, or occasionally code) from other files:
# Path: papaye/tests/tools.py
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# class FakeRoute():
#
# def __init__(self, name):
# self.name = name
#
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
#
# def remove_blob_dir(blob_dir):
# shutil.rmtree(blob_dir)
#
# def set_database_connection(request, blob_dir=None, config=None):
# if not blob_dir:
# blob_dir = tempfile.mkdtemp('blobs')
# conn = get_db_connection(blob_dir)
# request._primary_zodb_conn = conn
# if config:
# import transaction
# conn.root()['repository'] = {}
# conn.root()['user'] = {}
# transaction.commit()
# config.registry._zodb_databases = {'': conn._db}
# return blob_dir
#
# def get_resource(*args):
# return os.path.join(TEST_RESOURCES, *args)
#
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
. Output only the next line. | 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
result = iter(release)
assert isinstance(result, types.GeneratorType)
assert list(result) == [release_file, ]
def test_clone(self):
release = factories.ReleaseFactory(version='1.0')
result = Release.clone(release)
assert result is not release
assert result.name == release.name
assert result.version == release.version
assert result.original_metadata == release.original_metadata
assert result.metadata == release.metadata
assert hasattr(result, 'release_files')
assert len(list(result)) == len(list(release))
def test_get_item(self):
release = factories.ReleaseFactory(version='1.0')
<|code_end|>
, determine the next line of code. You have imports:
import types
import unittest
from mock import patch
from pyramid import testing
from pyramid.response import Response
from pyramid.threadlocal import get_current_request
from papaye.tests.tools import (
FakeGRequestResponse,
FakeRoute,
disable_cache,
remove_blob_dir,
set_database_connection,
get_resource,
)
from papaye.factories import models as factories
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Release
from papaye.models import Release
from papaye.models import Release
from papaye.factories.root import repository_root_factory
from papaye.models import Release
from papaye.models import Release
from papaye.models import Release, ReleaseFile
from papaye.models import Release
from papaye.models import Release, ReleaseFile
from papaye.models import Release, ReleaseFile
from papaye.models import ReleaseFile
from papaye.models import ReleaseFile, STATUS
from papaye.models import ReleaseFile, STATUS
from papaye.models import ReleaseFile
from papaye.models import User
from papaye.models import User
from papaye.factories.root import user_root_factory
from papaye.models import User
from papaye.models import SubscriptableBaseModel, Model
from papaye.models import Model, ClonableModelMixin
and context (class names, function names, or code) available:
# Path: papaye/tests/tools.py
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# class FakeRoute():
#
# def __init__(self, name):
# self.name = name
#
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
#
# def remove_blob_dir(blob_dir):
# shutil.rmtree(blob_dir)
#
# def set_database_connection(request, blob_dir=None, config=None):
# if not blob_dir:
# blob_dir = tempfile.mkdtemp('blobs')
# conn = get_db_connection(blob_dir)
# request._primary_zodb_conn = conn
# if config:
# import transaction
# conn.root()['repository'] = {}
# conn.root()['user'] = {}
# transaction.commit()
# config.registry._zodb_databases = {'': conn._db}
# return blob_dir
#
# def get_resource(*args):
# return os.path.join(TEST_RESOURCES, *args)
#
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
. Output only the next line. | 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):
model_instance = self.Model(name='name')
model_instance.attribute = {'test': 'ok'}
result = model_instance.get('oups', None)
self.assertIsNone(result)
class BaseModelTest(unittest.TestCase):
class TestModel(ClonableModelMixin, Model):
def __init__(self, attr1, attr2):
self.attr1 = attr1
self.attr2 = attr2
def test_clone(self):
model = self.TestModel('one', 'two')
result = self.TestModel.clone(model)
assert result is not model
<|code_end|>
. Use current file imports:
import types
import unittest
from mock import patch
from pyramid import testing
from pyramid.response import Response
from pyramid.threadlocal import get_current_request
from papaye.tests.tools import (
FakeGRequestResponse,
FakeRoute,
disable_cache,
remove_blob_dir,
set_database_connection,
get_resource,
)
from papaye.factories import models as factories
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Package
from papaye.models import Release
from papaye.models import Release
from papaye.models import Release
from papaye.factories.root import repository_root_factory
from papaye.models import Release
from papaye.models import Release
from papaye.models import Release, ReleaseFile
from papaye.models import Release
from papaye.models import Release, ReleaseFile
from papaye.models import Release, ReleaseFile
from papaye.models import ReleaseFile
from papaye.models import ReleaseFile, STATUS
from papaye.models import ReleaseFile, STATUS
from papaye.models import ReleaseFile
from papaye.models import User
from papaye.models import User
from papaye.factories.root import user_root_factory
from papaye.models import User
from papaye.models import SubscriptableBaseModel, Model
from papaye.models import Model, ClonableModelMixin
and context (classes, functions, or code) from other files:
# Path: papaye/tests/tools.py
# class FakeGRequestResponse():
#
# def __init__(self, status_code, content, url="https://fake/url/"):
# self.status_code = status_code
# self.content = content
# self.url = url
#
# class FakeRoute():
#
# def __init__(self, name):
# self.name = name
#
# def disable_cache(settings=None):
# cache_settings = {
# 'cache.regions': 'pypi',
# 'cache.enabled': 'false',
# }
# if settings:
# settings.update(cache_settings)
# else:
# settings = cache_settings
# set_cache_regions_from_settings(settings)
# return settings
#
# def remove_blob_dir(blob_dir):
# shutil.rmtree(blob_dir)
#
# def set_database_connection(request, blob_dir=None, config=None):
# if not blob_dir:
# blob_dir = tempfile.mkdtemp('blobs')
# conn = get_db_connection(blob_dir)
# request._primary_zodb_conn = conn
# if config:
# import transaction
# conn.root()['repository'] = {}
# conn.root()['user'] = {}
# transaction.commit()
# config.registry._zodb_databases = {'': conn._db}
# return blob_dir
#
# def get_resource(*args):
# return os.path.join(TEST_RESOURCES, *args)
#
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
. Output only the next line. | 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 = colander.SchemaNode(colander.String())
summary = colander.SchemaNode(String(), missing=None)
def get_data(self, package):
data = super().get_data(package)
if package.metadata and 'summary' in package.metadata:
data['summary'] = package.metadata.get('summary')
else:
data['summary'] = None
return data
class ReleaseAPISerializer(Serializer):
name = colander.SchemaNode(String())
version = colander.SchemaNode(String())
gravatar_hash = colander.SchemaNode(String(), missing=None)
metadata = APIMetadata(typ=NullableMapping(), missing=None)
download_url = colander.SchemaNode(String())
other_releases = APIOtherReleases()
release_files = APIReleaseFiles()
def __init__(self, request):
<|code_end|>
, determine the next line of code. You have imports:
import colander
import hashlib
from papaye.schemas import APIMetadata, String, APIReleaseFiles
from papaye.schemas import APIOtherReleases, NullableMapping
and context (class names, function names, or code) available:
# Path: papaye/schemas.py
# class APIMetadata(colander.MappingSchema):
# version = colander.SchemaNode(String(), missing=None)
# author = colander.SchemaNode(String(), missing=None)
# author_email = colander.SchemaNode(String(), missing=None)
# home_page = colander.SchemaNode(String(), missing=None)
# keywords = colander.SchemaNode(Tags(), default=[])
# license = colander.SchemaNode(String(), missing=None)
# summary = colander.SchemaNode(String(), missing=None)
# maintainer = colander.SchemaNode(String(), missing=None)
# maintainer_email = colander.SchemaNode(String(), missing=None)
# description = APIDescription(typ=NullableMapping(), missing=None)
# platform = colander.SchemaNode(String(), missing=None)
# classifiers = colander.SchemaNode(Classifiers(), default=[])
# name = colander.SchemaNode(String(), missing=None)
#
# class String(colander.String):
#
# def serialize(self, node, appstruct):
# if appstruct is None:
# appstruct = colander.null
# return super().serialize(node, appstruct)
#
# class APIReleaseFiles(colander.SequenceSchema):
# release_files = ReleaseFile()
#
# Path: papaye/schemas.py
# class APIOtherReleases(colander.SequenceSchema):
# other_releases = APIOtherRelease()
#
# class NullableMapping(colander.Mapping):
#
# def serialize(self, node, appstruct):
# if appstruct is None or appstruct == {}:
# return colander.null
# return super(NullableMapping, self).serialize(node, appstruct)
#
# def deserialize(self, node, cstruct):
# if cstruct == colander.null or cstruct == {}:
# return None
# return super(NullableMapping, self).deserialize(node, cstruct)
. Output only the next line. | 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 in attributes.items()
if isinstance(attribute, colander.SchemaNode)}
return super(Serializer, cls).__new__(cls)
<|code_end|>
, predict the immediate next line with the help of imports:
import colander
import hashlib
from papaye.schemas import APIMetadata, String, APIReleaseFiles
from papaye.schemas import APIOtherReleases, NullableMapping
and context (classes, functions, sometimes code) from other files:
# Path: papaye/schemas.py
# class APIMetadata(colander.MappingSchema):
# version = colander.SchemaNode(String(), missing=None)
# author = colander.SchemaNode(String(), missing=None)
# author_email = colander.SchemaNode(String(), missing=None)
# home_page = colander.SchemaNode(String(), missing=None)
# keywords = colander.SchemaNode(Tags(), default=[])
# license = colander.SchemaNode(String(), missing=None)
# summary = colander.SchemaNode(String(), missing=None)
# maintainer = colander.SchemaNode(String(), missing=None)
# maintainer_email = colander.SchemaNode(String(), missing=None)
# description = APIDescription(typ=NullableMapping(), missing=None)
# platform = colander.SchemaNode(String(), missing=None)
# classifiers = colander.SchemaNode(Classifiers(), default=[])
# name = colander.SchemaNode(String(), missing=None)
#
# class String(colander.String):
#
# def serialize(self, node, appstruct):
# if appstruct is None:
# appstruct = colander.null
# return super().serialize(node, appstruct)
#
# class APIReleaseFiles(colander.SequenceSchema):
# release_files = ReleaseFile()
#
# Path: papaye/schemas.py
# class APIOtherReleases(colander.SequenceSchema):
# other_releases = APIOtherRelease()
#
# class NullableMapping(colander.Mapping):
#
# def serialize(self, node, appstruct):
# if appstruct is None or appstruct == {}:
# return colander.null
# return super(NullableMapping, self).serialize(node, appstruct)
#
# def deserialize(self, node, cstruct):
# if cstruct == colander.null or cstruct == {}:
# return None
# return super(NullableMapping, self).deserialize(node, cstruct)
. Output only the next line. | @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 attributes.items()
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: node for name, node in self.fields.items() if isinstance(node, colander.SchemaNode)}
<|code_end|>
. Write the next line using the current file imports:
import colander
import hashlib
from papaye.schemas import APIMetadata, String, APIReleaseFiles
from papaye.schemas import APIOtherReleases, NullableMapping
and context from other files:
# Path: papaye/schemas.py
# class APIMetadata(colander.MappingSchema):
# version = colander.SchemaNode(String(), missing=None)
# author = colander.SchemaNode(String(), missing=None)
# author_email = colander.SchemaNode(String(), missing=None)
# home_page = colander.SchemaNode(String(), missing=None)
# keywords = colander.SchemaNode(Tags(), default=[])
# license = colander.SchemaNode(String(), missing=None)
# summary = colander.SchemaNode(String(), missing=None)
# maintainer = colander.SchemaNode(String(), missing=None)
# maintainer_email = colander.SchemaNode(String(), missing=None)
# description = APIDescription(typ=NullableMapping(), missing=None)
# platform = colander.SchemaNode(String(), missing=None)
# classifiers = colander.SchemaNode(Classifiers(), default=[])
# name = colander.SchemaNode(String(), missing=None)
#
# class String(colander.String):
#
# def serialize(self, node, appstruct):
# if appstruct is None:
# appstruct = colander.null
# return super().serialize(node, appstruct)
#
# class APIReleaseFiles(colander.SequenceSchema):
# release_files = ReleaseFile()
#
# Path: papaye/schemas.py
# class APIOtherReleases(colander.SequenceSchema):
# other_releases = APIOtherRelease()
#
# class NullableMapping(colander.Mapping):
#
# def serialize(self, node, appstruct):
# if appstruct is None or appstruct == {}:
# return colander.null
# return super(NullableMapping, self).serialize(node, appstruct)
#
# def deserialize(self, node, cstruct):
# if cstruct == colander.null or cstruct == {}:
# return None
# return super(NullableMapping, self).deserialize(node, cstruct)
, which may include functions, classes, or code. Output only the next line. | 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: node for name, node in self.fields.items() if isinstance(node, colander.SchemaNode)}
if nodes:
for name, node in nodes.items():
node.name = name
schema.add(node)
self._schema = schema
return self._schema
def serialize(self, obj):
data = self.get_data(obj)
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 = colander.SchemaNode(colander.String())
summary = colander.SchemaNode(String(), missing=None)
def get_data(self, package):
data = super().get_data(package)
<|code_end|>
. Use current file imports:
import colander
import hashlib
from papaye.schemas import APIMetadata, String, APIReleaseFiles
from papaye.schemas import APIOtherReleases, NullableMapping
and context (classes, functions, or code) from other files:
# Path: papaye/schemas.py
# class APIMetadata(colander.MappingSchema):
# version = colander.SchemaNode(String(), missing=None)
# author = colander.SchemaNode(String(), missing=None)
# author_email = colander.SchemaNode(String(), missing=None)
# home_page = colander.SchemaNode(String(), missing=None)
# keywords = colander.SchemaNode(Tags(), default=[])
# license = colander.SchemaNode(String(), missing=None)
# summary = colander.SchemaNode(String(), missing=None)
# maintainer = colander.SchemaNode(String(), missing=None)
# maintainer_email = colander.SchemaNode(String(), missing=None)
# description = APIDescription(typ=NullableMapping(), missing=None)
# platform = colander.SchemaNode(String(), missing=None)
# classifiers = colander.SchemaNode(Classifiers(), default=[])
# name = colander.SchemaNode(String(), missing=None)
#
# class String(colander.String):
#
# def serialize(self, node, appstruct):
# if appstruct is None:
# appstruct = colander.null
# return super().serialize(node, appstruct)
#
# class APIReleaseFiles(colander.SequenceSchema):
# release_files = ReleaseFile()
#
# Path: papaye/schemas.py
# class APIOtherReleases(colander.SequenceSchema):
# other_releases = APIOtherRelease()
#
# class NullableMapping(colander.Mapping):
#
# def serialize(self, node, appstruct):
# if appstruct is None or appstruct == {}:
# return colander.null
# return super(NullableMapping, self).serialize(node, appstruct)
#
# def deserialize(self, node, cstruct):
# if cstruct == colander.null or cstruct == {}:
# return None
# return super(NullableMapping, self).deserialize(node, cstruct)
. Output only the next line. | 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 attributes.items()
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: node for name, node in self.fields.items() if isinstance(node, colander.SchemaNode)}
if nodes:
for name, node in nodes.items():
node.name = name
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import colander
import hashlib
from papaye.schemas import APIMetadata, String, APIReleaseFiles
from papaye.schemas import APIOtherReleases, NullableMapping
and context:
# Path: papaye/schemas.py
# class APIMetadata(colander.MappingSchema):
# version = colander.SchemaNode(String(), missing=None)
# author = colander.SchemaNode(String(), missing=None)
# author_email = colander.SchemaNode(String(), missing=None)
# home_page = colander.SchemaNode(String(), missing=None)
# keywords = colander.SchemaNode(Tags(), default=[])
# license = colander.SchemaNode(String(), missing=None)
# summary = colander.SchemaNode(String(), missing=None)
# maintainer = colander.SchemaNode(String(), missing=None)
# maintainer_email = colander.SchemaNode(String(), missing=None)
# description = APIDescription(typ=NullableMapping(), missing=None)
# platform = colander.SchemaNode(String(), missing=None)
# classifiers = colander.SchemaNode(Classifiers(), default=[])
# name = colander.SchemaNode(String(), missing=None)
#
# class String(colander.String):
#
# def serialize(self, node, appstruct):
# if appstruct is None:
# appstruct = colander.null
# return super().serialize(node, appstruct)
#
# class APIReleaseFiles(colander.SequenceSchema):
# release_files = ReleaseFile()
#
# Path: papaye/schemas.py
# class APIOtherReleases(colander.SequenceSchema):
# other_releases = APIOtherRelease()
#
# class NullableMapping(colander.Mapping):
#
# def serialize(self, node, appstruct):
# if appstruct is None or appstruct == {}:
# return colander.null
# return super(NullableMapping, self).serialize(node, appstruct)
#
# def deserialize(self, node, cstruct):
# if cstruct == colander.null or cstruct == {}:
# return None
# return super(NullableMapping, self).deserialize(node, cstruct)
which might include code, classes, or functions. Output only the next line. | 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.releases:
release = package[release_name]
for release_filename in release.release_files:
release_file = release[release_filename]
if None in release.original_metadata:
release_file.status = STATUS.local
print(release_file.__name__ + ' --> local')
else:
release_file.status = STATUS.cached
<|code_end|>
, determine the next line of code. You have imports:
from papaye.models import STATUS
from papaye.evolve.managers import load_model, context_from_root
and context (class names, function names, or code) available:
# Path: papaye/models.py
# STATUS = status_type(*range(0, len(status_type._fields)))
#
# Path: papaye/evolve/managers.py
# def load_model(model_name):
# def decorated(func):
# func.load_model = importlib.import_module(model_name)
# return func
# return decorated
#
# def context_from_root(root):
# return root[APP_ROOT_NAME]
. Output only the next line. | 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.releases:
release = package[release_name]
for release_filename in release.release_files:
release_file = release[release_filename]
if None in release.original_metadata:
release_file.status = STATUS.local
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from papaye.models import STATUS
from papaye.evolve.managers import load_model, context_from_root
and context:
# Path: papaye/models.py
# STATUS = status_type(*range(0, len(status_type._fields)))
#
# Path: papaye/evolve/managers.py
# def load_model(model_name):
# def decorated(func):
# func.load_model = importlib.import_module(model_name)
# return func
# return decorated
#
# def context_from_root(root):
# return root[APP_ROOT_NAME]
which might include code, classes, or functions. Output only the next line. | 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 package.releases:
<|code_end|>
. Use current file imports:
from papaye.models import STATUS
from papaye.evolve.managers import load_model, context_from_root
and context (classes, functions, or code) from other files:
# Path: papaye/models.py
# STATUS = status_type(*range(0, len(status_type._fields)))
#
# Path: papaye/evolve/managers.py
# def load_model(model_name):
# def decorated(func):
# func.load_model = importlib.import_module(model_name)
# return func
# return decorated
#
# def context_from_root(root):
# return root[APP_ROOT_NAME]
. Output only the next line. | 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.get_root()
manager = ZODBEvolutionManager(
root,
evolve_packagename='papaye.evolve',
sw_version=0,
initial_db_version=0
)
mock.return_value = manager
# Remove app_root
del(self.config.registry._zodb_databases[''].open().root()['papaye_root'])
transaction.commit()
self.assertRaises(ConfigurationError, check_database_config, self.config)
class SchedulerTest(object):
def __init__(self, *args, **kwargs):
pass
def start(self):
<|code_end|>
, determine the next line of code. You have imports:
import mock
import shutil
import unittest
import transaction
from mock import patch
from pyramid import testing
from pyramid.config import Configurator
from pyramid.threadlocal import get_current_request
from repoze.evolution import ZODBEvolutionManager
from papaye.factories import models as factories
from papaye.tests.tools import set_database_connection
from papaye.config.startup import check_database_config
from papaye.config.startup import check_database_config
from pyramid.config import ConfigurationError
from papaye.config.startup import check_database_config
from pyramid.config import ConfigurationError
from papaye.config.startup import start_scheduler
from papaye.config.utils import SettingsReader
from papaye.config.startup import start_scheduler
from papaye.tasks.devices import DummyScheduler
from papaye.config.utils import SettingsReader
from papaye.config.startup import start_scheduler
from papaye.tasks.devices import DummyScheduler
from papaye.config.utils import SettingsReader
and context (class names, function names, or code) available:
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
#
# Path: papaye/tests/tools.py
# def set_database_connection(request, blob_dir=None, config=None):
# if not blob_dir:
# blob_dir = tempfile.mkdtemp('blobs')
# conn = get_db_connection(blob_dir)
# request._primary_zodb_conn = conn
# if config:
# import transaction
# conn.root()['repository'] = {}
# conn.root()['user'] = {}
# transaction.commit()
# config.registry._zodb_databases = {'': conn._db}
# return blob_dir
. Output only the next line. | 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
)
def tearDown(self):
shutil.rmtree(self.blob_dir)
def get_root(self):
root = factories.RootFactory()
def root_func():
return {'papaye_root': {'repository': {}, 'user': {}}}
class P_jar:
pass
<|code_end|>
. Write the next line using the current file imports:
import mock
import shutil
import unittest
import transaction
from mock import patch
from pyramid import testing
from pyramid.config import Configurator
from pyramid.threadlocal import get_current_request
from repoze.evolution import ZODBEvolutionManager
from papaye.factories import models as factories
from papaye.tests.tools import set_database_connection
from papaye.config.startup import check_database_config
from papaye.config.startup import check_database_config
from pyramid.config import ConfigurationError
from papaye.config.startup import check_database_config
from pyramid.config import ConfigurationError
from papaye.config.startup import start_scheduler
from papaye.config.utils import SettingsReader
from papaye.config.startup import start_scheduler
from papaye.tasks.devices import DummyScheduler
from papaye.config.utils import SettingsReader
from papaye.config.startup import start_scheduler
from papaye.tasks.devices import DummyScheduler
from papaye.config.utils import SettingsReader
and context from other files:
# Path: papaye/factories/models.py
# class RootFactory(factory.Factory):
# class Meta:
# class PackageFactory(factory.Factory):
# class Meta:
# class ReleaseFactory(factory.Factory):
# class Meta:
# class ReleaseFileFactory(factory.Factory):
# class Meta:
#
# Path: papaye/tests/tools.py
# def set_database_connection(request, blob_dir=None, config=None):
# if not blob_dir:
# blob_dir = tempfile.mkdtemp('blobs')
# conn = get_db_connection(blob_dir)
# request._primary_zodb_conn = conn
# if config:
# import transaction
# conn.root()['repository'] = {}
# conn.root()['user'] = {}
# transaction.commit()
# config.registry._zodb_databases = {'': conn._db}
# return blob_dir
, which may include functions, classes, or code. Output only the next line. | 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 (value.strip() for value in cstruct.split('\n')) if value != '']
elif isinstance(cstruct, list):
return cstruct
else:
raise colander.Invalid(node, '%r is not a string or list' % cstruct)
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
def deserialize(self, node, cstruct):
if cstruct == colander.null:
return None
if not isinstance(cstruct, (str, bytes)):
<|code_end|>
. Use current file imports:
(import colander
from docutils.core import publish_parts
from papaye.evolve.managers import load_model, context_from_root)
and context including class names, function names, or small code snippets from other files:
# Path: papaye/evolve/managers.py
# def load_model(model_name):
# def decorated(func):
# func.load_model = importlib.import_module(model_name)
# return func
# return decorated
#
# def context_from_root(root):
# return root[APP_ROOT_NAME]
. Output only the next line. | 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
def deserialize(self, node, cstruct):
if cstruct == colander.null:
return None
if not isinstance(cstruct, (str, bytes)):
raise colander.Invalid(node, '%r is not a string' % cstruct)
else:
try:
return {'content': publish_parts(cstruct, writer_name='html')['fragment'], 'html': True}
except:
return {'content': cstruct, 'html': False}
class APIDescription(colander.MappingSchema):
content = colander.SchemaNode(colander.String())
html = colander.SchemaNode(colander.Boolean())
class ReleaseFile(colander.MappingSchema):
filename = colander.SchemaNode(colander.String())
version = colander.SchemaNode(colander.String())
upload_date = colander.SchemaNode(colander.String())
<|code_end|>
, predict the immediate next line with the help of imports:
import colander
from docutils.core import publish_parts
from papaye.evolve.managers import load_model, context_from_root
and context (classes, functions, sometimes code) from other files:
# Path: papaye/evolve/managers.py
# def load_model(model_name):
# def decorated(func):
# func.load_model = importlib.import_module(model_name)
# return func
# return decorated
#
# def context_from_root(root):
# return root[APP_ROOT_NAME]
. Output only the next line. | 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(model_name)
return func
return decorated
def out_model(model_name):
model = importlib.import_module(model_name)
def wrapper(func):
<|code_end|>
, predict the immediate next line with the help of imports:
import importlib
import sys
import transaction
from pkg_resources import EntryPoint
from repoze.evolution.interfaces import IEvolutionManager
from termcolor import colored
from zope.interface import implementer
from papaye.factories.root import APP_ROOT_NAME
and context (classes, functions, sometimes code) from other files:
# Path: papaye/factories/root.py
# APP_ROOT_NAME = '{}_root'.format(APP_NAME)
. Output only the next line. | 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['maintainer'], None)
self.assertEqual(result['maintainer_email'], None)
self.assertEqual(
result['description'],
{
'html': True,
'content': publish_parts(cstruct['description'], writer_name='html')['fragment'],
}
)
self.assertEqual(result['platform'], 'UNKNOWN')
self.assertEqual(result['classifiers'], expected_classifiers)
self.assertEqual(result['name'], 'papaye')
def test_deserialize_with_empty_metadata(self):
schema = Metadata()
expected_keys = sorted([
'version',
'author',
'author_email',
'home_page',
'keywords',
'license',
'summary',
'maintainer',
'maintainer_email',
'description',
'platform',
<|code_end|>
, predict the next line using imports from the current file:
import json
import unittest
from docutils.core import publish_parts
from papaye.tests.tools import get_resource
from papaye.schemas import Metadata
from papaye.schemas import Metadata
from papaye.schemas import Metadata
and context including class names, function names, and sometimes code from other files:
# Path: papaye/tests/tools.py
# def get_resource(*args):
# return os.path.join(TEST_RESOURCES, *args)
. Output only the next line. | '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_root(root)
settings = SettingsReader(config)
packages_dir = settings.read_str('papaye.packages_directory')
if os.path.exists(packages_dir):
raise EvolveError('The repository directory is already exists. '
'Please remove them or choose another directory '
'in your settings file ({})'.format(
config.registry._settings.get('__file__', None)
))
tmpdir = tempfile.mkdtemp('packages_directory')
for package in context['repository']:
for release in package:
for release_file in release:
release_file.uuid = uuid.uuid4()
pkg_dir_relative_path = compute_release_file_directory(
release_file
)
dir = os.path.join(tmpdir, pkg_dir_relative_path)
os.makedirs(dir, exist_ok=True)
path = os.path.join(dir, release_file.filename)
with open(path, 'wb') as archive:
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import shutil
import tempfile
import uuid
from papaye.evolve.managers import load_model, context_from_root, APP_ROOT_NAME
from papaye.evolve.managers import EvolveError
from papaye.config.utils import SettingsReader
from papaye.models import Root, Package, Release, ReleaseFile, User
and context (classes, functions, sometimes code) from other files:
# Path: papaye/evolve/managers.py
# def cleanup():
# def load_model(model_name):
# def decorated(func):
# def out_model(model_name):
# def wrapper(func):
# def wrapped(root):
# def context_from_root(root):
# def error(msg):
# def __init__(self, config, evolve_packagename, sw_version,
# initial_db_version=None):
# def _get_root(self, version=None, old_model_module=None):
# def get_sw_version(self):
# def get_db_version(self):
# def set_db_version(self, root, version):
# def evolve_to(self, version):
# def task(self, string):
# def step(self, version, evmodule):
# def information(self, title, string):
# def evolve_to_current(self):
# class EvolveError(BaseException):
# class PapayeEvolutionManager(object):
#
# Path: papaye/evolve/managers.py
# class EvolveError(BaseException):
# pass
#
# Path: papaye/config/utils.py
# class SettingsReader(object):
#
# def __init__(self, configuration_or_settings):
# self.settings = self.get_settings(configuration_or_settings)
#
# def get_settings(self, configuration_or_settings):
# if isinstance(configuration_or_settings, Configurator):
# return configuration_or_settings.get_settings()
# else:
# return configuration_or_settings
#
# def read_bool(self, option, default=False):
# value = self.settings.get(option)
# if not value:
# return default
# else:
# return asbool(value)
#
# def read_str(self, option, default=None):
# return self.settings.get(option, default)
. Output only the next line. | 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(time_low)))
return os.path.join(*path)
@load_model('papaye.evolve.models.snapshot2')
def evolve(root, config):
context = context_from_root(root)
settings = SettingsReader(config)
packages_dir = settings.read_str('papaye.packages_directory')
if os.path.exists(packages_dir):
raise EvolveError('The repository directory is already exists. '
'Please remove them or choose another directory '
'in your settings file ({})'.format(
config.registry._settings.get('__file__', None)
))
tmpdir = tempfile.mkdtemp('packages_directory')
<|code_end|>
. Use current file imports:
(import os
import shutil
import tempfile
import uuid
from papaye.evolve.managers import load_model, context_from_root, APP_ROOT_NAME
from papaye.evolve.managers import EvolveError
from papaye.config.utils import SettingsReader
from papaye.models import Root, Package, Release, ReleaseFile, User)
and context including class names, function names, or small code snippets from other files:
# Path: papaye/evolve/managers.py
# def cleanup():
# def load_model(model_name):
# def decorated(func):
# def out_model(model_name):
# def wrapper(func):
# def wrapped(root):
# def context_from_root(root):
# def error(msg):
# def __init__(self, config, evolve_packagename, sw_version,
# initial_db_version=None):
# def _get_root(self, version=None, old_model_module=None):
# def get_sw_version(self):
# def get_db_version(self):
# def set_db_version(self, root, version):
# def evolve_to(self, version):
# def task(self, string):
# def step(self, version, evmodule):
# def information(self, title, string):
# def evolve_to_current(self):
# class EvolveError(BaseException):
# class PapayeEvolutionManager(object):
#
# Path: papaye/evolve/managers.py
# class EvolveError(BaseException):
# pass
#
# Path: papaye/config/utils.py
# class SettingsReader(object):
#
# def __init__(self, configuration_or_settings):
# self.settings = self.get_settings(configuration_or_settings)
#
# def get_settings(self, configuration_or_settings):
# if isinstance(configuration_or_settings, Configurator):
# return configuration_or_settings.get_settings()
# else:
# return configuration_or_settings
#
# def read_bool(self, option, default=False):
# value = self.settings.get(option)
# if not value:
# return default
# else:
# return asbool(value)
#
# def read_str(self, option, default=None):
# return self.settings.get(option, default)
. Output only the next line. | 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': {
'debug': False,
},
'urls': {
'login': request.route_url('login'),
'logout': request.route_url('logout'),
'package_resource': request.route_url('packages'),
'api': request.route_url('api'),
'simple': request.route_url('simple', traverse=()),
}
}
return {'app_context': json.dumps(app_context)}
@view_config(route_name="login", renderer='login.jinja2',
permission=NO_PERMISSION_REQUIRED)
class LoginView(object):
def __init__(self, request):
self.request = request
self.schema = LoginSchema().bind(request=self.request)
self.form = Form(self.schema, buttons=('submit', ))
<|code_end|>
, predict the next line using imports from the current file:
import json
import logging
from deform import Form
from deform.exception import ValidationFailure
from pyramid.httpexceptions import HTTPMovedPermanently
from pyramid.response import Response
from pyramid.security import remember, NO_PERMISSION_REQUIRED
from pyramid.view import view_config
from papaye.schemas import LoginSchema
from pyramid.security import forget
and context including class names, function names, and sometimes code from other files:
# Path: papaye/schemas.py
# class LoginSchema(colander.MappingSchema):
# username = colander.SchemaNode(String(), missing=None,
# validator=username_validator)
# password = colander.SchemaNode(
# String(), missing=None, widget=PasswordWidget()
# )
#
# def validator(self, node, appstruct):
# request = node.bindings['request']
# username = appstruct.get('username') or ''
# password = appstruct.get('password') or ''
# error = colander.Invalid(node, 'username and/or password invalid')
# username_matching_users = [
# user for user in request.root
# if user.username == username
# ]
# if not len(username_matching_users):
# raise error
# user = username_matching_users[0]
# if not user.password_verify(password):
# raise error
. Output only the next line. | 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 None:
<|code_end|>
, determine the next line of code. You have imports:
import colander
from docutils.core import publish_parts
from papaye.evolve.managers import load_model, context_from_root
and context (class names, function names, or code) available:
# Path: papaye/evolve/managers.py
# def load_model(model_name):
# def decorated(func):
# func.load_model = importlib.import_module(model_name)
# return func
# return decorated
#
# def context_from_root(root):
# return root[APP_ROOT_NAME]
. Output only the next line. | 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.SchemaNode(colander.String(), missing=None)
html = colander.SchemaNode(colander.Boolean())
class ReleaseFile(colander.MappingSchema):
filename = colander.SchemaNode(colander.String())
version = colander.SchemaNode(colander.String())
upload_date = colander.SchemaNode(colander.String())
size = colander.SchemaNode(colander.String())
url = colander.SchemaNode(colander.String())
class APIOtherRelease(colander.MappingSchema):
url = colander.SchemaNode(colander.String())
version = colander.SchemaNode(colander.String())
class APIOtherReleases(colander.SequenceSchema):
other_releases = APIOtherRelease()
class APIReleaseFiles(colander.SequenceSchema):
<|code_end|>
using the current file's imports:
import colander
from docutils.core import publish_parts
from papaye.evolve.managers import load_model, context_from_root
and any relevant context from other files:
# Path: papaye/evolve/managers.py
# def load_model(model_name):
# def decorated(func):
# func.load_model = importlib.import_module(model_name)
# return func
# return decorated
#
# def context_from_root(root):
# return root[APP_ROOT_NAME]
. Output only the next line. | release_files = ReleaseFile() |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.