Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Predict the next line after this snippet: <|code_start|>
class BaseCorrector(object):
def __init__(self):
self.data = file(os.path.join(settings.DATA_PATH, "big.txt")).read()
<|code_end|>
using the current file's imports:
from scan import settings
import re
import os
and any relevant context from other files:
# Path: scan/settings.py
# DB_URL = 'sqlite:///scan.db'
# DEBUG = True
# ROOT_PATH = path(__file__).dirname()
# REPO_PATH = ROOT_PATH.dirname()
# ENV_ROOT = REPO_PATH.dirname()
# DATA_PATH = os.path.join(REPO_PATH, "data")
# TEST_DATA_PATH = os.path.join(DATA_PATH, "test")
# MODEL_PATH = os.path.join(DATA_PATH, "models")
# SECRET_KEY = "30y^$e7henbp@#_w+z9)o9f8tovjrhoq(%vw=%#*(1-1esrh!_"
# USERNAME = "test"
# EMAIL = "test@test.com"
# PASSWORD = "test"
# SQLALCHEMY_DATABASE_URI = DB_URL
# SECURITY_REGISTERABLE = True
# SECURITY_RECOVERABLE = True
# SECURITY_SEND_REGISTER_EMAIL = False
# SECURITY_PASSWORD_HASH = "bcrypt"
# SECURITY_PASSWORD_SALT = SECRET_KEY
# BROKER_TRANSPORT_OPTIONS = {'visibility_timeout': 3600}
# BROKER_URL = 'redis://localhost:6379/3'
# CELERY_RESULT_BACKEND = 'redis://localhost:6379/3'
# CELERY_IMPORTS = ('core.tasks.tasks',)
# CACHE_TYPE = 'redis'
# CACHE_REDIS_URL = 'redis://localhost:6379/4'
# CACHE_REDIS_DB = 4
# MAX_FEATURES = 500
# MODEL_VERSION = 1
. Output only the next line. | def words(self, text): |
Here is a snippet: <|code_start|> min_samples_leaf=3,
random_state=1
)
self.fit_feats()
self.fit_done = False
def fit_feats(self):
self.feature_generator.fit(self.text, self.scores)
def get_features(self):
feats = []
for t in self.text:
feats.append(self.feature_generator.get_features(t))
feat_mat = np.vstack(feats)
return feat_mat
def train(self):
feats = self.get_features()
scores = np.array(self.scores)
# Compute error metrics for the estimator.
self.cv_scores = cross_validation.cross_val_score(self.classifier, feats, scores)
self.cv_score = self.cv_scores.mean()
self.cv_dev = self.cv_scores.std()
self.classifier.fit(feats, scores)
self.fit_done = True
<|code_end|>
. Write the next line using the current file imports:
import calendar
import numpy as np
import os
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
from core.algo.features import FeatureGenerator
from sklearn import cross_validation
from sklearn.externals import joblib
from core.database.models import Model
from app import db
from datetime import datetime
from scan import settings
and context from other files:
# Path: core/algo/features.py
# class FeatureGenerator(object):
# def __init__(self, normal_vectorizer=None, clean_vectorizer=None):
# self.mf_generator = MetaFeatureGenerator()
# self.fit_complete = False
# if normal_vectorizer and clean_vectorizer:
# self.fit_complete = True
#
# if normal_vectorizer:
# self.normal_vectorizer = normal_vectorizer
# else:
# self.normal_vectorizer = Vectorizer()
#
# if clean_vectorizer:
# self.clean_vectorizer = clean_vectorizer
# else:
# self.clean_vectorizer = Vectorizer()
#
# def fit(self, input_text, input_scores):
# self.normal_vectorizer.fit(input_text, input_scores)
# clean_text = [self.mf_generator.generate_clean_stem_text(t) for t in input_text]
# self.clean_vectorizer.fit(clean_text, input_scores)
#
# def get_features(self, text):
# vec_feats = self.generate_vectorizer_features(text)
# vec_keys = self.normal_vectorizer.vocab + self.clean_vectorizer.vocab
#
# meta_feats = self.generate_meta_features(text)
# meta_keys = meta_feats.keys()
# meta_keys.sort()
# meta_feat_arr = np.matrix([meta_feats[k] for k in meta_keys])
#
# self.colnames = vec_keys + meta_keys
#
# return np.hstack([vec_feats, meta_feat_arr])
#
# def generate_meta_features(self, text):
# feats = self.mf_generator.generate_meta_features(text)
# return feats
#
# def generate_vectorizer_features(self, text):
# clean_text = self.mf_generator.generate_clean_stem_text(text)
# feats = self.normal_vectorizer.get_features([text])
# clean_feats = self.clean_vectorizer.get_features([clean_text])
# return np.hstack([feats, clean_feats])
#
# Path: core/database/models.py
# class Model(db.Model):
# __tablename__ = 'models'
#
# id = db.Column(db.Integer, primary_key=True)
# path = db.Column(db.Text)
#
# question_id = db.Column(db.Integer, db.ForeignKey('questions.id'))
# question = db.relationship("Question", backref=db.backref('models', order_by=id))
#
# version = db.Column(db.Integer(), default=settings.MODEL_VERSION)
# error = db.Column(db.Float)
#
# created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
# updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
#
# Path: app.py
# def make_celery(app):
# def __call__(self, *args, **kwargs):
# def create_app():
# def create_test_app():
# class ContextTask(TaskBase):
#
# Path: scan/settings.py
# DB_URL = 'sqlite:///scan.db'
# DEBUG = True
# ROOT_PATH = path(__file__).dirname()
# REPO_PATH = ROOT_PATH.dirname()
# ENV_ROOT = REPO_PATH.dirname()
# DATA_PATH = os.path.join(REPO_PATH, "data")
# TEST_DATA_PATH = os.path.join(DATA_PATH, "test")
# MODEL_PATH = os.path.join(DATA_PATH, "models")
# SECRET_KEY = "30y^$e7henbp@#_w+z9)o9f8tovjrhoq(%vw=%#*(1-1esrh!_"
# USERNAME = "test"
# EMAIL = "test@test.com"
# PASSWORD = "test"
# SQLALCHEMY_DATABASE_URI = DB_URL
# SECURITY_REGISTERABLE = True
# SECURITY_RECOVERABLE = True
# SECURITY_SEND_REGISTER_EMAIL = False
# SECURITY_PASSWORD_HASH = "bcrypt"
# SECURITY_PASSWORD_SALT = SECRET_KEY
# BROKER_TRANSPORT_OPTIONS = {'visibility_timeout': 3600}
# BROKER_URL = 'redis://localhost:6379/3'
# CELERY_RESULT_BACKEND = 'redis://localhost:6379/3'
# CELERY_IMPORTS = ('core.tasks.tasks',)
# CACHE_TYPE = 'redis'
# CACHE_REDIS_URL = 'redis://localhost:6379/4'
# CACHE_REDIS_DB = 4
# MAX_FEATURES = 500
# MODEL_VERSION = 1
, which may include functions, classes, or code. Output only the next line. | def predict(self, text): |
Given the following code snippet before the placeholder: <|code_start|> path_string = "{0}_{1}.pickle".format(self.question.id, timestamp)
model = Model(
question=self.question,
error=scorer.cv_score,
path=path_string
)
db.session.add(model)
joblib.dump(scorer, os.path.join(settings.MODEL_PATH, path_string), compress=9)
db.session.commit()
class Scorer(object):
classification_max = 4
cv_folds = 2
def __init__(self, text, scores):
self.text = text
self.scores = scores
self.feature_generator = FeatureGenerator()
self.classifier = RandomForestRegressor(
n_estimators=100,
min_samples_split=4,
min_samples_leaf=3,
random_state=1
)
unique_scores = set(scores)
if len(unique_scores) <= self.classification_max:
self.classifier = RandomForestClassifier(
<|code_end|>
, predict the next line using imports from the current file:
import calendar
import numpy as np
import os
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
from core.algo.features import FeatureGenerator
from sklearn import cross_validation
from sklearn.externals import joblib
from core.database.models import Model
from app import db
from datetime import datetime
from scan import settings
and context including class names, function names, and sometimes code from other files:
# Path: core/algo/features.py
# class FeatureGenerator(object):
# def __init__(self, normal_vectorizer=None, clean_vectorizer=None):
# self.mf_generator = MetaFeatureGenerator()
# self.fit_complete = False
# if normal_vectorizer and clean_vectorizer:
# self.fit_complete = True
#
# if normal_vectorizer:
# self.normal_vectorizer = normal_vectorizer
# else:
# self.normal_vectorizer = Vectorizer()
#
# if clean_vectorizer:
# self.clean_vectorizer = clean_vectorizer
# else:
# self.clean_vectorizer = Vectorizer()
#
# def fit(self, input_text, input_scores):
# self.normal_vectorizer.fit(input_text, input_scores)
# clean_text = [self.mf_generator.generate_clean_stem_text(t) for t in input_text]
# self.clean_vectorizer.fit(clean_text, input_scores)
#
# def get_features(self, text):
# vec_feats = self.generate_vectorizer_features(text)
# vec_keys = self.normal_vectorizer.vocab + self.clean_vectorizer.vocab
#
# meta_feats = self.generate_meta_features(text)
# meta_keys = meta_feats.keys()
# meta_keys.sort()
# meta_feat_arr = np.matrix([meta_feats[k] for k in meta_keys])
#
# self.colnames = vec_keys + meta_keys
#
# return np.hstack([vec_feats, meta_feat_arr])
#
# def generate_meta_features(self, text):
# feats = self.mf_generator.generate_meta_features(text)
# return feats
#
# def generate_vectorizer_features(self, text):
# clean_text = self.mf_generator.generate_clean_stem_text(text)
# feats = self.normal_vectorizer.get_features([text])
# clean_feats = self.clean_vectorizer.get_features([clean_text])
# return np.hstack([feats, clean_feats])
#
# Path: core/database/models.py
# class Model(db.Model):
# __tablename__ = 'models'
#
# id = db.Column(db.Integer, primary_key=True)
# path = db.Column(db.Text)
#
# question_id = db.Column(db.Integer, db.ForeignKey('questions.id'))
# question = db.relationship("Question", backref=db.backref('models', order_by=id))
#
# version = db.Column(db.Integer(), default=settings.MODEL_VERSION)
# error = db.Column(db.Float)
#
# created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
# updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
#
# Path: app.py
# def make_celery(app):
# def __call__(self, *args, **kwargs):
# def create_app():
# def create_test_app():
# class ContextTask(TaskBase):
#
# Path: scan/settings.py
# DB_URL = 'sqlite:///scan.db'
# DEBUG = True
# ROOT_PATH = path(__file__).dirname()
# REPO_PATH = ROOT_PATH.dirname()
# ENV_ROOT = REPO_PATH.dirname()
# DATA_PATH = os.path.join(REPO_PATH, "data")
# TEST_DATA_PATH = os.path.join(DATA_PATH, "test")
# MODEL_PATH = os.path.join(DATA_PATH, "models")
# SECRET_KEY = "30y^$e7henbp@#_w+z9)o9f8tovjrhoq(%vw=%#*(1-1esrh!_"
# USERNAME = "test"
# EMAIL = "test@test.com"
# PASSWORD = "test"
# SQLALCHEMY_DATABASE_URI = DB_URL
# SECURITY_REGISTERABLE = True
# SECURITY_RECOVERABLE = True
# SECURITY_SEND_REGISTER_EMAIL = False
# SECURITY_PASSWORD_HASH = "bcrypt"
# SECURITY_PASSWORD_SALT = SECRET_KEY
# BROKER_TRANSPORT_OPTIONS = {'visibility_timeout': 3600}
# BROKER_URL = 'redis://localhost:6379/3'
# CELERY_RESULT_BACKEND = 'redis://localhost:6379/3'
# CELERY_IMPORTS = ('core.tasks.tasks',)
# CACHE_TYPE = 'redis'
# CACHE_REDIS_URL = 'redis://localhost:6379/4'
# CACHE_REDIS_DB = 4
# MAX_FEATURES = 500
# MODEL_VERSION = 1
. Output only the next line. | n_estimators=100, |
Based on the snippet: <|code_start|> path_string = "{0}_{1}.pickle".format(self.question.id, timestamp)
model = Model(
question=self.question,
error=scorer.cv_score,
path=path_string
)
db.session.add(model)
joblib.dump(scorer, os.path.join(settings.MODEL_PATH, path_string), compress=9)
db.session.commit()
class Scorer(object):
classification_max = 4
cv_folds = 2
def __init__(self, text, scores):
self.text = text
self.scores = scores
self.feature_generator = FeatureGenerator()
self.classifier = RandomForestRegressor(
n_estimators=100,
min_samples_split=4,
min_samples_leaf=3,
random_state=1
)
unique_scores = set(scores)
if len(unique_scores) <= self.classification_max:
self.classifier = RandomForestClassifier(
<|code_end|>
, predict the immediate next line with the help of imports:
import calendar
import numpy as np
import os
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
from core.algo.features import FeatureGenerator
from sklearn import cross_validation
from sklearn.externals import joblib
from core.database.models import Model
from app import db
from datetime import datetime
from scan import settings
and context (classes, functions, sometimes code) from other files:
# Path: core/algo/features.py
# class FeatureGenerator(object):
# def __init__(self, normal_vectorizer=None, clean_vectorizer=None):
# self.mf_generator = MetaFeatureGenerator()
# self.fit_complete = False
# if normal_vectorizer and clean_vectorizer:
# self.fit_complete = True
#
# if normal_vectorizer:
# self.normal_vectorizer = normal_vectorizer
# else:
# self.normal_vectorizer = Vectorizer()
#
# if clean_vectorizer:
# self.clean_vectorizer = clean_vectorizer
# else:
# self.clean_vectorizer = Vectorizer()
#
# def fit(self, input_text, input_scores):
# self.normal_vectorizer.fit(input_text, input_scores)
# clean_text = [self.mf_generator.generate_clean_stem_text(t) for t in input_text]
# self.clean_vectorizer.fit(clean_text, input_scores)
#
# def get_features(self, text):
# vec_feats = self.generate_vectorizer_features(text)
# vec_keys = self.normal_vectorizer.vocab + self.clean_vectorizer.vocab
#
# meta_feats = self.generate_meta_features(text)
# meta_keys = meta_feats.keys()
# meta_keys.sort()
# meta_feat_arr = np.matrix([meta_feats[k] for k in meta_keys])
#
# self.colnames = vec_keys + meta_keys
#
# return np.hstack([vec_feats, meta_feat_arr])
#
# def generate_meta_features(self, text):
# feats = self.mf_generator.generate_meta_features(text)
# return feats
#
# def generate_vectorizer_features(self, text):
# clean_text = self.mf_generator.generate_clean_stem_text(text)
# feats = self.normal_vectorizer.get_features([text])
# clean_feats = self.clean_vectorizer.get_features([clean_text])
# return np.hstack([feats, clean_feats])
#
# Path: core/database/models.py
# class Model(db.Model):
# __tablename__ = 'models'
#
# id = db.Column(db.Integer, primary_key=True)
# path = db.Column(db.Text)
#
# question_id = db.Column(db.Integer, db.ForeignKey('questions.id'))
# question = db.relationship("Question", backref=db.backref('models', order_by=id))
#
# version = db.Column(db.Integer(), default=settings.MODEL_VERSION)
# error = db.Column(db.Float)
#
# created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
# updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
#
# Path: app.py
# def make_celery(app):
# def __call__(self, *args, **kwargs):
# def create_app():
# def create_test_app():
# class ContextTask(TaskBase):
#
# Path: scan/settings.py
# DB_URL = 'sqlite:///scan.db'
# DEBUG = True
# ROOT_PATH = path(__file__).dirname()
# REPO_PATH = ROOT_PATH.dirname()
# ENV_ROOT = REPO_PATH.dirname()
# DATA_PATH = os.path.join(REPO_PATH, "data")
# TEST_DATA_PATH = os.path.join(DATA_PATH, "test")
# MODEL_PATH = os.path.join(DATA_PATH, "models")
# SECRET_KEY = "30y^$e7henbp@#_w+z9)o9f8tovjrhoq(%vw=%#*(1-1esrh!_"
# USERNAME = "test"
# EMAIL = "test@test.com"
# PASSWORD = "test"
# SQLALCHEMY_DATABASE_URI = DB_URL
# SECURITY_REGISTERABLE = True
# SECURITY_RECOVERABLE = True
# SECURITY_SEND_REGISTER_EMAIL = False
# SECURITY_PASSWORD_HASH = "bcrypt"
# SECURITY_PASSWORD_SALT = SECRET_KEY
# BROKER_TRANSPORT_OPTIONS = {'visibility_timeout': 3600}
# BROKER_URL = 'redis://localhost:6379/3'
# CELERY_RESULT_BACKEND = 'redis://localhost:6379/3'
# CELERY_IMPORTS = ('core.tasks.tasks',)
# CACHE_TYPE = 'redis'
# CACHE_REDIS_URL = 'redis://localhost:6379/4'
# CACHE_REDIS_DB = 4
# MAX_FEATURES = 500
# MODEL_VERSION = 1
. Output only the next line. | n_estimators=100, |
Here is a snippet: <|code_start|>
unique_scores = set(scores)
if len(unique_scores) <= self.classification_max:
self.classifier = RandomForestClassifier(
n_estimators=100,
min_samples_split=4,
min_samples_leaf=3,
random_state=1
)
self.fit_feats()
self.fit_done = False
def fit_feats(self):
self.feature_generator.fit(self.text, self.scores)
def get_features(self):
feats = []
for t in self.text:
feats.append(self.feature_generator.get_features(t))
feat_mat = np.vstack(feats)
return feat_mat
def train(self):
feats = self.get_features()
scores = np.array(self.scores)
# Compute error metrics for the estimator.
self.cv_scores = cross_validation.cross_val_score(self.classifier, feats, scores)
<|code_end|>
. Write the next line using the current file imports:
import calendar
import numpy as np
import os
from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
from core.algo.features import FeatureGenerator
from sklearn import cross_validation
from sklearn.externals import joblib
from core.database.models import Model
from app import db
from datetime import datetime
from scan import settings
and context from other files:
# Path: core/algo/features.py
# class FeatureGenerator(object):
# def __init__(self, normal_vectorizer=None, clean_vectorizer=None):
# self.mf_generator = MetaFeatureGenerator()
# self.fit_complete = False
# if normal_vectorizer and clean_vectorizer:
# self.fit_complete = True
#
# if normal_vectorizer:
# self.normal_vectorizer = normal_vectorizer
# else:
# self.normal_vectorizer = Vectorizer()
#
# if clean_vectorizer:
# self.clean_vectorizer = clean_vectorizer
# else:
# self.clean_vectorizer = Vectorizer()
#
# def fit(self, input_text, input_scores):
# self.normal_vectorizer.fit(input_text, input_scores)
# clean_text = [self.mf_generator.generate_clean_stem_text(t) for t in input_text]
# self.clean_vectorizer.fit(clean_text, input_scores)
#
# def get_features(self, text):
# vec_feats = self.generate_vectorizer_features(text)
# vec_keys = self.normal_vectorizer.vocab + self.clean_vectorizer.vocab
#
# meta_feats = self.generate_meta_features(text)
# meta_keys = meta_feats.keys()
# meta_keys.sort()
# meta_feat_arr = np.matrix([meta_feats[k] for k in meta_keys])
#
# self.colnames = vec_keys + meta_keys
#
# return np.hstack([vec_feats, meta_feat_arr])
#
# def generate_meta_features(self, text):
# feats = self.mf_generator.generate_meta_features(text)
# return feats
#
# def generate_vectorizer_features(self, text):
# clean_text = self.mf_generator.generate_clean_stem_text(text)
# feats = self.normal_vectorizer.get_features([text])
# clean_feats = self.clean_vectorizer.get_features([clean_text])
# return np.hstack([feats, clean_feats])
#
# Path: core/database/models.py
# class Model(db.Model):
# __tablename__ = 'models'
#
# id = db.Column(db.Integer, primary_key=True)
# path = db.Column(db.Text)
#
# question_id = db.Column(db.Integer, db.ForeignKey('questions.id'))
# question = db.relationship("Question", backref=db.backref('models', order_by=id))
#
# version = db.Column(db.Integer(), default=settings.MODEL_VERSION)
# error = db.Column(db.Float)
#
# created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
# updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
#
# Path: app.py
# def make_celery(app):
# def __call__(self, *args, **kwargs):
# def create_app():
# def create_test_app():
# class ContextTask(TaskBase):
#
# Path: scan/settings.py
# DB_URL = 'sqlite:///scan.db'
# DEBUG = True
# ROOT_PATH = path(__file__).dirname()
# REPO_PATH = ROOT_PATH.dirname()
# ENV_ROOT = REPO_PATH.dirname()
# DATA_PATH = os.path.join(REPO_PATH, "data")
# TEST_DATA_PATH = os.path.join(DATA_PATH, "test")
# MODEL_PATH = os.path.join(DATA_PATH, "models")
# SECRET_KEY = "30y^$e7henbp@#_w+z9)o9f8tovjrhoq(%vw=%#*(1-1esrh!_"
# USERNAME = "test"
# EMAIL = "test@test.com"
# PASSWORD = "test"
# SQLALCHEMY_DATABASE_URI = DB_URL
# SECURITY_REGISTERABLE = True
# SECURITY_RECOVERABLE = True
# SECURITY_SEND_REGISTER_EMAIL = False
# SECURITY_PASSWORD_HASH = "bcrypt"
# SECURITY_PASSWORD_SALT = SECRET_KEY
# BROKER_TRANSPORT_OPTIONS = {'visibility_timeout': 3600}
# BROKER_URL = 'redis://localhost:6379/3'
# CELERY_RESULT_BACKEND = 'redis://localhost:6379/3'
# CELERY_IMPORTS = ('core.tasks.tasks',)
# CACHE_TYPE = 'redis'
# CACHE_REDIS_URL = 'redis://localhost:6379/4'
# CACHE_REDIS_DB = 4
# MAX_FEATURES = 500
# MODEL_VERSION = 1
, which may include functions, classes, or code. Output only the next line. | self.cv_score = self.cv_scores.mean() |
Here is a snippet: <|code_start|>
question_id = db.Column(db.Integer, db.ForeignKey('questions.id'))
question = db.relationship("Question", backref=db.backref('essays', order_by=id))
created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
class PredictedScore(db.Model):
__tablename__ = 'predictedscores'
id = db.Column(db.Integer, primary_key=True)
prediction = db.Column(db.Float)
version = db.Column(db.Integer)
essay_id = db.Column(db.Integer, db.ForeignKey('essays.id'))
essay = db.relationship("Essay", backref=db.backref('predicted_scores', order_by=id))
model_id = db.Column(db.Integer, db.ForeignKey('models.id'))
model = db.relationship("Model", backref=db.backref('predicted_scores', order_by=id))
created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
class Model(db.Model):
__tablename__ = 'models'
id = db.Column(db.Integer, primary_key=True)
path = db.Column(db.Text)
question_id = db.Column(db.Integer, db.ForeignKey('questions.id'))
<|code_end|>
. Write the next line using the current file imports:
import hashlib
from sqlalchemy import event
from scan.log import logging
from datetime import datetime
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.security import UserMixin, RoleMixin
from scan import settings
and context from other files:
# Path: scan/log.py
# LOGGING = {
# 'version': 1,
# 'disable_existing_loggers': False,
# 'formatters': {
# 'standard': {
# 'format': '%(asctime)s %(levelname)s %(process)d '
# '[%(name)s] %(filename)s:%(lineno)d - %(message)s',
# },
# 'syslog_format': {'format': syslog_format},
# 'raw': {'format': '%(message)s'},
# },
# 'handlers': {
# 'console': {
# 'level': 'DEBUG',
# 'class': 'logging.StreamHandler',
# 'formatter': 'standard',
# 'stream': sys.stdout,
# }
# },
# 'loggers': {
# 'requests.packages.urllib3.connectionpool': {
# 'handlers': [],
# 'propagate': False,
# 'level': 'DEBUG',
# },
# '': {
# 'handlers': ['console'],
# 'level': 'DEBUG',
# 'propagate': False
# },
# }
# }
#
# Path: scan/settings.py
# DB_URL = 'sqlite:///scan.db'
# DEBUG = True
# ROOT_PATH = path(__file__).dirname()
# REPO_PATH = ROOT_PATH.dirname()
# ENV_ROOT = REPO_PATH.dirname()
# DATA_PATH = os.path.join(REPO_PATH, "data")
# TEST_DATA_PATH = os.path.join(DATA_PATH, "test")
# MODEL_PATH = os.path.join(DATA_PATH, "models")
# SECRET_KEY = "30y^$e7henbp@#_w+z9)o9f8tovjrhoq(%vw=%#*(1-1esrh!_"
# USERNAME = "test"
# EMAIL = "test@test.com"
# PASSWORD = "test"
# SQLALCHEMY_DATABASE_URI = DB_URL
# SECURITY_REGISTERABLE = True
# SECURITY_RECOVERABLE = True
# SECURITY_SEND_REGISTER_EMAIL = False
# SECURITY_PASSWORD_HASH = "bcrypt"
# SECURITY_PASSWORD_SALT = SECRET_KEY
# BROKER_TRANSPORT_OPTIONS = {'visibility_timeout': 3600}
# BROKER_URL = 'redis://localhost:6379/3'
# CELERY_RESULT_BACKEND = 'redis://localhost:6379/3'
# CELERY_IMPORTS = ('core.tasks.tasks',)
# CACHE_TYPE = 'redis'
# CACHE_REDIS_URL = 'redis://localhost:6379/4'
# CACHE_REDIS_DB = 4
# MAX_FEATURES = 500
# MODEL_VERSION = 1
, which may include functions, classes, or code. Output only the next line. | question = db.relationship("Question", backref=db.backref('models', order_by=id)) |
Next line prediction: <|code_start|> description = db.Column(db.String(STRING_MAX))
def __repr__(self):
return "<Role(name='%s')>" % (self.name)
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
first_name = db.Column(db.String(STRING_MAX))
last_name = db.Column(db.String(STRING_MAX))
username = db.Column(db.String(STRING_MAX), unique=True)
email = db.Column(db.String(STRING_MAX), unique=True)
password = db.Column(db.String(STRING_MAX))
active = db.Column(db.Boolean())
confirmed_at = db.Column(db.DateTime(timezone=True))
hashkey = db.Column(db.String(STRING_MAX), unique=True)
created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return "<User(name='%s', lastname='%s', password='%s')>" % (self.username, self.last_name, self.password)
class Question(db.Model):
__tablename__ = 'questions'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(STRING_MAX))
description = db.Column(db.Text)
<|code_end|>
. Use current file imports:
(import hashlib
from sqlalchemy import event
from scan.log import logging
from datetime import datetime
from flask.ext.sqlalchemy import SQLAlchemy
from flask.ext.security import UserMixin, RoleMixin
from scan import settings)
and context including class names, function names, or small code snippets from other files:
# Path: scan/log.py
# LOGGING = {
# 'version': 1,
# 'disable_existing_loggers': False,
# 'formatters': {
# 'standard': {
# 'format': '%(asctime)s %(levelname)s %(process)d '
# '[%(name)s] %(filename)s:%(lineno)d - %(message)s',
# },
# 'syslog_format': {'format': syslog_format},
# 'raw': {'format': '%(message)s'},
# },
# 'handlers': {
# 'console': {
# 'level': 'DEBUG',
# 'class': 'logging.StreamHandler',
# 'formatter': 'standard',
# 'stream': sys.stdout,
# }
# },
# 'loggers': {
# 'requests.packages.urllib3.connectionpool': {
# 'handlers': [],
# 'propagate': False,
# 'level': 'DEBUG',
# },
# '': {
# 'handlers': ['console'],
# 'level': 'DEBUG',
# 'propagate': False
# },
# }
# }
#
# Path: scan/settings.py
# DB_URL = 'sqlite:///scan.db'
# DEBUG = True
# ROOT_PATH = path(__file__).dirname()
# REPO_PATH = ROOT_PATH.dirname()
# ENV_ROOT = REPO_PATH.dirname()
# DATA_PATH = os.path.join(REPO_PATH, "data")
# TEST_DATA_PATH = os.path.join(DATA_PATH, "test")
# MODEL_PATH = os.path.join(DATA_PATH, "models")
# SECRET_KEY = "30y^$e7henbp@#_w+z9)o9f8tovjrhoq(%vw=%#*(1-1esrh!_"
# USERNAME = "test"
# EMAIL = "test@test.com"
# PASSWORD = "test"
# SQLALCHEMY_DATABASE_URI = DB_URL
# SECURITY_REGISTERABLE = True
# SECURITY_RECOVERABLE = True
# SECURITY_SEND_REGISTER_EMAIL = False
# SECURITY_PASSWORD_HASH = "bcrypt"
# SECURITY_PASSWORD_SALT = SECRET_KEY
# BROKER_TRANSPORT_OPTIONS = {'visibility_timeout': 3600}
# BROKER_URL = 'redis://localhost:6379/3'
# CELERY_RESULT_BACKEND = 'redis://localhost:6379/3'
# CELERY_IMPORTS = ('core.tasks.tasks',)
# CACHE_TYPE = 'redis'
# CACHE_REDIS_URL = 'redis://localhost:6379/4'
# CACHE_REDIS_DB = 4
# MAX_FEATURES = 500
# MODEL_VERSION = 1
. Output only the next line. | prompt = db.Column(db.Text) |
Using the snippet: <|code_start|>
def single_instance_task():
def task_exc(func):
@functools.wraps(func)
<|code_end|>
, determine the next line of code. You have imports:
import functools
from celery.signals import worker_shutdown
from app import cache
and context (class names, function names, or code) available:
# Path: app.py
# def make_celery(app):
# def __call__(self, *args, **kwargs):
# def create_app():
# def create_test_app():
# class ContextTask(TaskBase):
. Output only the next line. | def wrapper(*args, **kwargs): |
Given the following code snippet before the placeholder: <|code_start|>
def make_celery(app):
celery = Celery(app.import_name, broker=app.config['BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def create_app():
app = Flask(__name__, template_folder='templates')
app.config.from_object('scan.settings')
db.app = app
db.init_app(app)
return app
def create_test_app():
<|code_end|>
, predict the next line using imports from the current file:
from flask import Flask
from flask.ext.security import Security, SQLAlchemyUserDatastore
from flask.ext.babel import Babel
from scan import settings
from celery import Celery
from core.database.models import db, User, Role
from flask.ext.cache import Cache
from core.web.main_views import main_views
and context including class names, function names, and sometimes code from other files:
# Path: scan/settings.py
# DB_URL = 'sqlite:///scan.db'
# DEBUG = True
# ROOT_PATH = path(__file__).dirname()
# REPO_PATH = ROOT_PATH.dirname()
# ENV_ROOT = REPO_PATH.dirname()
# DATA_PATH = os.path.join(REPO_PATH, "data")
# TEST_DATA_PATH = os.path.join(DATA_PATH, "test")
# MODEL_PATH = os.path.join(DATA_PATH, "models")
# SECRET_KEY = "30y^$e7henbp@#_w+z9)o9f8tovjrhoq(%vw=%#*(1-1esrh!_"
# USERNAME = "test"
# EMAIL = "test@test.com"
# PASSWORD = "test"
# SQLALCHEMY_DATABASE_URI = DB_URL
# SECURITY_REGISTERABLE = True
# SECURITY_RECOVERABLE = True
# SECURITY_SEND_REGISTER_EMAIL = False
# SECURITY_PASSWORD_HASH = "bcrypt"
# SECURITY_PASSWORD_SALT = SECRET_KEY
# BROKER_TRANSPORT_OPTIONS = {'visibility_timeout': 3600}
# BROKER_URL = 'redis://localhost:6379/3'
# CELERY_RESULT_BACKEND = 'redis://localhost:6379/3'
# CELERY_IMPORTS = ('core.tasks.tasks',)
# CACHE_TYPE = 'redis'
# CACHE_REDIS_URL = 'redis://localhost:6379/4'
# CACHE_REDIS_DB = 4
# MAX_FEATURES = 500
# MODEL_VERSION = 1
#
# Path: core/database/models.py
# STRING_MAX = 255
# class Role(db.Model, RoleMixin):
# class User(db.Model, UserMixin):
# class Question(db.Model):
# class Essay(db.Model):
# class PredictedScore(db.Model):
# class Model(db.Model):
# def __repr__(self):
# def __repr__(self):
#
# Path: core/web/main_views.py
# class InvalidUser(Exception):
# class InvalidAction(Exception):
# class BaseQuestionView(MethodView):
# class QuestionView(BaseQuestionView):
# class QuestionDetailView(BaseQuestionView):
# class QuestionActionView(BaseQuestionView):
# class EssayUploadView(BaseQuestionView):
# class BaseEssayView(MethodView):
# class EssayDetailView(BaseEssayView):
# class EssayActionView(BaseEssayView):
# class TaskStatusView(MethodView):
# def index():
# def get_model(self, id):
# def get_cache_key(self, id):
# def get_cache(self, id):
# def set_cache(self, id, val):
# def get_questions(self):
# def get(self):
# def post(self):
# def get_upload_form(self, model):
# def get(self, id):
# def post(self, id):
# def delete(self, id):
# def create(self, model):
# def create_and_score(self, model):
# def get(self, id, action):
# def post(self, id):
# def get_model(self, id):
# def get_cache_key(self, id):
# def get_cache(self, id):
# def set_cache(self, id, val):
# def delete(self, id):
# def score(self, model):
# def get(self, id, action):
# def get(self, task_id):
. Output only the next line. | app = create_app() |
Based on the snippet: <|code_start|>
def make_celery(app):
celery = Celery(app.import_name, broker=app.config['BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
<|code_end|>
, predict the immediate next line with the help of imports:
from flask import Flask
from flask.ext.security import Security, SQLAlchemyUserDatastore
from flask.ext.babel import Babel
from scan import settings
from celery import Celery
from core.database.models import db, User, Role
from flask.ext.cache import Cache
from core.web.main_views import main_views
and context (classes, functions, sometimes code) from other files:
# Path: scan/settings.py
# DB_URL = 'sqlite:///scan.db'
# DEBUG = True
# ROOT_PATH = path(__file__).dirname()
# REPO_PATH = ROOT_PATH.dirname()
# ENV_ROOT = REPO_PATH.dirname()
# DATA_PATH = os.path.join(REPO_PATH, "data")
# TEST_DATA_PATH = os.path.join(DATA_PATH, "test")
# MODEL_PATH = os.path.join(DATA_PATH, "models")
# SECRET_KEY = "30y^$e7henbp@#_w+z9)o9f8tovjrhoq(%vw=%#*(1-1esrh!_"
# USERNAME = "test"
# EMAIL = "test@test.com"
# PASSWORD = "test"
# SQLALCHEMY_DATABASE_URI = DB_URL
# SECURITY_REGISTERABLE = True
# SECURITY_RECOVERABLE = True
# SECURITY_SEND_REGISTER_EMAIL = False
# SECURITY_PASSWORD_HASH = "bcrypt"
# SECURITY_PASSWORD_SALT = SECRET_KEY
# BROKER_TRANSPORT_OPTIONS = {'visibility_timeout': 3600}
# BROKER_URL = 'redis://localhost:6379/3'
# CELERY_RESULT_BACKEND = 'redis://localhost:6379/3'
# CELERY_IMPORTS = ('core.tasks.tasks',)
# CACHE_TYPE = 'redis'
# CACHE_REDIS_URL = 'redis://localhost:6379/4'
# CACHE_REDIS_DB = 4
# MAX_FEATURES = 500
# MODEL_VERSION = 1
#
# Path: core/database/models.py
# STRING_MAX = 255
# class Role(db.Model, RoleMixin):
# class User(db.Model, UserMixin):
# class Question(db.Model):
# class Essay(db.Model):
# class PredictedScore(db.Model):
# class Model(db.Model):
# def __repr__(self):
# def __repr__(self):
#
# Path: core/web/main_views.py
# class InvalidUser(Exception):
# class InvalidAction(Exception):
# class BaseQuestionView(MethodView):
# class QuestionView(BaseQuestionView):
# class QuestionDetailView(BaseQuestionView):
# class QuestionActionView(BaseQuestionView):
# class EssayUploadView(BaseQuestionView):
# class BaseEssayView(MethodView):
# class EssayDetailView(BaseEssayView):
# class EssayActionView(BaseEssayView):
# class TaskStatusView(MethodView):
# def index():
# def get_model(self, id):
# def get_cache_key(self, id):
# def get_cache(self, id):
# def set_cache(self, id, val):
# def get_questions(self):
# def get(self):
# def post(self):
# def get_upload_form(self, model):
# def get(self, id):
# def post(self, id):
# def delete(self, id):
# def create(self, model):
# def create_and_score(self, model):
# def get(self, id, action):
# def post(self, id):
# def get_model(self, id):
# def get_cache_key(self, id):
# def get_cache(self, id):
# def set_cache(self, id, val):
# def delete(self, id):
# def score(self, model):
# def get(self, id, action):
# def get(self, task_id):
. Output only the next line. | def __call__(self, *args, **kwargs): |
Given the following code snippet before the placeholder: <|code_start|>
def make_celery(app):
celery = Celery(app.import_name, broker=app.config['BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
celery.Task = ContextTask
return celery
def create_app():
app = Flask(__name__, template_folder='templates')
app.config.from_object('scan.settings')
db.app = app
db.init_app(app)
return app
def create_test_app():
app = create_app()
app.config.from_object('scan.test_settings')
db.app = app
db.init_app(app)
return app
<|code_end|>
, predict the next line using imports from the current file:
from flask import Flask
from flask.ext.security import Security, SQLAlchemyUserDatastore
from flask.ext.babel import Babel
from scan import settings
from celery import Celery
from core.database.models import db, User, Role
from flask.ext.cache import Cache
from core.web.main_views import main_views
and context including class names, function names, and sometimes code from other files:
# Path: scan/settings.py
# DB_URL = 'sqlite:///scan.db'
# DEBUG = True
# ROOT_PATH = path(__file__).dirname()
# REPO_PATH = ROOT_PATH.dirname()
# ENV_ROOT = REPO_PATH.dirname()
# DATA_PATH = os.path.join(REPO_PATH, "data")
# TEST_DATA_PATH = os.path.join(DATA_PATH, "test")
# MODEL_PATH = os.path.join(DATA_PATH, "models")
# SECRET_KEY = "30y^$e7henbp@#_w+z9)o9f8tovjrhoq(%vw=%#*(1-1esrh!_"
# USERNAME = "test"
# EMAIL = "test@test.com"
# PASSWORD = "test"
# SQLALCHEMY_DATABASE_URI = DB_URL
# SECURITY_REGISTERABLE = True
# SECURITY_RECOVERABLE = True
# SECURITY_SEND_REGISTER_EMAIL = False
# SECURITY_PASSWORD_HASH = "bcrypt"
# SECURITY_PASSWORD_SALT = SECRET_KEY
# BROKER_TRANSPORT_OPTIONS = {'visibility_timeout': 3600}
# BROKER_URL = 'redis://localhost:6379/3'
# CELERY_RESULT_BACKEND = 'redis://localhost:6379/3'
# CELERY_IMPORTS = ('core.tasks.tasks',)
# CACHE_TYPE = 'redis'
# CACHE_REDIS_URL = 'redis://localhost:6379/4'
# CACHE_REDIS_DB = 4
# MAX_FEATURES = 500
# MODEL_VERSION = 1
#
# Path: core/database/models.py
# STRING_MAX = 255
# class Role(db.Model, RoleMixin):
# class User(db.Model, UserMixin):
# class Question(db.Model):
# class Essay(db.Model):
# class PredictedScore(db.Model):
# class Model(db.Model):
# def __repr__(self):
# def __repr__(self):
#
# Path: core/web/main_views.py
# class InvalidUser(Exception):
# class InvalidAction(Exception):
# class BaseQuestionView(MethodView):
# class QuestionView(BaseQuestionView):
# class QuestionDetailView(BaseQuestionView):
# class QuestionActionView(BaseQuestionView):
# class EssayUploadView(BaseQuestionView):
# class BaseEssayView(MethodView):
# class EssayDetailView(BaseEssayView):
# class EssayActionView(BaseEssayView):
# class TaskStatusView(MethodView):
# def index():
# def get_model(self, id):
# def get_cache_key(self, id):
# def get_cache(self, id):
# def set_cache(self, id, val):
# def get_questions(self):
# def get(self):
# def post(self):
# def get_upload_form(self, model):
# def get(self, id):
# def post(self, id):
# def delete(self, id):
# def create(self, model):
# def create_and_score(self, model):
# def get(self, id, action):
# def post(self, id):
# def get_model(self, id):
# def get_cache_key(self, id):
# def get_cache(self, id):
# def set_cache(self, id, val):
# def delete(self, id):
# def score(self, model):
# def get(self, id, action):
# def get(self, task_id):
. Output only the next line. | app = create_app() |
Given the code snippet: <|code_start|>
def make_celery(app):
celery = Celery(app.import_name, broker=app.config['BROKER_URL'])
celery.conf.update(app.config)
<|code_end|>
, generate the next line using the imports in this file:
from flask import Flask
from flask.ext.security import Security, SQLAlchemyUserDatastore
from flask.ext.babel import Babel
from scan import settings
from celery import Celery
from core.database.models import db, User, Role
from flask.ext.cache import Cache
from core.web.main_views import main_views
and context (functions, classes, or occasionally code) from other files:
# Path: scan/settings.py
# DB_URL = 'sqlite:///scan.db'
# DEBUG = True
# ROOT_PATH = path(__file__).dirname()
# REPO_PATH = ROOT_PATH.dirname()
# ENV_ROOT = REPO_PATH.dirname()
# DATA_PATH = os.path.join(REPO_PATH, "data")
# TEST_DATA_PATH = os.path.join(DATA_PATH, "test")
# MODEL_PATH = os.path.join(DATA_PATH, "models")
# SECRET_KEY = "30y^$e7henbp@#_w+z9)o9f8tovjrhoq(%vw=%#*(1-1esrh!_"
# USERNAME = "test"
# EMAIL = "test@test.com"
# PASSWORD = "test"
# SQLALCHEMY_DATABASE_URI = DB_URL
# SECURITY_REGISTERABLE = True
# SECURITY_RECOVERABLE = True
# SECURITY_SEND_REGISTER_EMAIL = False
# SECURITY_PASSWORD_HASH = "bcrypt"
# SECURITY_PASSWORD_SALT = SECRET_KEY
# BROKER_TRANSPORT_OPTIONS = {'visibility_timeout': 3600}
# BROKER_URL = 'redis://localhost:6379/3'
# CELERY_RESULT_BACKEND = 'redis://localhost:6379/3'
# CELERY_IMPORTS = ('core.tasks.tasks',)
# CACHE_TYPE = 'redis'
# CACHE_REDIS_URL = 'redis://localhost:6379/4'
# CACHE_REDIS_DB = 4
# MAX_FEATURES = 500
# MODEL_VERSION = 1
#
# Path: core/database/models.py
# STRING_MAX = 255
# class Role(db.Model, RoleMixin):
# class User(db.Model, UserMixin):
# class Question(db.Model):
# class Essay(db.Model):
# class PredictedScore(db.Model):
# class Model(db.Model):
# def __repr__(self):
# def __repr__(self):
#
# Path: core/web/main_views.py
# class InvalidUser(Exception):
# class InvalidAction(Exception):
# class BaseQuestionView(MethodView):
# class QuestionView(BaseQuestionView):
# class QuestionDetailView(BaseQuestionView):
# class QuestionActionView(BaseQuestionView):
# class EssayUploadView(BaseQuestionView):
# class BaseEssayView(MethodView):
# class EssayDetailView(BaseEssayView):
# class EssayActionView(BaseEssayView):
# class TaskStatusView(MethodView):
# def index():
# def get_model(self, id):
# def get_cache_key(self, id):
# def get_cache(self, id):
# def set_cache(self, id, val):
# def get_questions(self):
# def get(self):
# def post(self):
# def get_upload_form(self, model):
# def get(self, id):
# def post(self, id):
# def delete(self, id):
# def create(self, model):
# def create_and_score(self, model):
# def get(self, id, action):
# def post(self, id):
# def get_model(self, id):
# def get_cache_key(self, id):
# def get_cache(self, id):
# def set_cache(self, id, val):
# def delete(self, id):
# def score(self, model):
# def get(self, id, action):
# def get(self, task_id):
. Output only the next line. | TaskBase = celery.Task |
Given the following code snippet before the placeholder: <|code_start|>
def make_celery(app):
celery = Celery(app.import_name, broker=app.config['BROKER_URL'])
celery.conf.update(app.config)
TaskBase = celery.Task
class ContextTask(TaskBase):
abstract = True
def __call__(self, *args, **kwargs):
with app.app_context():
return TaskBase.__call__(self, *args, **kwargs)
<|code_end|>
, predict the next line using imports from the current file:
from flask import Flask
from flask.ext.security import Security, SQLAlchemyUserDatastore
from flask.ext.babel import Babel
from scan import settings
from celery import Celery
from core.database.models import db, User, Role
from flask.ext.cache import Cache
from core.web.main_views import main_views
and context including class names, function names, and sometimes code from other files:
# Path: scan/settings.py
# DB_URL = 'sqlite:///scan.db'
# DEBUG = True
# ROOT_PATH = path(__file__).dirname()
# REPO_PATH = ROOT_PATH.dirname()
# ENV_ROOT = REPO_PATH.dirname()
# DATA_PATH = os.path.join(REPO_PATH, "data")
# TEST_DATA_PATH = os.path.join(DATA_PATH, "test")
# MODEL_PATH = os.path.join(DATA_PATH, "models")
# SECRET_KEY = "30y^$e7henbp@#_w+z9)o9f8tovjrhoq(%vw=%#*(1-1esrh!_"
# USERNAME = "test"
# EMAIL = "test@test.com"
# PASSWORD = "test"
# SQLALCHEMY_DATABASE_URI = DB_URL
# SECURITY_REGISTERABLE = True
# SECURITY_RECOVERABLE = True
# SECURITY_SEND_REGISTER_EMAIL = False
# SECURITY_PASSWORD_HASH = "bcrypt"
# SECURITY_PASSWORD_SALT = SECRET_KEY
# BROKER_TRANSPORT_OPTIONS = {'visibility_timeout': 3600}
# BROKER_URL = 'redis://localhost:6379/3'
# CELERY_RESULT_BACKEND = 'redis://localhost:6379/3'
# CELERY_IMPORTS = ('core.tasks.tasks',)
# CACHE_TYPE = 'redis'
# CACHE_REDIS_URL = 'redis://localhost:6379/4'
# CACHE_REDIS_DB = 4
# MAX_FEATURES = 500
# MODEL_VERSION = 1
#
# Path: core/database/models.py
# STRING_MAX = 255
# class Role(db.Model, RoleMixin):
# class User(db.Model, UserMixin):
# class Question(db.Model):
# class Essay(db.Model):
# class PredictedScore(db.Model):
# class Model(db.Model):
# def __repr__(self):
# def __repr__(self):
#
# Path: core/web/main_views.py
# class InvalidUser(Exception):
# class InvalidAction(Exception):
# class BaseQuestionView(MethodView):
# class QuestionView(BaseQuestionView):
# class QuestionDetailView(BaseQuestionView):
# class QuestionActionView(BaseQuestionView):
# class EssayUploadView(BaseQuestionView):
# class BaseEssayView(MethodView):
# class EssayDetailView(BaseEssayView):
# class EssayActionView(BaseEssayView):
# class TaskStatusView(MethodView):
# def index():
# def get_model(self, id):
# def get_cache_key(self, id):
# def get_cache(self, id):
# def set_cache(self, id, val):
# def get_questions(self):
# def get(self):
# def post(self):
# def get_upload_form(self, model):
# def get(self, id):
# def post(self, id):
# def delete(self, id):
# def create(self, model):
# def create_and_score(self, model):
# def get(self, id, action):
# def post(self, id):
# def get_model(self, id):
# def get_cache_key(self, id):
# def get_cache(self, id):
# def set_cache(self, id, val):
# def delete(self, id):
# def score(self, model):
# def get(self, id, action):
# def get(self, task_id):
. Output only the next line. | celery.Task = ContextTask |
Next line prediction: <|code_start|>
log = logging.getLogger(__name__)
class DataLoader(object):
def __init__(self, pathname):
self.pathname = pathname
def load_text_files(self, pathname):
filenames = os.listdir(pathname)
text = []
for filename in filenames:
data = open(os.path.join(pathname, filename)).read()
text.append(data[:settings.CHARACTER_LIMIT])
<|code_end|>
. Use current file imports:
(from core.tests.base import ScanTest
from scan.log import logging
from core.tests.base import db
from mock import patch
from core.algo.scorer import Scorer
from scan import test_settings as settings
import os
import json
import random)
and context including class names, function names, or small code snippets from other files:
# Path: core/tests/base.py
# class ScanTest(TestCase):
#
# def create_app(self):
# return app
#
# def setUp(self):
# db.create_all(app=app)
#
# def tearDown(self):
# db.session.remove()
# db.drop_all()
#
# Path: scan/log.py
# LOGGING = {
# 'version': 1,
# 'disable_existing_loggers': False,
# 'formatters': {
# 'standard': {
# 'format': '%(asctime)s %(levelname)s %(process)d '
# '[%(name)s] %(filename)s:%(lineno)d - %(message)s',
# },
# 'syslog_format': {'format': syslog_format},
# 'raw': {'format': '%(message)s'},
# },
# 'handlers': {
# 'console': {
# 'level': 'DEBUG',
# 'class': 'logging.StreamHandler',
# 'formatter': 'standard',
# 'stream': sys.stdout,
# }
# },
# 'loggers': {
# 'requests.packages.urllib3.connectionpool': {
# 'handlers': [],
# 'propagate': False,
# 'level': 'DEBUG',
# },
# '': {
# 'handlers': ['console'],
# 'level': 'DEBUG',
# 'propagate': False
# },
# }
# }
#
# Path: core/tests/base.py
# class ScanTest(TestCase):
# def create_app(self):
# def setUp(self):
# def tearDown(self):
#
# Path: core/algo/scorer.py
# class Scorer(object):
# classification_max = 4
# cv_folds = 2
#
# def __init__(self, text, scores):
# self.text = text
# self.scores = scores
# self.feature_generator = FeatureGenerator()
# self.classifier = RandomForestRegressor(
# n_estimators=100,
# min_samples_split=4,
# min_samples_leaf=3,
# random_state=1
# )
#
# unique_scores = set(scores)
# if len(unique_scores) <= self.classification_max:
# self.classifier = RandomForestClassifier(
# n_estimators=100,
# min_samples_split=4,
# min_samples_leaf=3,
# random_state=1
# )
#
# self.fit_feats()
# self.fit_done = False
#
# def fit_feats(self):
# self.feature_generator.fit(self.text, self.scores)
#
# def get_features(self):
# feats = []
# for t in self.text:
# feats.append(self.feature_generator.get_features(t))
#
# feat_mat = np.vstack(feats)
# return feat_mat
#
# def train(self):
# feats = self.get_features()
# scores = np.array(self.scores)
#
# # Compute error metrics for the estimator.
# self.cv_scores = cross_validation.cross_val_score(self.classifier, feats, scores)
# self.cv_score = self.cv_scores.mean()
# self.cv_dev = self.cv_scores.std()
#
# self.classifier.fit(feats, scores)
# self.fit_done = True
#
# def predict(self, text):
# feats = self.feature_generator.get_features(text)
# return self.classifier.predict(feats)
#
# Path: scan/test_settings.py
# DB_URL = "sqlite:///test.db"
# SQLALCHEMY_DATABASE_URI = DB_URL
# TESTING = True
# CHARACTER_LIMIT = 1000
# TRAINING_LIMIT = 50
# QUICK_TEST_LIMIT = 5
. Output only the next line. | return text |
Here is a snippet: <|code_start|>
log = logging.getLogger(__name__)
class DataLoader(object):
def __init__(self, pathname):
self.pathname = pathname
def load_text_files(self, pathname):
filenames = os.listdir(pathname)
text = []
for filename in filenames:
data = open(os.path.join(pathname, filename)).read()
text.append(data[:settings.CHARACTER_LIMIT])
return text
def load_json_file(self, filename):
datafile = open(os.path.join(filename))
data = json.load(datafile)
return data
<|code_end|>
. Write the next line using the current file imports:
from core.tests.base import ScanTest
from scan.log import logging
from core.tests.base import db
from mock import patch
from core.algo.scorer import Scorer
from scan import test_settings as settings
import os
import json
import random
and context from other files:
# Path: core/tests/base.py
# class ScanTest(TestCase):
#
# def create_app(self):
# return app
#
# def setUp(self):
# db.create_all(app=app)
#
# def tearDown(self):
# db.session.remove()
# db.drop_all()
#
# Path: scan/log.py
# LOGGING = {
# 'version': 1,
# 'disable_existing_loggers': False,
# 'formatters': {
# 'standard': {
# 'format': '%(asctime)s %(levelname)s %(process)d '
# '[%(name)s] %(filename)s:%(lineno)d - %(message)s',
# },
# 'syslog_format': {'format': syslog_format},
# 'raw': {'format': '%(message)s'},
# },
# 'handlers': {
# 'console': {
# 'level': 'DEBUG',
# 'class': 'logging.StreamHandler',
# 'formatter': 'standard',
# 'stream': sys.stdout,
# }
# },
# 'loggers': {
# 'requests.packages.urllib3.connectionpool': {
# 'handlers': [],
# 'propagate': False,
# 'level': 'DEBUG',
# },
# '': {
# 'handlers': ['console'],
# 'level': 'DEBUG',
# 'propagate': False
# },
# }
# }
#
# Path: core/tests/base.py
# class ScanTest(TestCase):
# def create_app(self):
# def setUp(self):
# def tearDown(self):
#
# Path: core/algo/scorer.py
# class Scorer(object):
# classification_max = 4
# cv_folds = 2
#
# def __init__(self, text, scores):
# self.text = text
# self.scores = scores
# self.feature_generator = FeatureGenerator()
# self.classifier = RandomForestRegressor(
# n_estimators=100,
# min_samples_split=4,
# min_samples_leaf=3,
# random_state=1
# )
#
# unique_scores = set(scores)
# if len(unique_scores) <= self.classification_max:
# self.classifier = RandomForestClassifier(
# n_estimators=100,
# min_samples_split=4,
# min_samples_leaf=3,
# random_state=1
# )
#
# self.fit_feats()
# self.fit_done = False
#
# def fit_feats(self):
# self.feature_generator.fit(self.text, self.scores)
#
# def get_features(self):
# feats = []
# for t in self.text:
# feats.append(self.feature_generator.get_features(t))
#
# feat_mat = np.vstack(feats)
# return feat_mat
#
# def train(self):
# feats = self.get_features()
# scores = np.array(self.scores)
#
# # Compute error metrics for the estimator.
# self.cv_scores = cross_validation.cross_val_score(self.classifier, feats, scores)
# self.cv_score = self.cv_scores.mean()
# self.cv_dev = self.cv_scores.std()
#
# self.classifier.fit(feats, scores)
# self.fit_done = True
#
# def predict(self, text):
# feats = self.feature_generator.get_features(text)
# return self.classifier.predict(feats)
#
# Path: scan/test_settings.py
# DB_URL = "sqlite:///test.db"
# SQLALCHEMY_DATABASE_URI = DB_URL
# TESTING = True
# CHARACTER_LIMIT = 1000
# TRAINING_LIMIT = 50
# QUICK_TEST_LIMIT = 5
, which may include functions, classes, or code. Output only the next line. | def load_data(self): |
Given the following code snippet before the placeholder: <|code_start|>
log = logging.getLogger(__name__)
class DataLoader(object):
def __init__(self, pathname):
self.pathname = pathname
def load_text_files(self, pathname):
filenames = os.listdir(pathname)
text = []
<|code_end|>
, predict the next line using imports from the current file:
from core.tests.base import ScanTest
from scan.log import logging
from core.tests.base import db
from mock import patch
from core.algo.scorer import Scorer
from scan import test_settings as settings
import os
import json
import random
and context including class names, function names, and sometimes code from other files:
# Path: core/tests/base.py
# class ScanTest(TestCase):
#
# def create_app(self):
# return app
#
# def setUp(self):
# db.create_all(app=app)
#
# def tearDown(self):
# db.session.remove()
# db.drop_all()
#
# Path: scan/log.py
# LOGGING = {
# 'version': 1,
# 'disable_existing_loggers': False,
# 'formatters': {
# 'standard': {
# 'format': '%(asctime)s %(levelname)s %(process)d '
# '[%(name)s] %(filename)s:%(lineno)d - %(message)s',
# },
# 'syslog_format': {'format': syslog_format},
# 'raw': {'format': '%(message)s'},
# },
# 'handlers': {
# 'console': {
# 'level': 'DEBUG',
# 'class': 'logging.StreamHandler',
# 'formatter': 'standard',
# 'stream': sys.stdout,
# }
# },
# 'loggers': {
# 'requests.packages.urllib3.connectionpool': {
# 'handlers': [],
# 'propagate': False,
# 'level': 'DEBUG',
# },
# '': {
# 'handlers': ['console'],
# 'level': 'DEBUG',
# 'propagate': False
# },
# }
# }
#
# Path: core/tests/base.py
# class ScanTest(TestCase):
# def create_app(self):
# def setUp(self):
# def tearDown(self):
#
# Path: core/algo/scorer.py
# class Scorer(object):
# classification_max = 4
# cv_folds = 2
#
# def __init__(self, text, scores):
# self.text = text
# self.scores = scores
# self.feature_generator = FeatureGenerator()
# self.classifier = RandomForestRegressor(
# n_estimators=100,
# min_samples_split=4,
# min_samples_leaf=3,
# random_state=1
# )
#
# unique_scores = set(scores)
# if len(unique_scores) <= self.classification_max:
# self.classifier = RandomForestClassifier(
# n_estimators=100,
# min_samples_split=4,
# min_samples_leaf=3,
# random_state=1
# )
#
# self.fit_feats()
# self.fit_done = False
#
# def fit_feats(self):
# self.feature_generator.fit(self.text, self.scores)
#
# def get_features(self):
# feats = []
# for t in self.text:
# feats.append(self.feature_generator.get_features(t))
#
# feat_mat = np.vstack(feats)
# return feat_mat
#
# def train(self):
# feats = self.get_features()
# scores = np.array(self.scores)
#
# # Compute error metrics for the estimator.
# self.cv_scores = cross_validation.cross_val_score(self.classifier, feats, scores)
# self.cv_score = self.cv_scores.mean()
# self.cv_dev = self.cv_scores.std()
#
# self.classifier.fit(feats, scores)
# self.fit_done = True
#
# def predict(self, text):
# feats = self.feature_generator.get_features(text)
# return self.classifier.predict(feats)
#
# Path: scan/test_settings.py
# DB_URL = "sqlite:///test.db"
# SQLALCHEMY_DATABASE_URI = DB_URL
# TESTING = True
# CHARACTER_LIMIT = 1000
# TRAINING_LIMIT = 50
# QUICK_TEST_LIMIT = 5
. Output only the next line. | for filename in filenames: |
Next line prediction: <|code_start|>
log = logging.getLogger(__name__)
class DataLoader(object):
def __init__(self, pathname):
<|code_end|>
. Use current file imports:
(from core.tests.base import ScanTest
from scan.log import logging
from core.tests.base import db
from mock import patch
from core.algo.scorer import Scorer
from scan import test_settings as settings
import os
import json
import random)
and context including class names, function names, or small code snippets from other files:
# Path: core/tests/base.py
# class ScanTest(TestCase):
#
# def create_app(self):
# return app
#
# def setUp(self):
# db.create_all(app=app)
#
# def tearDown(self):
# db.session.remove()
# db.drop_all()
#
# Path: scan/log.py
# LOGGING = {
# 'version': 1,
# 'disable_existing_loggers': False,
# 'formatters': {
# 'standard': {
# 'format': '%(asctime)s %(levelname)s %(process)d '
# '[%(name)s] %(filename)s:%(lineno)d - %(message)s',
# },
# 'syslog_format': {'format': syslog_format},
# 'raw': {'format': '%(message)s'},
# },
# 'handlers': {
# 'console': {
# 'level': 'DEBUG',
# 'class': 'logging.StreamHandler',
# 'formatter': 'standard',
# 'stream': sys.stdout,
# }
# },
# 'loggers': {
# 'requests.packages.urllib3.connectionpool': {
# 'handlers': [],
# 'propagate': False,
# 'level': 'DEBUG',
# },
# '': {
# 'handlers': ['console'],
# 'level': 'DEBUG',
# 'propagate': False
# },
# }
# }
#
# Path: core/tests/base.py
# class ScanTest(TestCase):
# def create_app(self):
# def setUp(self):
# def tearDown(self):
#
# Path: core/algo/scorer.py
# class Scorer(object):
# classification_max = 4
# cv_folds = 2
#
# def __init__(self, text, scores):
# self.text = text
# self.scores = scores
# self.feature_generator = FeatureGenerator()
# self.classifier = RandomForestRegressor(
# n_estimators=100,
# min_samples_split=4,
# min_samples_leaf=3,
# random_state=1
# )
#
# unique_scores = set(scores)
# if len(unique_scores) <= self.classification_max:
# self.classifier = RandomForestClassifier(
# n_estimators=100,
# min_samples_split=4,
# min_samples_leaf=3,
# random_state=1
# )
#
# self.fit_feats()
# self.fit_done = False
#
# def fit_feats(self):
# self.feature_generator.fit(self.text, self.scores)
#
# def get_features(self):
# feats = []
# for t in self.text:
# feats.append(self.feature_generator.get_features(t))
#
# feat_mat = np.vstack(feats)
# return feat_mat
#
# def train(self):
# feats = self.get_features()
# scores = np.array(self.scores)
#
# # Compute error metrics for the estimator.
# self.cv_scores = cross_validation.cross_val_score(self.classifier, feats, scores)
# self.cv_score = self.cv_scores.mean()
# self.cv_dev = self.cv_scores.std()
#
# self.classifier.fit(feats, scores)
# self.fit_done = True
#
# def predict(self, text):
# feats = self.feature_generator.get_features(text)
# return self.classifier.predict(feats)
#
# Path: scan/test_settings.py
# DB_URL = "sqlite:///test.db"
# SQLALCHEMY_DATABASE_URI = DB_URL
# TESTING = True
# CHARACTER_LIMIT = 1000
# TRAINING_LIMIT = 50
# QUICK_TEST_LIMIT = 5
. Output only the next line. | self.pathname = pathname |
Given the code snippet: <|code_start|>
class SqlAlchemyTask(celery.Task):
"""An abstract Celery Task that ensures that the connection the the
database is closed on task completion"""
abstract = True
def after_return(self, status, retval, task_id, args, kwargs, einfo):
db.session.remove()
@celery.task(base=SqlAlchemyTask)
def create_model(question_id):
question = Question.query.filter_by(id=question_id).first()
manager = Manager(question)
manager.create_model()
cache.delete('{0}_question_status')
@celery.task(base=SqlAlchemyTask)
def score_essay(essay_id):
essay = Essay.query.filter_by(id=essay_id).first()
manager = Manager(essay.question)
score = manager.score_essay(essay)
essay.predicted_score = score
essay.model = manager.get_latest_model()
db.session.commit()
@celery.task(base=SqlAlchemyTask)
def create_and_score(question_id):
create_model(question_id)
essay_ids = db.session.query(Essay.id).filter(Essay.question_id == question_id).all()
for e in essay_ids:
<|code_end|>
, generate the next line using the imports in this file:
from app import celery
from core.algo.scorer import Manager
from core.database.models import Question, Essay
from app import db
from app import cache
from app import db, cache
from app import db
and context (functions, classes, or occasionally code) from other files:
# Path: app.py
# def make_celery(app):
# def __call__(self, *args, **kwargs):
# def create_app():
# def create_test_app():
# class ContextTask(TaskBase):
#
# Path: core/algo/scorer.py
# class Manager(object):
# def __init__(self, question):
# self.question = question
#
# def score_essay(self, essay):
# text = essay.text
# model = self.get_latest_model()
# model_obj = joblib.load(os.path.join(settings.MODEL_PATH, model.path))
# return model_obj.predict(text)
#
# def get_latest_model(self):
# models = self.question.models
#
# if len(models) == 0:
# raise NoModelException
#
# model = models[-1]
# return model
#
# def create_model(self):
# text = [e.text for e in self.question.essays if e.actual_score is not None]
# scores = [e.actual_score for e in self.question.essays if e.actual_score is not None]
# scorer = Scorer(text, scores)
# scorer.train()
# time = datetime.utcnow()
# timestamp = calendar.timegm(time.utctimetuple())
# path_string = "{0}_{1}.pickle".format(self.question.id, timestamp)
# model = Model(
# question=self.question,
# error=scorer.cv_score,
# path=path_string
# )
#
# db.session.add(model)
#
# joblib.dump(scorer, os.path.join(settings.MODEL_PATH, path_string), compress=9)
# db.session.commit()
#
# Path: core/database/models.py
# class Question(db.Model):
# __tablename__ = 'questions'
#
# id = db.Column(db.Integer, primary_key=True)
# name = db.Column(db.String(STRING_MAX))
# description = db.Column(db.Text)
# prompt = db.Column(db.Text)
# user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
#
# user = db.relationship("User", backref=db.backref('questions', order_by=id))
#
# created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
# updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
#
# class Essay(db.Model):
# __tablename__ = 'essays'
#
# id = db.Column(db.Integer, primary_key=True)
# text = db.Column(db.Text)
# actual_score = db.Column(db.Float)
# info = db.Column(db.Text)
#
# predicted_score = db.Column(db.Float)
# model_id = db.Column(db.Integer, db.ForeignKey('models.id'))
# model = db.relationship("Model", backref=db.backref('essays', order_by=id))
#
# question_id = db.Column(db.Integer, db.ForeignKey('questions.id'))
# question = db.relationship("Question", backref=db.backref('essays', order_by=id))
#
# created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
# updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
. Output only the next line. | score_essay(e[0]) |
Continue the code snippet: <|code_start|>
class SqlAlchemyTask(celery.Task):
"""An abstract Celery Task that ensures that the connection the the
database is closed on task completion"""
abstract = True
def after_return(self, status, retval, task_id, args, kwargs, einfo):
db.session.remove()
@celery.task(base=SqlAlchemyTask)
def create_model(question_id):
question = Question.query.filter_by(id=question_id).first()
manager = Manager(question)
manager.create_model()
cache.delete('{0}_question_status')
@celery.task(base=SqlAlchemyTask)
def score_essay(essay_id):
essay = Essay.query.filter_by(id=essay_id).first()
manager = Manager(essay.question)
score = manager.score_essay(essay)
essay.predicted_score = score
essay.model = manager.get_latest_model()
db.session.commit()
@celery.task(base=SqlAlchemyTask)
def create_and_score(question_id):
<|code_end|>
. Use current file imports:
from app import celery
from core.algo.scorer import Manager
from core.database.models import Question, Essay
from app import db
from app import cache
from app import db, cache
from app import db
and context (classes, functions, or code) from other files:
# Path: app.py
# def make_celery(app):
# def __call__(self, *args, **kwargs):
# def create_app():
# def create_test_app():
# class ContextTask(TaskBase):
#
# Path: core/algo/scorer.py
# class Manager(object):
# def __init__(self, question):
# self.question = question
#
# def score_essay(self, essay):
# text = essay.text
# model = self.get_latest_model()
# model_obj = joblib.load(os.path.join(settings.MODEL_PATH, model.path))
# return model_obj.predict(text)
#
# def get_latest_model(self):
# models = self.question.models
#
# if len(models) == 0:
# raise NoModelException
#
# model = models[-1]
# return model
#
# def create_model(self):
# text = [e.text for e in self.question.essays if e.actual_score is not None]
# scores = [e.actual_score for e in self.question.essays if e.actual_score is not None]
# scorer = Scorer(text, scores)
# scorer.train()
# time = datetime.utcnow()
# timestamp = calendar.timegm(time.utctimetuple())
# path_string = "{0}_{1}.pickle".format(self.question.id, timestamp)
# model = Model(
# question=self.question,
# error=scorer.cv_score,
# path=path_string
# )
#
# db.session.add(model)
#
# joblib.dump(scorer, os.path.join(settings.MODEL_PATH, path_string), compress=9)
# db.session.commit()
#
# Path: core/database/models.py
# class Question(db.Model):
# __tablename__ = 'questions'
#
# id = db.Column(db.Integer, primary_key=True)
# name = db.Column(db.String(STRING_MAX))
# description = db.Column(db.Text)
# prompt = db.Column(db.Text)
# user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
#
# user = db.relationship("User", backref=db.backref('questions', order_by=id))
#
# created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
# updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
#
# class Essay(db.Model):
# __tablename__ = 'essays'
#
# id = db.Column(db.Integer, primary_key=True)
# text = db.Column(db.Text)
# actual_score = db.Column(db.Float)
# info = db.Column(db.Text)
#
# predicted_score = db.Column(db.Float)
# model_id = db.Column(db.Integer, db.ForeignKey('models.id'))
# model = db.relationship("Model", backref=db.backref('essays', order_by=id))
#
# question_id = db.Column(db.Integer, db.ForeignKey('questions.id'))
# question = db.relationship("Question", backref=db.backref('essays', order_by=id))
#
# created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
# updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
. Output only the next line. | create_model(question_id) |
Using the snippet: <|code_start|>
class SqlAlchemyTask(celery.Task):
"""An abstract Celery Task that ensures that the connection the the
database is closed on task completion"""
abstract = True
def after_return(self, status, retval, task_id, args, kwargs, einfo):
db.session.remove()
@celery.task(base=SqlAlchemyTask)
def create_model(question_id):
question = Question.query.filter_by(id=question_id).first()
manager = Manager(question)
manager.create_model()
cache.delete('{0}_question_status')
@celery.task(base=SqlAlchemyTask)
def score_essay(essay_id):
essay = Essay.query.filter_by(id=essay_id).first()
manager = Manager(essay.question)
score = manager.score_essay(essay)
essay.predicted_score = score
essay.model = manager.get_latest_model()
db.session.commit()
@celery.task(base=SqlAlchemyTask)
<|code_end|>
, determine the next line of code. You have imports:
from app import celery
from core.algo.scorer import Manager
from core.database.models import Question, Essay
from app import db
from app import cache
from app import db, cache
from app import db
and context (class names, function names, or code) available:
# Path: app.py
# def make_celery(app):
# def __call__(self, *args, **kwargs):
# def create_app():
# def create_test_app():
# class ContextTask(TaskBase):
#
# Path: core/algo/scorer.py
# class Manager(object):
# def __init__(self, question):
# self.question = question
#
# def score_essay(self, essay):
# text = essay.text
# model = self.get_latest_model()
# model_obj = joblib.load(os.path.join(settings.MODEL_PATH, model.path))
# return model_obj.predict(text)
#
# def get_latest_model(self):
# models = self.question.models
#
# if len(models) == 0:
# raise NoModelException
#
# model = models[-1]
# return model
#
# def create_model(self):
# text = [e.text for e in self.question.essays if e.actual_score is not None]
# scores = [e.actual_score for e in self.question.essays if e.actual_score is not None]
# scorer = Scorer(text, scores)
# scorer.train()
# time = datetime.utcnow()
# timestamp = calendar.timegm(time.utctimetuple())
# path_string = "{0}_{1}.pickle".format(self.question.id, timestamp)
# model = Model(
# question=self.question,
# error=scorer.cv_score,
# path=path_string
# )
#
# db.session.add(model)
#
# joblib.dump(scorer, os.path.join(settings.MODEL_PATH, path_string), compress=9)
# db.session.commit()
#
# Path: core/database/models.py
# class Question(db.Model):
# __tablename__ = 'questions'
#
# id = db.Column(db.Integer, primary_key=True)
# name = db.Column(db.String(STRING_MAX))
# description = db.Column(db.Text)
# prompt = db.Column(db.Text)
# user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
#
# user = db.relationship("User", backref=db.backref('questions', order_by=id))
#
# created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
# updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
#
# class Essay(db.Model):
# __tablename__ = 'essays'
#
# id = db.Column(db.Integer, primary_key=True)
# text = db.Column(db.Text)
# actual_score = db.Column(db.Float)
# info = db.Column(db.Text)
#
# predicted_score = db.Column(db.Float)
# model_id = db.Column(db.Integer, db.ForeignKey('models.id'))
# model = db.relationship("Model", backref=db.backref('essays', order_by=id))
#
# question_id = db.Column(db.Integer, db.ForeignKey('questions.id'))
# question = db.relationship("Question", backref=db.backref('essays', order_by=id))
#
# created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
# updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
. Output only the next line. | def create_and_score(question_id): |
Given snippet: <|code_start|>
class SqlAlchemyTask(celery.Task):
"""An abstract Celery Task that ensures that the connection the the
database is closed on task completion"""
abstract = True
def after_return(self, status, retval, task_id, args, kwargs, einfo):
db.session.remove()
@celery.task(base=SqlAlchemyTask)
def create_model(question_id):
question = Question.query.filter_by(id=question_id).first()
manager = Manager(question)
manager.create_model()
cache.delete('{0}_question_status')
@celery.task(base=SqlAlchemyTask)
def score_essay(essay_id):
essay = Essay.query.filter_by(id=essay_id).first()
manager = Manager(essay.question)
score = manager.score_essay(essay)
essay.predicted_score = score
essay.model = manager.get_latest_model()
db.session.commit()
@celery.task(base=SqlAlchemyTask)
def create_and_score(question_id):
create_model(question_id)
essay_ids = db.session.query(Essay.id).filter(Essay.question_id == question_id).all()
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from app import celery
from core.algo.scorer import Manager
from core.database.models import Question, Essay
from app import db
from app import cache
from app import db, cache
from app import db
and context:
# Path: app.py
# def make_celery(app):
# def __call__(self, *args, **kwargs):
# def create_app():
# def create_test_app():
# class ContextTask(TaskBase):
#
# Path: core/algo/scorer.py
# class Manager(object):
# def __init__(self, question):
# self.question = question
#
# def score_essay(self, essay):
# text = essay.text
# model = self.get_latest_model()
# model_obj = joblib.load(os.path.join(settings.MODEL_PATH, model.path))
# return model_obj.predict(text)
#
# def get_latest_model(self):
# models = self.question.models
#
# if len(models) == 0:
# raise NoModelException
#
# model = models[-1]
# return model
#
# def create_model(self):
# text = [e.text for e in self.question.essays if e.actual_score is not None]
# scores = [e.actual_score for e in self.question.essays if e.actual_score is not None]
# scorer = Scorer(text, scores)
# scorer.train()
# time = datetime.utcnow()
# timestamp = calendar.timegm(time.utctimetuple())
# path_string = "{0}_{1}.pickle".format(self.question.id, timestamp)
# model = Model(
# question=self.question,
# error=scorer.cv_score,
# path=path_string
# )
#
# db.session.add(model)
#
# joblib.dump(scorer, os.path.join(settings.MODEL_PATH, path_string), compress=9)
# db.session.commit()
#
# Path: core/database/models.py
# class Question(db.Model):
# __tablename__ = 'questions'
#
# id = db.Column(db.Integer, primary_key=True)
# name = db.Column(db.String(STRING_MAX))
# description = db.Column(db.Text)
# prompt = db.Column(db.Text)
# user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
#
# user = db.relationship("User", backref=db.backref('questions', order_by=id))
#
# created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
# updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
#
# class Essay(db.Model):
# __tablename__ = 'essays'
#
# id = db.Column(db.Integer, primary_key=True)
# text = db.Column(db.Text)
# actual_score = db.Column(db.Float)
# info = db.Column(db.Text)
#
# predicted_score = db.Column(db.Float)
# model_id = db.Column(db.Integer, db.ForeignKey('models.id'))
# model = db.relationship("Model", backref=db.backref('essays', order_by=id))
#
# question_id = db.Column(db.Integer, db.ForeignKey('questions.id'))
# question = db.relationship("Question", backref=db.backref('essays', order_by=id))
#
# created = db.Column(db.DateTime(timezone=True), default=datetime.utcnow)
# updated = db.Column(db.DateTime(timezone=True), onupdate=datetime.utcnow)
which might include code, classes, or functions. Output only the next line. | for e in essay_ids: |
Based on the snippet: <|code_start|>
class Vectorizer(object):
max_features = settings.MAX_FEATURES / 2
def __init__(self):
self.fit_done = False
def fit(self, input_text, input_scores):
self.initial_vectorizer = CountVectorizer(ngram_range=(1, 2), min_df = 3 / len(input_text), max_df=.4)
self.initial_vectorizer.fit(input_text)
self.vocab = self.get_vocab(self.initial_vectorizer, input_text, input_scores)
<|code_end|>
, predict the immediate next line with the help of imports:
from sklearn.feature_extraction.text import CountVectorizer
from scipy.stats import fisher_exact
from scan import settings
import numpy as np
and context (classes, functions, sometimes code) from other files:
# Path: scan/settings.py
# DB_URL = 'sqlite:///scan.db'
# DEBUG = True
# ROOT_PATH = path(__file__).dirname()
# REPO_PATH = ROOT_PATH.dirname()
# ENV_ROOT = REPO_PATH.dirname()
# DATA_PATH = os.path.join(REPO_PATH, "data")
# TEST_DATA_PATH = os.path.join(DATA_PATH, "test")
# MODEL_PATH = os.path.join(DATA_PATH, "models")
# SECRET_KEY = "30y^$e7henbp@#_w+z9)o9f8tovjrhoq(%vw=%#*(1-1esrh!_"
# USERNAME = "test"
# EMAIL = "test@test.com"
# PASSWORD = "test"
# SQLALCHEMY_DATABASE_URI = DB_URL
# SECURITY_REGISTERABLE = True
# SECURITY_RECOVERABLE = True
# SECURITY_SEND_REGISTER_EMAIL = False
# SECURITY_PASSWORD_HASH = "bcrypt"
# SECURITY_PASSWORD_SALT = SECRET_KEY
# BROKER_TRANSPORT_OPTIONS = {'visibility_timeout': 3600}
# BROKER_URL = 'redis://localhost:6379/3'
# CELERY_RESULT_BACKEND = 'redis://localhost:6379/3'
# CELERY_IMPORTS = ('core.tasks.tasks',)
# CACHE_TYPE = 'redis'
# CACHE_REDIS_URL = 'redis://localhost:6379/4'
# CACHE_REDIS_DB = 4
# MAX_FEATURES = 500
# MODEL_VERSION = 1
. Output only the next line. | self.vectorizer = CountVectorizer(ngram_range=(1, 2), vocabulary=self.vocab) |
Given snippet: <|code_start|>
app = create_test_app()
db.app = app
db.init_app(app)
log = logging.getLogger(__name__)
class ScanTest(TestCase):
def create_app(self):
return app
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from flask.ext.testing import TestCase
from mock import patch
from app import create_test_app, db
from scan.log import logging
and context:
# Path: app.py
# def make_celery(app):
# def __call__(self, *args, **kwargs):
# def create_app():
# def create_test_app():
# class ContextTask(TaskBase):
#
# Path: scan/log.py
# LOGGING = {
# 'version': 1,
# 'disable_existing_loggers': False,
# 'formatters': {
# 'standard': {
# 'format': '%(asctime)s %(levelname)s %(process)d '
# '[%(name)s] %(filename)s:%(lineno)d - %(message)s',
# },
# 'syslog_format': {'format': syslog_format},
# 'raw': {'format': '%(message)s'},
# },
# 'handlers': {
# 'console': {
# 'level': 'DEBUG',
# 'class': 'logging.StreamHandler',
# 'formatter': 'standard',
# 'stream': sys.stdout,
# }
# },
# 'loggers': {
# 'requests.packages.urllib3.connectionpool': {
# 'handlers': [],
# 'propagate': False,
# 'level': 'DEBUG',
# },
# '': {
# 'handlers': ['console'],
# 'level': 'DEBUG',
# 'propagate': False
# },
# }
# }
which might include code, classes, or functions. Output only the next line. | def setUp(self): |
Continue the code snippet: <|code_start|>
app = create_test_app()
db.app = app
db.init_app(app)
log = logging.getLogger(__name__)
class ScanTest(TestCase):
def create_app(self):
<|code_end|>
. Use current file imports:
from flask.ext.testing import TestCase
from mock import patch
from app import create_test_app, db
from scan.log import logging
and context (classes, functions, or code) from other files:
# Path: app.py
# def make_celery(app):
# def __call__(self, *args, **kwargs):
# def create_app():
# def create_test_app():
# class ContextTask(TaskBase):
#
# Path: scan/log.py
# LOGGING = {
# 'version': 1,
# 'disable_existing_loggers': False,
# 'formatters': {
# 'standard': {
# 'format': '%(asctime)s %(levelname)s %(process)d '
# '[%(name)s] %(filename)s:%(lineno)d - %(message)s',
# },
# 'syslog_format': {'format': syslog_format},
# 'raw': {'format': '%(message)s'},
# },
# 'handlers': {
# 'console': {
# 'level': 'DEBUG',
# 'class': 'logging.StreamHandler',
# 'formatter': 'standard',
# 'stream': sys.stdout,
# }
# },
# 'loggers': {
# 'requests.packages.urllib3.connectionpool': {
# 'handlers': [],
# 'propagate': False,
# 'level': 'DEBUG',
# },
# '': {
# 'handlers': ['console'],
# 'level': 'DEBUG',
# 'propagate': False
# },
# }
# }
. Output only the next line. | return app |
Given the following code snippet before the placeholder: <|code_start|>
app = create_test_app()
db.app = app
db.init_app(app)
log = logging.getLogger(__name__)
class ScanTest(TestCase):
def create_app(self):
<|code_end|>
, predict the next line using imports from the current file:
from flask.ext.testing import TestCase
from mock import patch
from app import create_test_app, db
from scan.log import logging
and context including class names, function names, and sometimes code from other files:
# Path: app.py
# def make_celery(app):
# def __call__(self, *args, **kwargs):
# def create_app():
# def create_test_app():
# class ContextTask(TaskBase):
#
# Path: scan/log.py
# LOGGING = {
# 'version': 1,
# 'disable_existing_loggers': False,
# 'formatters': {
# 'standard': {
# 'format': '%(asctime)s %(levelname)s %(process)d '
# '[%(name)s] %(filename)s:%(lineno)d - %(message)s',
# },
# 'syslog_format': {'format': syslog_format},
# 'raw': {'format': '%(message)s'},
# },
# 'handlers': {
# 'console': {
# 'level': 'DEBUG',
# 'class': 'logging.StreamHandler',
# 'formatter': 'standard',
# 'stream': sys.stdout,
# }
# },
# 'loggers': {
# 'requests.packages.urllib3.connectionpool': {
# 'handlers': [],
# 'propagate': False,
# 'level': 'DEBUG',
# },
# '': {
# 'handlers': ['console'],
# 'level': 'DEBUG',
# 'propagate': False
# },
# }
# }
. Output only the next line. | return app |
Using the snippet: <|code_start|> if line[-2:] == ["\r", "\n"]:
yield "".join(line).strip()
line.clear()
async def _async_event_lines(ret: AsyncIterable[str]) -> AsyncIterator[str]:
line = []
async for char in ret:
line.append(char)
if line[-2:] == ["\r", "\n"]:
yield "".join(line).strip()
line.clear()
class Event(Http):
def event_handler_config(self, handlername: str) -> str:
return self._get_config(handlername)
async def async_event_handler_config(self, handlername: str) -> str:
return await self._async_get_config(handlername)
def alarm_handler(self, alarm_name: str) -> str:
ret = self.command("alarm.cgi?action={alarm_name}")
return ret.content.decode()
async def async_alarm_handler(self, alarm_name: str) -> str:
ret = await self.async_command("alarm.cgi?action={alarm_name}")
return ret.content.decode()
@property
<|code_end|>
, determine the next line of code. You have imports:
import logging
import re
from typing import (
Any,
AsyncIterator,
AsyncIterable,
Dict,
Iterator,
Iterable,
List,
Optional,
Tuple,
)
from requests import RequestException
from urllib3.exceptions import HTTPError
from .exceptions import CommError
from .http import Http, TimeoutT
from .utils import pretty
and context (class names, function names, or code) available:
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# Path: src/amcrest/http.py
# _LOGGER = logging.getLogger(__name__)
# _KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
# (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
# ]
# class SOHTTPAdapter(HTTPAdapter):
# class Http:
# def __init__(self, *args, **kwargs) -> None:
# def init_poolmanager(self, *args, **kwargs) -> None:
# def __init__(
# self,
# host: str,
# port: int,
# user: str,
# password: str,
# *,
# verbose: bool = True,
# protocol: str = "http",
# ssl_verify: bool = True,
# retries_connection: Optional[int] = None,
# timeout_protocol: TimeoutT = None,
# ) -> None:
# def _generate_token(self) -> None:
# async def _async_generate_token(self) -> None:
# def __repr__(self) -> str:
# def as_dict(self) -> dict:
# def __base_url(self, param: str = "") -> str:
# def get_base_url(self) -> str:
# def command(self, *args, **kwargs) -> requests.Response:
# async def async_command(self, *args, **kwargs) -> httpx.Response:
# async def async_stream_command(
# self, *args, **kwargs
# ) -> AsyncIterator[httpx.Response]:
# def _command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# stream: bool = False,
# ) -> requests.Response:
# async def _async_command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# ) -> httpx.Response:
# async def _async_stream_command(
# self,
# cmd: str,
# timeout_cmd: TimeoutT = None,
# ) -> AsyncIterator[httpx.Response]:
# def command_audio(
# self,
# cmd: str,
# file_content,
# http_header,
# timeout: TimeoutT = None,
# ) -> None:
# def _get_config(self, config_name: str) -> str:
# async def _async_get_config(self, config_name: str) -> str:
# def _magic_box(self, action: str) -> str:
# async def _async_magic_box(self, action: str) -> str:
#
# Path: src/amcrest/utils.py
# def pretty(value: str, delimiter: str = "=") -> str:
# """Format string key=value."""
# return value.strip().rpartition(delimiter)[2]
. Output only the next line. | def alarm_config(self) -> str: |
Predict the next line after this snippet: <|code_start|> @property
def video_loss_detect_config(self) -> str:
return self.event_handler_config("LossDetect")
@property
async def async_video_loss_detect_config(self) -> str:
return await self.async_event_handler_config("LossDetect")
@property
def event_login_failure(self) -> str:
return self.event_handler_config("LoginFailureAlarm")
@property
async def async_event_login_failure(self) -> str:
return await self.async_event_handler_config("LoginFailureAlarm")
@property
def event_storage_not_exist(self) -> str:
return self.event_handler_config("StorageNotExist")
@property
async def async_event_storage_not_exist(self) -> str:
return await self.async_event_handler_config("StorageNotExist")
@property
def event_storage_access_failure(self) -> str:
return self.event_handler_config("StorageFailure")
@property
async def async_event_storage_access_failure(self) -> str:
<|code_end|>
using the current file's imports:
import logging
import re
from typing import (
Any,
AsyncIterator,
AsyncIterable,
Dict,
Iterator,
Iterable,
List,
Optional,
Tuple,
)
from requests import RequestException
from urllib3.exceptions import HTTPError
from .exceptions import CommError
from .http import Http, TimeoutT
from .utils import pretty
and any relevant context from other files:
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# Path: src/amcrest/http.py
# _LOGGER = logging.getLogger(__name__)
# _KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
# (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
# ]
# class SOHTTPAdapter(HTTPAdapter):
# class Http:
# def __init__(self, *args, **kwargs) -> None:
# def init_poolmanager(self, *args, **kwargs) -> None:
# def __init__(
# self,
# host: str,
# port: int,
# user: str,
# password: str,
# *,
# verbose: bool = True,
# protocol: str = "http",
# ssl_verify: bool = True,
# retries_connection: Optional[int] = None,
# timeout_protocol: TimeoutT = None,
# ) -> None:
# def _generate_token(self) -> None:
# async def _async_generate_token(self) -> None:
# def __repr__(self) -> str:
# def as_dict(self) -> dict:
# def __base_url(self, param: str = "") -> str:
# def get_base_url(self) -> str:
# def command(self, *args, **kwargs) -> requests.Response:
# async def async_command(self, *args, **kwargs) -> httpx.Response:
# async def async_stream_command(
# self, *args, **kwargs
# ) -> AsyncIterator[httpx.Response]:
# def _command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# stream: bool = False,
# ) -> requests.Response:
# async def _async_command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# ) -> httpx.Response:
# async def _async_stream_command(
# self,
# cmd: str,
# timeout_cmd: TimeoutT = None,
# ) -> AsyncIterator[httpx.Response]:
# def command_audio(
# self,
# cmd: str,
# file_content,
# http_header,
# timeout: TimeoutT = None,
# ) -> None:
# def _get_config(self, config_name: str) -> str:
# async def _async_get_config(self, config_name: str) -> str:
# def _magic_box(self, action: str) -> str:
# async def _async_magic_box(self, action: str) -> str:
#
# Path: src/amcrest/utils.py
# def pretty(value: str, delimiter: str = "=") -> str:
# """Format string key=value."""
# return value.strip().rpartition(delimiter)[2]
. Output only the next line. | return await self.async_event_handler_config("StorageFailure") |
Continue the code snippet: <|code_start|> @property
async def async_alarm_states_input_channels(self) -> str:
return await self.async_alarm_handler("getInState")
@property
def alarm_states_output_channels(self) -> str:
return self.alarm_handler("getOutState")
@property
async def async_alarm_states_output_channels(self) -> str:
return await self.async_alarm_handler("getOutState")
@property
def video_blind_detect_config(self) -> str:
return self.event_handler_config("BlindDetect")
@property
async def async_video_blind_detect_config(self) -> str:
return await self.async_event_handler_config("BlindDetect")
@property
def video_loss_detect_config(self) -> str:
return self.event_handler_config("LossDetect")
@property
async def async_video_loss_detect_config(self) -> str:
return await self.async_event_handler_config("LossDetect")
@property
def event_login_failure(self) -> str:
<|code_end|>
. Use current file imports:
import logging
import re
from typing import (
Any,
AsyncIterator,
AsyncIterable,
Dict,
Iterator,
Iterable,
List,
Optional,
Tuple,
)
from requests import RequestException
from urllib3.exceptions import HTTPError
from .exceptions import CommError
from .http import Http, TimeoutT
from .utils import pretty
and context (classes, functions, or code) from other files:
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# Path: src/amcrest/http.py
# _LOGGER = logging.getLogger(__name__)
# _KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
# (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
# ]
# class SOHTTPAdapter(HTTPAdapter):
# class Http:
# def __init__(self, *args, **kwargs) -> None:
# def init_poolmanager(self, *args, **kwargs) -> None:
# def __init__(
# self,
# host: str,
# port: int,
# user: str,
# password: str,
# *,
# verbose: bool = True,
# protocol: str = "http",
# ssl_verify: bool = True,
# retries_connection: Optional[int] = None,
# timeout_protocol: TimeoutT = None,
# ) -> None:
# def _generate_token(self) -> None:
# async def _async_generate_token(self) -> None:
# def __repr__(self) -> str:
# def as_dict(self) -> dict:
# def __base_url(self, param: str = "") -> str:
# def get_base_url(self) -> str:
# def command(self, *args, **kwargs) -> requests.Response:
# async def async_command(self, *args, **kwargs) -> httpx.Response:
# async def async_stream_command(
# self, *args, **kwargs
# ) -> AsyncIterator[httpx.Response]:
# def _command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# stream: bool = False,
# ) -> requests.Response:
# async def _async_command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# ) -> httpx.Response:
# async def _async_stream_command(
# self,
# cmd: str,
# timeout_cmd: TimeoutT = None,
# ) -> AsyncIterator[httpx.Response]:
# def command_audio(
# self,
# cmd: str,
# file_content,
# http_header,
# timeout: TimeoutT = None,
# ) -> None:
# def _get_config(self, config_name: str) -> str:
# async def _async_get_config(self, config_name: str) -> str:
# def _magic_box(self, action: str) -> str:
# async def _async_magic_box(self, action: str) -> str:
#
# Path: src/amcrest/utils.py
# def pretty(value: str, delimiter: str = "=") -> str:
# """Format string key=value."""
# return value.strip().rpartition(delimiter)[2]
. Output only the next line. | return self.event_handler_config("LoginFailureAlarm") |
Predict the next line after this snippet: <|code_start|> @property
def alarm_states_input_channels(self) -> str:
return self.alarm_handler("getInState")
@property
async def async_alarm_states_input_channels(self) -> str:
return await self.async_alarm_handler("getInState")
@property
def alarm_states_output_channels(self) -> str:
return self.alarm_handler("getOutState")
@property
async def async_alarm_states_output_channels(self) -> str:
return await self.async_alarm_handler("getOutState")
@property
def video_blind_detect_config(self) -> str:
return self.event_handler_config("BlindDetect")
@property
async def async_video_blind_detect_config(self) -> str:
return await self.async_event_handler_config("BlindDetect")
@property
def video_loss_detect_config(self) -> str:
return self.event_handler_config("LossDetect")
@property
async def async_video_loss_detect_config(self) -> str:
<|code_end|>
using the current file's imports:
import logging
import re
from typing import (
Any,
AsyncIterator,
AsyncIterable,
Dict,
Iterator,
Iterable,
List,
Optional,
Tuple,
)
from requests import RequestException
from urllib3.exceptions import HTTPError
from .exceptions import CommError
from .http import Http, TimeoutT
from .utils import pretty
and any relevant context from other files:
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# Path: src/amcrest/http.py
# _LOGGER = logging.getLogger(__name__)
# _KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
# (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
# ]
# class SOHTTPAdapter(HTTPAdapter):
# class Http:
# def __init__(self, *args, **kwargs) -> None:
# def init_poolmanager(self, *args, **kwargs) -> None:
# def __init__(
# self,
# host: str,
# port: int,
# user: str,
# password: str,
# *,
# verbose: bool = True,
# protocol: str = "http",
# ssl_verify: bool = True,
# retries_connection: Optional[int] = None,
# timeout_protocol: TimeoutT = None,
# ) -> None:
# def _generate_token(self) -> None:
# async def _async_generate_token(self) -> None:
# def __repr__(self) -> str:
# def as_dict(self) -> dict:
# def __base_url(self, param: str = "") -> str:
# def get_base_url(self) -> str:
# def command(self, *args, **kwargs) -> requests.Response:
# async def async_command(self, *args, **kwargs) -> httpx.Response:
# async def async_stream_command(
# self, *args, **kwargs
# ) -> AsyncIterator[httpx.Response]:
# def _command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# stream: bool = False,
# ) -> requests.Response:
# async def _async_command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# ) -> httpx.Response:
# async def _async_stream_command(
# self,
# cmd: str,
# timeout_cmd: TimeoutT = None,
# ) -> AsyncIterator[httpx.Response]:
# def command_audio(
# self,
# cmd: str,
# file_content,
# http_header,
# timeout: TimeoutT = None,
# ) -> None:
# def _get_config(self, config_name: str) -> str:
# async def _async_get_config(self, config_name: str) -> str:
# def _magic_box(self, action: str) -> str:
# async def _async_magic_box(self, action: str) -> str:
#
# Path: src/amcrest/utils.py
# def pretty(value: str, delimiter: str = "=") -> str:
# """Format string key=value."""
# return value.strip().rpartition(delimiter)[2]
. Output only the next line. | return await self.async_event_handler_config("LossDetect") |
Predict the next line after this snippet: <|code_start|>
_LOGGER = logging.getLogger(__name__)
class Media(Http):
def factory_create(self) -> str:
ret = self.command("mediaFileFind.cgi?action=factory.create")
return ret.content.decode()
def factory_close(self, factory_id: str) -> str:
ret = self.command(
f"mediaFileFind.cgi?action=factory.close&object={factory_id}"
)
return ret.content.decode()
def factory_destroy(self, factory_id: str) -> str:
ret = self.command(
f"mediaFileFind.cgi?action=factory.destroy&object={factory_id}"
)
return ret.content.decode()
def media_file_find_start(
self,
factory_id: str,
start_time: datetime,
end_time: datetime,
channel: int = 0,
directories: Sequence[str] = (),
<|code_end|>
using the current file's imports:
import logging
from datetime import datetime
from typing import Iterator, Optional, Sequence
from .http import Http, TimeoutT
from .utils import date_to_str
and any relevant context from other files:
# Path: src/amcrest/http.py
# _LOGGER = logging.getLogger(__name__)
# _KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
# (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
# ]
# class SOHTTPAdapter(HTTPAdapter):
# class Http:
# def __init__(self, *args, **kwargs) -> None:
# def init_poolmanager(self, *args, **kwargs) -> None:
# def __init__(
# self,
# host: str,
# port: int,
# user: str,
# password: str,
# *,
# verbose: bool = True,
# protocol: str = "http",
# ssl_verify: bool = True,
# retries_connection: Optional[int] = None,
# timeout_protocol: TimeoutT = None,
# ) -> None:
# def _generate_token(self) -> None:
# async def _async_generate_token(self) -> None:
# def __repr__(self) -> str:
# def as_dict(self) -> dict:
# def __base_url(self, param: str = "") -> str:
# def get_base_url(self) -> str:
# def command(self, *args, **kwargs) -> requests.Response:
# async def async_command(self, *args, **kwargs) -> httpx.Response:
# async def async_stream_command(
# self, *args, **kwargs
# ) -> AsyncIterator[httpx.Response]:
# def _command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# stream: bool = False,
# ) -> requests.Response:
# async def _async_command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# ) -> httpx.Response:
# async def _async_stream_command(
# self,
# cmd: str,
# timeout_cmd: TimeoutT = None,
# ) -> AsyncIterator[httpx.Response]:
# def command_audio(
# self,
# cmd: str,
# file_content,
# http_header,
# timeout: TimeoutT = None,
# ) -> None:
# def _get_config(self, config_name: str) -> str:
# async def _async_get_config(self, config_name: str) -> str:
# def _magic_box(self, action: str) -> str:
# async def _async_magic_box(self, action: str) -> str:
#
# Path: src/amcrest/utils.py
# def date_to_str(value: datetime) -> str:
# return value.strftime(DATEFMT)
. Output only the next line. | types: Sequence[str] = (), |
Based on the snippet: <|code_start|># This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# vim:sw=4:ts=4:et
_LOGGER = logging.getLogger(__name__)
class Media(Http):
def factory_create(self) -> str:
ret = self.command("mediaFileFind.cgi?action=factory.create")
return ret.content.decode()
def factory_close(self, factory_id: str) -> str:
ret = self.command(
f"mediaFileFind.cgi?action=factory.close&object={factory_id}"
<|code_end|>
, predict the immediate next line with the help of imports:
import logging
from datetime import datetime
from typing import Iterator, Optional, Sequence
from .http import Http, TimeoutT
from .utils import date_to_str
and context (classes, functions, sometimes code) from other files:
# Path: src/amcrest/http.py
# _LOGGER = logging.getLogger(__name__)
# _KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
# (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
# ]
# class SOHTTPAdapter(HTTPAdapter):
# class Http:
# def __init__(self, *args, **kwargs) -> None:
# def init_poolmanager(self, *args, **kwargs) -> None:
# def __init__(
# self,
# host: str,
# port: int,
# user: str,
# password: str,
# *,
# verbose: bool = True,
# protocol: str = "http",
# ssl_verify: bool = True,
# retries_connection: Optional[int] = None,
# timeout_protocol: TimeoutT = None,
# ) -> None:
# def _generate_token(self) -> None:
# async def _async_generate_token(self) -> None:
# def __repr__(self) -> str:
# def as_dict(self) -> dict:
# def __base_url(self, param: str = "") -> str:
# def get_base_url(self) -> str:
# def command(self, *args, **kwargs) -> requests.Response:
# async def async_command(self, *args, **kwargs) -> httpx.Response:
# async def async_stream_command(
# self, *args, **kwargs
# ) -> AsyncIterator[httpx.Response]:
# def _command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# stream: bool = False,
# ) -> requests.Response:
# async def _async_command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# ) -> httpx.Response:
# async def _async_stream_command(
# self,
# cmd: str,
# timeout_cmd: TimeoutT = None,
# ) -> AsyncIterator[httpx.Response]:
# def command_audio(
# self,
# cmd: str,
# file_content,
# http_header,
# timeout: TimeoutT = None,
# ) -> None:
# def _get_config(self, config_name: str) -> str:
# async def _async_get_config(self, config_name: str) -> str:
# def _magic_box(self, action: str) -> str:
# async def _async_magic_box(self, action: str) -> str:
#
# Path: src/amcrest/utils.py
# def date_to_str(value: datetime) -> str:
# return value.strftime(DATEFMT)
. Output only the next line. | ) |
Predict the next line for this snippet: <|code_start|>
_LOGGER = logging.getLogger(__name__)
class Snapshot(Http):
@property
def snapshot_config(self) -> str:
return self._get_config("Snap")
@property
async def async_snapshot_config(self) -> str:
return await self._async_get_config("Snap")
@overload
def snapshot(
self,
*,
channel: Optional[int] = ...,
path_file: Optional[str] = ...,
timeout: TimeoutT = ...,
stream: Literal[True] = ...,
) -> HTTPResponse:
...
@overload
def snapshot(
self,
*,
channel: Optional[int] = ...,
<|code_end|>
with the help of current file imports:
import logging
import shutil
from typing import Optional, Union, overload
from typing_extensions import Literal
from urllib3.exceptions import HTTPError
from urllib3.response import HTTPResponse
from .exceptions import CommError
from .http import Http, TimeoutT
and context from other files:
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# Path: src/amcrest/http.py
# _LOGGER = logging.getLogger(__name__)
# _KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
# (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
# ]
# class SOHTTPAdapter(HTTPAdapter):
# class Http:
# def __init__(self, *args, **kwargs) -> None:
# def init_poolmanager(self, *args, **kwargs) -> None:
# def __init__(
# self,
# host: str,
# port: int,
# user: str,
# password: str,
# *,
# verbose: bool = True,
# protocol: str = "http",
# ssl_verify: bool = True,
# retries_connection: Optional[int] = None,
# timeout_protocol: TimeoutT = None,
# ) -> None:
# def _generate_token(self) -> None:
# async def _async_generate_token(self) -> None:
# def __repr__(self) -> str:
# def as_dict(self) -> dict:
# def __base_url(self, param: str = "") -> str:
# def get_base_url(self) -> str:
# def command(self, *args, **kwargs) -> requests.Response:
# async def async_command(self, *args, **kwargs) -> httpx.Response:
# async def async_stream_command(
# self, *args, **kwargs
# ) -> AsyncIterator[httpx.Response]:
# def _command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# stream: bool = False,
# ) -> requests.Response:
# async def _async_command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# ) -> httpx.Response:
# async def _async_stream_command(
# self,
# cmd: str,
# timeout_cmd: TimeoutT = None,
# ) -> AsyncIterator[httpx.Response]:
# def command_audio(
# self,
# cmd: str,
# file_content,
# http_header,
# timeout: TimeoutT = None,
# ) -> None:
# def _get_config(self, config_name: str) -> str:
# async def _async_get_config(self, config_name: str) -> str:
# def _magic_box(self, action: str) -> str:
# async def _async_magic_box(self, action: str) -> str:
, which may contain function names, class names, or code. Output only the next line. | path_file: Optional[str] = ..., |
Given the code snippet: <|code_start|># vim:sw=4:ts=4:et
_LOGGER = logging.getLogger(__name__)
class Snapshot(Http):
@property
def snapshot_config(self) -> str:
return self._get_config("Snap")
@property
async def async_snapshot_config(self) -> str:
return await self._async_get_config("Snap")
@overload
def snapshot(
self,
*,
channel: Optional[int] = ...,
path_file: Optional[str] = ...,
timeout: TimeoutT = ...,
stream: Literal[True] = ...,
) -> HTTPResponse:
...
@overload
def snapshot(
self,
<|code_end|>
, generate the next line using the imports in this file:
import logging
import shutil
from typing import Optional, Union, overload
from typing_extensions import Literal
from urllib3.exceptions import HTTPError
from urllib3.response import HTTPResponse
from .exceptions import CommError
from .http import Http, TimeoutT
and context (functions, classes, or occasionally code) from other files:
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# Path: src/amcrest/http.py
# _LOGGER = logging.getLogger(__name__)
# _KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
# (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
# ]
# class SOHTTPAdapter(HTTPAdapter):
# class Http:
# def __init__(self, *args, **kwargs) -> None:
# def init_poolmanager(self, *args, **kwargs) -> None:
# def __init__(
# self,
# host: str,
# port: int,
# user: str,
# password: str,
# *,
# verbose: bool = True,
# protocol: str = "http",
# ssl_verify: bool = True,
# retries_connection: Optional[int] = None,
# timeout_protocol: TimeoutT = None,
# ) -> None:
# def _generate_token(self) -> None:
# async def _async_generate_token(self) -> None:
# def __repr__(self) -> str:
# def as_dict(self) -> dict:
# def __base_url(self, param: str = "") -> str:
# def get_base_url(self) -> str:
# def command(self, *args, **kwargs) -> requests.Response:
# async def async_command(self, *args, **kwargs) -> httpx.Response:
# async def async_stream_command(
# self, *args, **kwargs
# ) -> AsyncIterator[httpx.Response]:
# def _command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# stream: bool = False,
# ) -> requests.Response:
# async def _async_command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# ) -> httpx.Response:
# async def _async_stream_command(
# self,
# cmd: str,
# timeout_cmd: TimeoutT = None,
# ) -> AsyncIterator[httpx.Response]:
# def command_audio(
# self,
# cmd: str,
# file_content,
# http_header,
# timeout: TimeoutT = None,
# ) -> None:
# def _get_config(self, config_name: str) -> str:
# async def _async_get_config(self, config_name: str) -> str:
# def _magic_box(self, action: str) -> str:
# async def _async_magic_box(self, action: str) -> str:
. Output only the next line. | *, |
Predict the next line after this snippet: <|code_start|># This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# vim:sw=4:ts=4:et
_LOGGER = logging.getLogger(__name__)
class Snapshot(Http):
@property
<|code_end|>
using the current file's imports:
import logging
import shutil
from typing import Optional, Union, overload
from typing_extensions import Literal
from urllib3.exceptions import HTTPError
from urllib3.response import HTTPResponse
from .exceptions import CommError
from .http import Http, TimeoutT
and any relevant context from other files:
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# Path: src/amcrest/http.py
# _LOGGER = logging.getLogger(__name__)
# _KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
# (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
# ]
# class SOHTTPAdapter(HTTPAdapter):
# class Http:
# def __init__(self, *args, **kwargs) -> None:
# def init_poolmanager(self, *args, **kwargs) -> None:
# def __init__(
# self,
# host: str,
# port: int,
# user: str,
# password: str,
# *,
# verbose: bool = True,
# protocol: str = "http",
# ssl_verify: bool = True,
# retries_connection: Optional[int] = None,
# timeout_protocol: TimeoutT = None,
# ) -> None:
# def _generate_token(self) -> None:
# async def _async_generate_token(self) -> None:
# def __repr__(self) -> str:
# def as_dict(self) -> dict:
# def __base_url(self, param: str = "") -> str:
# def get_base_url(self) -> str:
# def command(self, *args, **kwargs) -> requests.Response:
# async def async_command(self, *args, **kwargs) -> httpx.Response:
# async def async_stream_command(
# self, *args, **kwargs
# ) -> AsyncIterator[httpx.Response]:
# def _command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# stream: bool = False,
# ) -> requests.Response:
# async def _async_command(
# self,
# cmd: str,
# retries: Optional[int] = None,
# timeout_cmd: TimeoutT = None,
# ) -> httpx.Response:
# async def _async_stream_command(
# self,
# cmd: str,
# timeout_cmd: TimeoutT = None,
# ) -> AsyncIterator[httpx.Response]:
# def command_audio(
# self,
# cmd: str,
# file_content,
# http_header,
# timeout: TimeoutT = None,
# ) -> None:
# def _get_config(self, config_name: str) -> str:
# async def _async_get_config(self, config_name: str) -> str:
# def _magic_box(self, action: str) -> str:
# async def _async_magic_box(self, action: str) -> str:
. Output only the next line. | def snapshot_config(self) -> str: |
Here is a snippet: <|code_start|># This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# vim:sw=4:ts=4:et
_LOGGER = logging.getLogger(__name__)
_KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
]
# On some systems TCP_KEEP* are not defined in socket.
try:
_KEEPALIVE_OPTS += [
(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, KEEPALIVE_IDLE),
(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, KEEPALIVE_INTERVAL),
(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, KEEPALIVE_COUNT),
<|code_end|>
. Write the next line using the current file imports:
import asyncio
import logging
import re
import socket
import threading
import httpx
import requests
from contextlib import asynccontextmanager
from typing import AsyncIterator, Optional, Tuple, Union
from requests.adapters import HTTPAdapter
from urllib3.connection import HTTPConnection
from .config import (
KEEPALIVE_COUNT,
KEEPALIVE_IDLE,
KEEPALIVE_INTERVAL,
MAX_RETRY_HTTP_CONNECTION,
TIMEOUT_HTTP_PROTOCOL,
)
from .exceptions import CommError, LoginError
from .utils import clean_url, pretty
and context from other files:
# Path: src/amcrest/config.py
# KEEPALIVE_COUNT = 5
#
# KEEPALIVE_IDLE = 20
#
# KEEPALIVE_INTERVAL = 10
#
# MAX_RETRY_HTTP_CONNECTION = 3
#
# TIMEOUT_HTTP_PROTOCOL = 6.05
#
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# class LoginError(AmcrestError):
# """A login error occurred."""
#
# Path: src/amcrest/utils.py
# def clean_url(url: str) -> str:
# host = re.sub(r"^http[s]?://", "", url, flags=re.IGNORECASE)
# host = re.sub(r"/$", "", host)
# return host
#
# def pretty(value: str, delimiter: str = "=") -> str:
# """Format string key=value."""
# return value.strip().rpartition(delimiter)[2]
, which may include functions, classes, or code. Output only the next line. | ] |
Given the following code snippet before the placeholder: <|code_start|># it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# vim:sw=4:ts=4:et
_LOGGER = logging.getLogger(__name__)
_KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
]
# On some systems TCP_KEEP* are not defined in socket.
try:
_KEEPALIVE_OPTS += [
(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, KEEPALIVE_IDLE),
(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, KEEPALIVE_INTERVAL),
(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, KEEPALIVE_COUNT),
]
except AttributeError:
pass
TimeoutT = Union[Optional[float], Tuple[Optional[float], Optional[float]]]
HttpxTimeoutT = Union[
Optional[float],
<|code_end|>
, predict the next line using imports from the current file:
import asyncio
import logging
import re
import socket
import threading
import httpx
import requests
from contextlib import asynccontextmanager
from typing import AsyncIterator, Optional, Tuple, Union
from requests.adapters import HTTPAdapter
from urllib3.connection import HTTPConnection
from .config import (
KEEPALIVE_COUNT,
KEEPALIVE_IDLE,
KEEPALIVE_INTERVAL,
MAX_RETRY_HTTP_CONNECTION,
TIMEOUT_HTTP_PROTOCOL,
)
from .exceptions import CommError, LoginError
from .utils import clean_url, pretty
and context including class names, function names, and sometimes code from other files:
# Path: src/amcrest/config.py
# KEEPALIVE_COUNT = 5
#
# KEEPALIVE_IDLE = 20
#
# KEEPALIVE_INTERVAL = 10
#
# MAX_RETRY_HTTP_CONNECTION = 3
#
# TIMEOUT_HTTP_PROTOCOL = 6.05
#
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# class LoginError(AmcrestError):
# """A login error occurred."""
#
# Path: src/amcrest/utils.py
# def clean_url(url: str) -> str:
# host = re.sub(r"^http[s]?://", "", url, flags=re.IGNORECASE)
# host = re.sub(r"/$", "", host)
# return host
#
# def pretty(value: str, delimiter: str = "=") -> str:
# """Format string key=value."""
# return value.strip().rpartition(delimiter)[2]
. Output only the next line. | Tuple[Optional[float], Optional[float], Optional[float], Optional[float]], |
Continue the code snippet: <|code_start|># the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# vim:sw=4:ts=4:et
_LOGGER = logging.getLogger(__name__)
_KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
]
# On some systems TCP_KEEP* are not defined in socket.
try:
_KEEPALIVE_OPTS += [
(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, KEEPALIVE_IDLE),
(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, KEEPALIVE_INTERVAL),
(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, KEEPALIVE_COUNT),
]
except AttributeError:
pass
TimeoutT = Union[Optional[float], Tuple[Optional[float], Optional[float]]]
HttpxTimeoutT = Union[
Optional[float],
Tuple[Optional[float], Optional[float], Optional[float], Optional[float]],
<|code_end|>
. Use current file imports:
import asyncio
import logging
import re
import socket
import threading
import httpx
import requests
from contextlib import asynccontextmanager
from typing import AsyncIterator, Optional, Tuple, Union
from requests.adapters import HTTPAdapter
from urllib3.connection import HTTPConnection
from .config import (
KEEPALIVE_COUNT,
KEEPALIVE_IDLE,
KEEPALIVE_INTERVAL,
MAX_RETRY_HTTP_CONNECTION,
TIMEOUT_HTTP_PROTOCOL,
)
from .exceptions import CommError, LoginError
from .utils import clean_url, pretty
and context (classes, functions, or code) from other files:
# Path: src/amcrest/config.py
# KEEPALIVE_COUNT = 5
#
# KEEPALIVE_IDLE = 20
#
# KEEPALIVE_INTERVAL = 10
#
# MAX_RETRY_HTTP_CONNECTION = 3
#
# TIMEOUT_HTTP_PROTOCOL = 6.05
#
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# class LoginError(AmcrestError):
# """A login error occurred."""
#
# Path: src/amcrest/utils.py
# def clean_url(url: str) -> str:
# host = re.sub(r"^http[s]?://", "", url, flags=re.IGNORECASE)
# host = re.sub(r"/$", "", host)
# return host
#
# def pretty(value: str, delimiter: str = "=") -> str:
# """Format string key=value."""
# return value.strip().rpartition(delimiter)[2]
. Output only the next line. | ] |
Continue the code snippet: <|code_start|># but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# vim:sw=4:ts=4:et
_LOGGER = logging.getLogger(__name__)
_KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
]
# On some systems TCP_KEEP* are not defined in socket.
try:
_KEEPALIVE_OPTS += [
(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, KEEPALIVE_IDLE),
(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, KEEPALIVE_INTERVAL),
(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, KEEPALIVE_COUNT),
]
except AttributeError:
pass
TimeoutT = Union[Optional[float], Tuple[Optional[float], Optional[float]]]
HttpxTimeoutT = Union[
Optional[float],
Tuple[Optional[float], Optional[float], Optional[float], Optional[float]],
]
<|code_end|>
. Use current file imports:
import asyncio
import logging
import re
import socket
import threading
import httpx
import requests
from contextlib import asynccontextmanager
from typing import AsyncIterator, Optional, Tuple, Union
from requests.adapters import HTTPAdapter
from urllib3.connection import HTTPConnection
from .config import (
KEEPALIVE_COUNT,
KEEPALIVE_IDLE,
KEEPALIVE_INTERVAL,
MAX_RETRY_HTTP_CONNECTION,
TIMEOUT_HTTP_PROTOCOL,
)
from .exceptions import CommError, LoginError
from .utils import clean_url, pretty
and context (classes, functions, or code) from other files:
# Path: src/amcrest/config.py
# KEEPALIVE_COUNT = 5
#
# KEEPALIVE_IDLE = 20
#
# KEEPALIVE_INTERVAL = 10
#
# MAX_RETRY_HTTP_CONNECTION = 3
#
# TIMEOUT_HTTP_PROTOCOL = 6.05
#
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# class LoginError(AmcrestError):
# """A login error occurred."""
#
# Path: src/amcrest/utils.py
# def clean_url(url: str) -> str:
# host = re.sub(r"^http[s]?://", "", url, flags=re.IGNORECASE)
# host = re.sub(r"/$", "", host)
# return host
#
# def pretty(value: str, delimiter: str = "=") -> str:
# """Format string key=value."""
# return value.strip().rpartition(delimiter)[2]
. Output only the next line. | class SOHTTPAdapter(HTTPAdapter): |
Given the following code snippet before the placeholder: <|code_start|># This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# vim:sw=4:ts=4:et
_LOGGER = logging.getLogger(__name__)
_KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
]
# On some systems TCP_KEEP* are not defined in socket.
try:
_KEEPALIVE_OPTS += [
(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, KEEPALIVE_IDLE),
(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, KEEPALIVE_INTERVAL),
(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, KEEPALIVE_COUNT),
<|code_end|>
, predict the next line using imports from the current file:
import asyncio
import logging
import re
import socket
import threading
import httpx
import requests
from contextlib import asynccontextmanager
from typing import AsyncIterator, Optional, Tuple, Union
from requests.adapters import HTTPAdapter
from urllib3.connection import HTTPConnection
from .config import (
KEEPALIVE_COUNT,
KEEPALIVE_IDLE,
KEEPALIVE_INTERVAL,
MAX_RETRY_HTTP_CONNECTION,
TIMEOUT_HTTP_PROTOCOL,
)
from .exceptions import CommError, LoginError
from .utils import clean_url, pretty
and context including class names, function names, and sometimes code from other files:
# Path: src/amcrest/config.py
# KEEPALIVE_COUNT = 5
#
# KEEPALIVE_IDLE = 20
#
# KEEPALIVE_INTERVAL = 10
#
# MAX_RETRY_HTTP_CONNECTION = 3
#
# TIMEOUT_HTTP_PROTOCOL = 6.05
#
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# class LoginError(AmcrestError):
# """A login error occurred."""
#
# Path: src/amcrest/utils.py
# def clean_url(url: str) -> str:
# host = re.sub(r"^http[s]?://", "", url, flags=re.IGNORECASE)
# host = re.sub(r"/$", "", host)
# return host
#
# def pretty(value: str, delimiter: str = "=") -> str:
# """Format string key=value."""
# return value.strip().rpartition(delimiter)[2]
. Output only the next line. | ] |
Next line prediction: <|code_start|># it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# vim:sw=4:ts=4:et
_LOGGER = logging.getLogger(__name__)
_KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
]
# On some systems TCP_KEEP* are not defined in socket.
try:
_KEEPALIVE_OPTS += [
(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, KEEPALIVE_IDLE),
(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, KEEPALIVE_INTERVAL),
(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, KEEPALIVE_COUNT),
]
except AttributeError:
pass
TimeoutT = Union[Optional[float], Tuple[Optional[float], Optional[float]]]
HttpxTimeoutT = Union[
Optional[float],
<|code_end|>
. Use current file imports:
(import asyncio
import logging
import re
import socket
import threading
import httpx
import requests
from contextlib import asynccontextmanager
from typing import AsyncIterator, Optional, Tuple, Union
from requests.adapters import HTTPAdapter
from urllib3.connection import HTTPConnection
from .config import (
KEEPALIVE_COUNT,
KEEPALIVE_IDLE,
KEEPALIVE_INTERVAL,
MAX_RETRY_HTTP_CONNECTION,
TIMEOUT_HTTP_PROTOCOL,
)
from .exceptions import CommError, LoginError
from .utils import clean_url, pretty)
and context including class names, function names, or small code snippets from other files:
# Path: src/amcrest/config.py
# KEEPALIVE_COUNT = 5
#
# KEEPALIVE_IDLE = 20
#
# KEEPALIVE_INTERVAL = 10
#
# MAX_RETRY_HTTP_CONNECTION = 3
#
# TIMEOUT_HTTP_PROTOCOL = 6.05
#
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# class LoginError(AmcrestError):
# """A login error occurred."""
#
# Path: src/amcrest/utils.py
# def clean_url(url: str) -> str:
# host = re.sub(r"^http[s]?://", "", url, flags=re.IGNORECASE)
# host = re.sub(r"/$", "", host)
# return host
#
# def pretty(value: str, delimiter: str = "=") -> str:
# """Format string key=value."""
# return value.strip().rpartition(delimiter)[2]
. Output only the next line. | Tuple[Optional[float], Optional[float], Optional[float], Optional[float]], |
Using the snippet: <|code_start|># This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# vim:sw=4:ts=4:et
_LOGGER = logging.getLogger(__name__)
_KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
]
# On some systems TCP_KEEP* are not defined in socket.
try:
_KEEPALIVE_OPTS += [
(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, KEEPALIVE_IDLE),
(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, KEEPALIVE_INTERVAL),
(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, KEEPALIVE_COUNT),
<|code_end|>
, determine the next line of code. You have imports:
import asyncio
import logging
import re
import socket
import threading
import httpx
import requests
from contextlib import asynccontextmanager
from typing import AsyncIterator, Optional, Tuple, Union
from requests.adapters import HTTPAdapter
from urllib3.connection import HTTPConnection
from .config import (
KEEPALIVE_COUNT,
KEEPALIVE_IDLE,
KEEPALIVE_INTERVAL,
MAX_RETRY_HTTP_CONNECTION,
TIMEOUT_HTTP_PROTOCOL,
)
from .exceptions import CommError, LoginError
from .utils import clean_url, pretty
and context (class names, function names, or code) available:
# Path: src/amcrest/config.py
# KEEPALIVE_COUNT = 5
#
# KEEPALIVE_IDLE = 20
#
# KEEPALIVE_INTERVAL = 10
#
# MAX_RETRY_HTTP_CONNECTION = 3
#
# TIMEOUT_HTTP_PROTOCOL = 6.05
#
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# class LoginError(AmcrestError):
# """A login error occurred."""
#
# Path: src/amcrest/utils.py
# def clean_url(url: str) -> str:
# host = re.sub(r"^http[s]?://", "", url, flags=re.IGNORECASE)
# host = re.sub(r"/$", "", host)
# return host
#
# def pretty(value: str, delimiter: str = "=") -> str:
# """Format string key=value."""
# return value.strip().rpartition(delimiter)[2]
. Output only the next line. | ] |
Next line prediction: <|code_start|># This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# vim:sw=4:ts=4:et
_LOGGER = logging.getLogger(__name__)
_KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
<|code_end|>
. Use current file imports:
(import asyncio
import logging
import re
import socket
import threading
import httpx
import requests
from contextlib import asynccontextmanager
from typing import AsyncIterator, Optional, Tuple, Union
from requests.adapters import HTTPAdapter
from urllib3.connection import HTTPConnection
from .config import (
KEEPALIVE_COUNT,
KEEPALIVE_IDLE,
KEEPALIVE_INTERVAL,
MAX_RETRY_HTTP_CONNECTION,
TIMEOUT_HTTP_PROTOCOL,
)
from .exceptions import CommError, LoginError
from .utils import clean_url, pretty)
and context including class names, function names, or small code snippets from other files:
# Path: src/amcrest/config.py
# KEEPALIVE_COUNT = 5
#
# KEEPALIVE_IDLE = 20
#
# KEEPALIVE_INTERVAL = 10
#
# MAX_RETRY_HTTP_CONNECTION = 3
#
# TIMEOUT_HTTP_PROTOCOL = 6.05
#
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# class LoginError(AmcrestError):
# """A login error occurred."""
#
# Path: src/amcrest/utils.py
# def clean_url(url: str) -> str:
# host = re.sub(r"^http[s]?://", "", url, flags=re.IGNORECASE)
# host = re.sub(r"/$", "", host)
# return host
#
# def pretty(value: str, delimiter: str = "=") -> str:
# """Format string key=value."""
# return value.strip().rpartition(delimiter)[2]
. Output only the next line. | ] |
Given snippet: <|code_start|># This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# vim:sw=4:ts=4:et
_LOGGER = logging.getLogger(__name__)
_KEEPALIVE_OPTS = HTTPConnection.default_socket_options + [
(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
]
# On some systems TCP_KEEP* are not defined in socket.
try:
_KEEPALIVE_OPTS += [
(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, KEEPALIVE_IDLE),
(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, KEEPALIVE_INTERVAL),
(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, KEEPALIVE_COUNT),
]
except AttributeError:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import asyncio
import logging
import re
import socket
import threading
import httpx
import requests
from contextlib import asynccontextmanager
from typing import AsyncIterator, Optional, Tuple, Union
from requests.adapters import HTTPAdapter
from urllib3.connection import HTTPConnection
from .config import (
KEEPALIVE_COUNT,
KEEPALIVE_IDLE,
KEEPALIVE_INTERVAL,
MAX_RETRY_HTTP_CONNECTION,
TIMEOUT_HTTP_PROTOCOL,
)
from .exceptions import CommError, LoginError
from .utils import clean_url, pretty
and context:
# Path: src/amcrest/config.py
# KEEPALIVE_COUNT = 5
#
# KEEPALIVE_IDLE = 20
#
# KEEPALIVE_INTERVAL = 10
#
# MAX_RETRY_HTTP_CONNECTION = 3
#
# TIMEOUT_HTTP_PROTOCOL = 6.05
#
# Path: src/amcrest/exceptions.py
# class CommError(AmcrestError):
# """A communication error occurred."""
#
# class LoginError(AmcrestError):
# """A login error occurred."""
#
# Path: src/amcrest/utils.py
# def clean_url(url: str) -> str:
# host = re.sub(r"^http[s]?://", "", url, flags=re.IGNORECASE)
# host = re.sub(r"/$", "", host)
# return host
#
# def pretty(value: str, delimiter: str = "=") -> str:
# """Format string key=value."""
# return value.strip().rpartition(delimiter)[2]
which might include code, classes, or functions. Output only the next line. | pass |
Given the code snippet: <|code_start|>
# -- Options for HTMLHelp output ------------------------------------------
# Output file base name for HTML help builder.
htmlhelp_basename = "MySQLAutoXtrabackupdoc"
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(
<|code_end|>
, generate the next line using the imports in this file:
import os
import sys
import sphinx_rtd_theme
from mysql_autoxtrabackup.utils.version import VERSION
and context (functions, classes, or occasionally code) from other files:
# Path: mysql_autoxtrabackup/utils/version.py
# VERSION = "2.0.2"
. Output only the next line. | master_doc, |
Using the snippet: <|code_start|>
class TestHelpers:
def test_get_latest_dir_name(self):
os.makedirs("tests/DELETE_ME", mode=777, exist_ok=True)
os.makedirs("tests/DELETE_ME/2021-05-06_11-48-31", mode=777, exist_ok=True)
os.makedirs("tests/DELETE_ME/2021-05-06_11-47-31", mode=777, exist_ok=True)
assert (
helpers.get_latest_dir_name(path=f"{os.path.dirname(__file__)}/DELETE_ME")
<|code_end|>
, determine the next line of code. You have imports:
import os
import shutil
from mysql_autoxtrabackup.utils import helpers
and context (class names, function names, or code) available:
# Path: mysql_autoxtrabackup/utils/helpers.py
# def get_folder_size(path: str) -> Union[str, None]:
# def sorted_ls(path: Optional[str]) -> List[str]:
# def get_directory_size(path: str) -> int:
# def create_backup_directory(directory: str, forced_dir: Optional[str] = None) -> str:
# def get_latest_dir_name(path: Optional[str]) -> Optional[str]:
# def create_directory(path: str) -> Optional[bool]:
# def check_if_backup_prepared(type_: str, path: str) -> str:
# def list_available_backups(path: str) -> Dict[str, List[Dict[str, str]]]:
. Output only the next line. | == "2021-05-06_11-48-31" |
Predict the next line for this snippet: <|code_start|> def check_matrix_combinations(self, node, distro, parsed_selectors):
def process_combinations(data, distro, parsed_selectors):
for k, v in data.items():
if k == DISTROINFO_GRP_DISTROS and distro not in v:
return False
elif (k != DISTROINFO_GRP_DISTROS and k in parsed_selectors
and parsed_selectors[k] != v):
return False
return data.get('data', True)
for data in self._matrix.get(node, []):
yield process_combinations(data, distro, parsed_selectors)
def verify_selectors(self, selectors, distro):
parsed_selectors = self.parse_selectors(selectors)
if DISTROINFO_GRP in parsed_selectors.keys():
return (
False,
('"{0}" not allowed in selectors, it is chosen '
'automatically based on distro'.format(DISTROINFO_GRP)))
# first, verify that these selector values even exist in specs
for selector_name, selector_val in parsed_selectors.items():
if not self.has_spec_group(selector_name):
return (
False,
'"{0}" not an entry in specs'.format(selector_name)
)
<|code_end|>
with the help of current file imports:
import copy
import itertools
import os
import yaml
from distgen.config import merge_yaml
from distgen.pathmanager import PathManager
and context from other files:
# Path: distgen/config.py
# def merge_yaml(origin, override):
# old = copy.deepcopy(origin)
# new = copy.deepcopy(override)
# return _merge_yaml(old, new)
#
# Path: distgen/pathmanager.py
# class PathManager(object):
# envvar = None
#
# def __init__(self, path, envvar=None, file_suffix=None):
# self.path = path
# self.envvar = envvar
# self.suffix = file_suffix
#
# def get_file(self, filename, prefered_path=None, fail=False,
# file_desc="file"):
#
# if filename.startswith('/'):
# if os.path.isfile(filename):
# return filename
# else:
# return None
#
# path = self.get_path()
# if prefered_path:
# path = prefered_path + path
#
# for i in path:
# config_files = [os.path.join(i, filename)]
# if self.suffix:
# config_files.append(config_files[0] + self.suffix)
# for cf in config_files:
# if os.path.isfile(cf):
# return cf
#
# if fail:
# fatal("can't find {0} '{1}'".format(file_desc, filename))
#
# return None
#
# def open_file(self, relative, prefered_path=None,
# fail=False, file_desc="file"):
#
# filename = self.get_file(relative, prefered_path, fail=fail,
# file_desc=file_desc)
# if not filename:
# return None
#
# try:
# fd = open(filename)
# except IOError:
# if fail:
# fatal("can't open file {0}".format(relative))
# return None
#
# return fd
#
# def get_path(self):
# path = self.path
# if self.envvar and self.envvar in os.environ:
# env_path = os.environ[self.envvar].split(':')
# path = env_path + path
#
# return [os.getcwd()] + path
, which may contain function names, class names, or code. Output only the next line. | elif not self.has_spec_group_item(selector_name, selector_val): |
Here is a snippet: <|code_start|> self._validate_specs(self.raw_data.get('specs', None))
self._validate_matrix(self.raw_data.get('matrix', {}))
def _validate_version(self, version):
try:
v = int(version)
except TypeError:
self._validation_err(
'version must be int or string convertable '
'to string, is "{0}"'.format(version))
if v != 1:
self._validation_err(
'only version "1" is recognized by this distgen version')
def _validate_specs(self, specs):
if not isinstance(specs, dict):
self._validation_err(
'"specs" must be a mapping, is "{0}"'.format(type(specs)))
for k, v in specs.items():
self._validate_spec_group(k, v)
if 'distroinfo' not in specs:
self._validation_err('"distroinfo" must be in "specs"')
def _validate_spec_group(self, name, spec_group):
if not isinstance(spec_group, dict):
self._validation_err(
'a spec group "{0}" must be a mapping, is "{1}"'.
format(name, type(spec_group)))
<|code_end|>
. Write the next line using the current file imports:
import copy
import itertools
import os
import yaml
from distgen.config import merge_yaml
from distgen.pathmanager import PathManager
and context from other files:
# Path: distgen/config.py
# def merge_yaml(origin, override):
# old = copy.deepcopy(origin)
# new = copy.deepcopy(override)
# return _merge_yaml(old, new)
#
# Path: distgen/pathmanager.py
# class PathManager(object):
# envvar = None
#
# def __init__(self, path, envvar=None, file_suffix=None):
# self.path = path
# self.envvar = envvar
# self.suffix = file_suffix
#
# def get_file(self, filename, prefered_path=None, fail=False,
# file_desc="file"):
#
# if filename.startswith('/'):
# if os.path.isfile(filename):
# return filename
# else:
# return None
#
# path = self.get_path()
# if prefered_path:
# path = prefered_path + path
#
# for i in path:
# config_files = [os.path.join(i, filename)]
# if self.suffix:
# config_files.append(config_files[0] + self.suffix)
# for cf in config_files:
# if os.path.isfile(cf):
# return cf
#
# if fail:
# fatal("can't find {0} '{1}'".format(file_desc, filename))
#
# return None
#
# def open_file(self, relative, prefered_path=None,
# fail=False, file_desc="file"):
#
# filename = self.get_file(relative, prefered_path, fail=fail,
# file_desc=file_desc)
# if not filename:
# return None
#
# try:
# fd = open(filename)
# except IOError:
# if fail:
# fatal("can't open file {0}".format(relative))
# return None
#
# return fd
#
# def get_path(self):
# path = self.path
# if self.envvar and self.envvar in os.environ:
# env_path = os.environ[self.envvar].split(':')
# path = env_path + path
#
# return [os.getcwd()] + path
, which may include functions, classes, or code. Output only the next line. | for k, v in spec_group.items(): |
Using the snippet: <|code_start|> ('yumi', 'update', 'yum update foo bar'),
('yumni', 'update', 'yum -y update foo bar'),
('dnfi', 'install', 'dnf install foo bar'),
('dnfni', 'install', 'dnf -y install foo bar'),
('dnfi', 'reinstall', 'dnf reinstall foo bar'),
('dnfni', 'reinstall', 'dnf -y reinstall foo bar'),
('dnfi', 'remove', 'dnf remove foo bar'),
('dnfni', 'remove', 'dnf -y remove foo bar'),
('dnfi', 'update', 'dnf update foo bar'),
('dnfni', 'update', 'dnf -y update foo bar'),
])
def test_pkg_methods(self, m, action, result):
assert getattr(self.mgrs[m], action)(['foo', 'bar']) == result
@pytest.mark.parametrize('m, result', [
('yumi', 'yum update'),
('yumni', 'yum -y update'),
('dnfi', 'dnf update'),
('dnfni', 'dnf -y update'),
])
def test_update_all(self, m, result):
assert self.mgrs[m].update_all() == result
@pytest.mark.parametrize('m, result', [
('yumi', 'yum clean all --enablerepo=\'*\''),
('yumni', 'yum -y clean all --enablerepo=\'*\''),
('dnfi', 'dnf clean all --enablerepo=\'*\''),
('dnfni', 'dnf -y clean all --enablerepo=\'*\''),
])
def test_cleancache(self, m, result):
<|code_end|>
, determine the next line of code. You have imports:
import pytest
from distgen.commands import DnfPkgManager, YumPkgManager
and context (class names, function names, or code) available:
# Path: distgen/commands.py
# class DnfPkgManager(YumPkgManager):
# binary = "dnf"
#
# class YumPkgManager(AbstractPkgManger):
# binary = "yum"
#
# def _base_command(self, opts):
# base = self.binary + " -y"
# if self.is_interactive(opts):
# base = self.binary
#
# docs = True
# if self.in_container(opts):
# docs = False
#
# if opts and 'docs' in opts:
# docs = opts['docs']
#
# docs_string = ""
# if not docs:
# docs_string = " --setopt=tsflags=nodocs"
#
# return base + docs_string
#
# def action(self, action, pkgs, options):
# return "{0} {1} {2}".format(
# self._base_command(options),
# action,
# " ".join(pkgs),
# ).strip()
#
# def install(self, pkgs, options=None):
# return self.action("install", pkgs, options)
#
# def reinstall(self, pkgs, options=None):
# return self.action("reinstall", pkgs, options)
#
# def remove(self, pkgs, options=None):
# return self.action("remove", pkgs, options)
#
# def update(self, pkgs, options=None):
# return self.action("update", pkgs, options)
#
# def update_all(self, options=None):
# return self.action("update", [], options)
#
# def cleancache(self, options=None):
# return self._base_command(options) + " clean all --enablerepo='*'"
. Output only the next line. | assert self.mgrs[m].cleancache() == result |
Given the code snippet: <|code_start|>
class TestIndividualPkgManagers(object):
def setup_method(self, method):
class Config(object):
def __init__(self, interactive, container=None):
self.interactive = interactive
self.container = container
self.mgrs = {'yumi': YumPkgManager(Config(True)),
'yumni': YumPkgManager(Config(False)),
'dnfi': DnfPkgManager(Config(True)),
'dnfni': DnfPkgManager(Config(False)),
}
@pytest.mark.parametrize('m, action, result', [
('yumi', 'install', 'yum install foo bar'),
('yumni', 'install', 'yum -y install foo bar'),
('yumi', 'reinstall', 'yum reinstall foo bar'),
('yumni', 'reinstall', 'yum -y reinstall foo bar'),
('yumi', 'remove', 'yum remove foo bar'),
('yumni', 'remove', 'yum -y remove foo bar'),
('yumi', 'update', 'yum update foo bar'),
('yumni', 'update', 'yum -y update foo bar'),
('dnfi', 'install', 'dnf install foo bar'),
('dnfni', 'install', 'dnf -y install foo bar'),
('dnfi', 'reinstall', 'dnf reinstall foo bar'),
('dnfni', 'reinstall', 'dnf -y reinstall foo bar'),
('dnfi', 'remove', 'dnf remove foo bar'),
('dnfni', 'remove', 'dnf -y remove foo bar'),
<|code_end|>
, generate the next line using the imports in this file:
import pytest
from distgen.commands import DnfPkgManager, YumPkgManager
and context (functions, classes, or occasionally code) from other files:
# Path: distgen/commands.py
# class DnfPkgManager(YumPkgManager):
# binary = "dnf"
#
# class YumPkgManager(AbstractPkgManger):
# binary = "yum"
#
# def _base_command(self, opts):
# base = self.binary + " -y"
# if self.is_interactive(opts):
# base = self.binary
#
# docs = True
# if self.in_container(opts):
# docs = False
#
# if opts and 'docs' in opts:
# docs = opts['docs']
#
# docs_string = ""
# if not docs:
# docs_string = " --setopt=tsflags=nodocs"
#
# return base + docs_string
#
# def action(self, action, pkgs, options):
# return "{0} {1} {2}".format(
# self._base_command(options),
# action,
# " ".join(pkgs),
# ).strip()
#
# def install(self, pkgs, options=None):
# return self.action("install", pkgs, options)
#
# def reinstall(self, pkgs, options=None):
# return self.action("reinstall", pkgs, options)
#
# def remove(self, pkgs, options=None):
# return self.action("remove", pkgs, options)
#
# def update(self, pkgs, options=None):
# return self.action("update", pkgs, options)
#
# def update_all(self, options=None):
# return self.action("update", [], options)
#
# def cleancache(self, options=None):
# return self._base_command(options) + " clean all --enablerepo='*'"
. Output only the next line. | ('dnfi', 'update', 'dnf update foo bar'), |
Continue the code snippet: <|code_start|>
# Output file base name for HTML help builder.
htmlhelp_basename = 'distgendoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'distgen.tex', u'distgen Documentation',
<|code_end|>
. Use current file imports:
import os
import sys
from distgen.version import dg_version
and context (classes, functions, or code) from other files:
# Path: distgen/version.py
. Output only the next line. | u'Pavel Raiskup, Slavek Kabrda', 'manual'), |
Predict the next line for this snippet: <|code_start|>
class Project(AbstractProject):
def inst_init(self, specfiles, template, sysconfig):
self.somestuff = 'interesting'
<|code_end|>
with the help of current file imports:
from distgen.project import AbstractProject
and context from other files:
# Path: distgen/project.py
# class AbstractProject():
# tplgen = None
#
# name = "unknown-project"
#
# maintainer = "unknown <unknown@unknown.com>"
#
# def inst_init(self, specfiles, template, sysconfig):
# """
# Executed before the project.py/spec files/template is loaded and
# before all the dynamic stuff and specification is calculated.
# Now is still time to dynamically change the list of specfiles or
# adjust the system configuration. You can define a variable as an
# attribute of this project:
#
# self.variable = "42"
#
# which can be later utilized in a template like this:
#
# {{ project.variable }}
# """
# pass
#
# def inst_finish(self, specfiles, template, sysconfig, spec):
# """
# Executed after the project.py/spec files/template is loaded, and
# the specification (spec) calculated (== instantiated). This is
# the last chance to dynamically change sysconfig or spec.
# """
# pass
#
# def __init__(self):
# """ Never overwrite constructor please! """
# pass
#
# def abstract_initialize(self):
# """
# Never overwrite this function, please. Its currently just a
# placeholder called right after Project was instantiated and the
# right paths to templates/specs was set.
# """
# pass
#
# def abstract_setup_vars(self, config):
# """
# Never overwrite this function, please.
# """
# # Be careful here with changes. Any change will survive to the next
# # call of render() method (its effect won't disappear for next
# # template).
# pass
, which may contain function names, class names, or code. Output only the next line. | def inst_finish(self, specfiles, template, sysconfig, spec): |
Predict the next line after this snippet: <|code_start|>
project = "distgen"
datadir = "share"
pkgdatadir = datadir + "/" + project
tpldir = pkgdatadir + "/templates"
distconfdir = pkgdatadir + "/distconf"
try:
sys.path = [path.join(getcwd(), 'build_manpages')] + sys.path
except:
print("=======================================")
print("Use 'git submodule update --init' first")
print("=======================================")
<|code_end|>
using the current file's imports:
import sys
from setuptools import setup
from distgen.version import dg_version
from os import listdir, path, getcwd
from setuptools.command.build_py import build_py
from setuptools.command.install import install
from build_manpages.build_manpages import (
build_manpages, get_build_py_cmd, get_install_cmd)
and any relevant context from other files:
# Path: distgen/version.py
. Output only the next line. | raise |
Next line prediction: <|code_start|>
class TestMergeYaml(object):
def test_non_overlapping(self):
a = {'a': 1, 'aa': 2}
<|code_end|>
. Use current file imports:
(import os
from distgen.config import merge_yaml, load_config)
and context including class names, function names, or small code snippets from other files:
# Path: distgen/config.py
# def merge_yaml(origin, override):
# old = copy.deepcopy(origin)
# new = copy.deepcopy(override)
# return _merge_yaml(old, new)
#
# def load_config(path, config_file, context=None):
# pm = PathManager(path, file_suffix='.yaml')
# yaml_data = __recursive_load(pm, [], config_file)
# return yaml_data
. Output only the next line. | b = {'b': 3, 'bb': 4} |
Predict the next line for this snippet: <|code_start|> else:
return None
path = self.get_path()
if prefered_path:
path = prefered_path + path
for i in path:
config_files = [os.path.join(i, filename)]
if self.suffix:
config_files.append(config_files[0] + self.suffix)
for cf in config_files:
if os.path.isfile(cf):
return cf
if fail:
fatal("can't find {0} '{1}'".format(file_desc, filename))
return None
def open_file(self, relative, prefered_path=None,
fail=False, file_desc="file"):
filename = self.get_file(relative, prefered_path, fail=fail,
file_desc=file_desc)
if not filename:
return None
try:
fd = open(filename)
<|code_end|>
with the help of current file imports:
import os
from distgen.err import fatal
and context from other files:
# Path: distgen/err.py
# def fatal(msg):
# logging.fatal(msg)
# sys.exit(1)
, which may contain function names, class names, or code. Output only the next line. | except IOError: |
Using the snippet: <|code_start|>
try:
except ImportError:
class TestDistroDetection(object):
@pytest.mark.parametrize('arch', [b'x86_64', b'i386'])
@pytest.mark.parametrize('distro, version, name, cversion', [
('fedora', 24, 'sth', 24),
('fedora', 25, 'sth', 25),
('fedora', 21, 'rawhide', 'rawhide'),
('rhel', 7, 'sth', 7),
])
@patch('subprocess.check_output')
@patch('distro.linux_distribution')
def test_rpm(self, pdist, sp_co, distro, version, name, cversion, arch):
sp_co.return_value = arch
pdist.return_value = (distro, version, name)
assert detect_default_distro() == '{0}-{1}-{2}.yaml'.format(
<|code_end|>
, determine the next line of code. You have imports:
import pytest
from unittest.mock import patch
from mock import patch
from distgen.distro_version import detect_default_distro
and context (class names, function names, or code) available:
# Path: distgen/distro_version.py
# def detect_default_distro():
# """
# Based on the current information from python-distro module, return the
# expected default distgen config. Return None if distro can not be detected.
# """
#
# distro, version, name = distro_module.linux_distribution(full_distribution_name=True)
#
# if distro == 'Fedora Linux':
# distro = 'Fedora'
#
# distro = distro.lower()
#
# if distro == 'fedora':
# if name.lower() == 'rawhide':
# version = 'rawhide'
# elif distro in ['centos', 'rhel']:
# pass
# else:
# return None
#
# # Only RPM distros for now:
# cmd = ['rpm', '--eval', '%_arch']
# arch = subprocess.check_output(cmd).decode('ascii').strip()
#
# return '{0}-{1}-{2}.yaml'.format(distro, version, arch)
. Output only the next line. | distro, cversion, arch.decode('ascii') |
Using the snippet: <|code_start|>
class ProfileRetriever:
def __init__(self, settings, fileDownloader, profileCache, diskIo, githubZipballExtractor):
self.settings = settings
self.fileDownloader = fileDownloader
self.profileCache = profileCache
self.diskIo = diskIo
self.githubZipballExtractor = githubZipballExtractor
<|code_end|>
, determine the next line of code. You have imports:
from .DiskIo import getDiskIo
from .FileDownloader import getFileDownloader
from .GithubZipballExtractor import getGithubZipballExtractor
from .ProfileCache import getProfileCache
from .ProfileUrlResolver import getProfileUrl
from .Settings import getSettings
import os
and context (class names, function names, or code) available:
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
#
# Path: vimswitch/FileDownloader.py
# def getFileDownloader(app):
# return app.get('fileDownloader', createFileDownloader(app))
#
# Path: vimswitch/GithubZipballExtractor.py
# def getGithubZipballExtractor(app):
# return app.get('githubZipballExtractor', createGithubZipballExtractor(app))
#
# Path: vimswitch/ProfileCache.py
# def getProfileCache(app):
# return app.get('profileCache', createProfileCache(app))
#
# Path: vimswitch/ProfileUrlResolver.py
# def getProfileUrl(profile):
# prefix = 'https://github.com/'
# suffix = '/archive/master.zip'
# url = prefix + profile.getName() + suffix
# return url
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
. Output only the next line. | def retrieve(self, profile): |
Here is a snippet: <|code_start|>
class ProfileRetriever:
def __init__(self, settings, fileDownloader, profileCache, diskIo, githubZipballExtractor):
self.settings = settings
self.fileDownloader = fileDownloader
self.profileCache = profileCache
self.diskIo = diskIo
<|code_end|>
. Write the next line using the current file imports:
from .DiskIo import getDiskIo
from .FileDownloader import getFileDownloader
from .GithubZipballExtractor import getGithubZipballExtractor
from .ProfileCache import getProfileCache
from .ProfileUrlResolver import getProfileUrl
from .Settings import getSettings
import os
and context from other files:
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
#
# Path: vimswitch/FileDownloader.py
# def getFileDownloader(app):
# return app.get('fileDownloader', createFileDownloader(app))
#
# Path: vimswitch/GithubZipballExtractor.py
# def getGithubZipballExtractor(app):
# return app.get('githubZipballExtractor', createGithubZipballExtractor(app))
#
# Path: vimswitch/ProfileCache.py
# def getProfileCache(app):
# return app.get('profileCache', createProfileCache(app))
#
# Path: vimswitch/ProfileUrlResolver.py
# def getProfileUrl(profile):
# prefix = 'https://github.com/'
# suffix = '/archive/master.zip'
# url = prefix + profile.getName() + suffix
# return url
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
, which may include functions, classes, or code. Output only the next line. | self.githubZipballExtractor = githubZipballExtractor |
Predict the next line for this snippet: <|code_start|>
class ProfileRetriever:
def __init__(self, settings, fileDownloader, profileCache, diskIo, githubZipballExtractor):
self.settings = settings
<|code_end|>
with the help of current file imports:
from .DiskIo import getDiskIo
from .FileDownloader import getFileDownloader
from .GithubZipballExtractor import getGithubZipballExtractor
from .ProfileCache import getProfileCache
from .ProfileUrlResolver import getProfileUrl
from .Settings import getSettings
import os
and context from other files:
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
#
# Path: vimswitch/FileDownloader.py
# def getFileDownloader(app):
# return app.get('fileDownloader', createFileDownloader(app))
#
# Path: vimswitch/GithubZipballExtractor.py
# def getGithubZipballExtractor(app):
# return app.get('githubZipballExtractor', createGithubZipballExtractor(app))
#
# Path: vimswitch/ProfileCache.py
# def getProfileCache(app):
# return app.get('profileCache', createProfileCache(app))
#
# Path: vimswitch/ProfileUrlResolver.py
# def getProfileUrl(profile):
# prefix = 'https://github.com/'
# suffix = '/archive/master.zip'
# url = prefix + profile.getName() + suffix
# return url
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
, which may contain function names, class names, or code. Output only the next line. | self.fileDownloader = fileDownloader |
Given the code snippet: <|code_start|>
class ProfileRetriever:
def __init__(self, settings, fileDownloader, profileCache, diskIo, githubZipballExtractor):
self.settings = settings
self.fileDownloader = fileDownloader
self.profileCache = profileCache
self.diskIo = diskIo
<|code_end|>
, generate the next line using the imports in this file:
from .DiskIo import getDiskIo
from .FileDownloader import getFileDownloader
from .GithubZipballExtractor import getGithubZipballExtractor
from .ProfileCache import getProfileCache
from .ProfileUrlResolver import getProfileUrl
from .Settings import getSettings
import os
and context (functions, classes, or occasionally code) from other files:
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
#
# Path: vimswitch/FileDownloader.py
# def getFileDownloader(app):
# return app.get('fileDownloader', createFileDownloader(app))
#
# Path: vimswitch/GithubZipballExtractor.py
# def getGithubZipballExtractor(app):
# return app.get('githubZipballExtractor', createGithubZipballExtractor(app))
#
# Path: vimswitch/ProfileCache.py
# def getProfileCache(app):
# return app.get('profileCache', createProfileCache(app))
#
# Path: vimswitch/ProfileUrlResolver.py
# def getProfileUrl(profile):
# prefix = 'https://github.com/'
# suffix = '/archive/master.zip'
# url = prefix + profile.getName() + suffix
# return url
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
. Output only the next line. | self.githubZipballExtractor = githubZipballExtractor |
Next line prediction: <|code_start|>
class TestApplicationDirs(FileSystemTestCase):
def setUp(self):
FileSystemTestCase.setUp(self)
app = Application()
app.settings = Settings(self.getWorkingDir())
self.settings = app.settings
self.diskIo = getDiskIo(app)
self.applicationDirs = getApplicationDirs(app)
def test_createIfNone_noApplicationDirs_createsApplicationDirs(self):
self.applicationDirs.createIfNone()
<|code_end|>
. Use current file imports:
(from .FileSystemTestCase import FileSystemTestCase
from vimswitch.Settings import Settings
from vimswitch.DiskIo import getDiskIo
from vimswitch.ApplicationDirs import getApplicationDirs
from vimswitch.Application import Application)
and context including class names, function names, or small code snippets from other files:
# Path: vimswitch/test/FileSystemTestCase.py
# class FileSystemTestCase(BaseTestCase):
# """
# Inherit from this class when a unit test needs to access the disk. This
# class sets up a sandbox so that disk modifications only occur within a
# working directory. This keeps test code from affecting other files on the
# system.
#
# To get a path relative to the working directory use getTestPath(). To get a
# path to test data use getDataPath().
#
# The working directory is cleared after every test so there is no need to do
# it manually within your tests.
# """
#
# def setUp(self):
# self.sandbox = FileSystemSandbox()
# self.sandbox.enable(self.getWorkingDir())
# self.clearWorkingDirectory()
#
# def tearDown(self):
# self.clearWorkingDirectory()
# self.sandbox.disable()
#
# @classmethod
# def getMyDir(self):
# return os.path.dirname(__file__)
#
# @classmethod
# def getTestPath(self, path):
# "Returns path prepended by the working directory"
# fullPath = os.path.join(self.getWorkingDir(), path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getDataPath(self, path):
# "Returns path prepended by the test data directory"
# dataDir = 'data'
# fullPath = os.path.join(self.getMyDir(), dataDir, path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getWorkingDir(self):
# """"Returns the path to a directory where we can safely create files and
# directories during tests"""
# dirName = 'workingDir'
# return os.path.join(self.getMyDir(), dirName)
#
# def copyDataToWorkingDir(self, dataSrc, workingDirDest):
# "Copies a file or dir from the data directory to the working directory"
# dataSrc = self.getDataPath(dataSrc)
# workingDirDest = self.getTestPath(workingDirDest)
# if os.path.isdir(dataSrc):
# shutil.copytree(dataSrc, workingDirDest)
# else:
# shutil.copy(dataSrc, workingDirDest)
#
# def clearWorkingDirectory(self):
# for entry in os.listdir(self.getWorkingDir()):
# fullPath = os.path.join(self.getWorkingDir(), entry)
# if os.path.isfile(fullPath):
# # If file is readonly, make it writable
# if not os.access(fullPath, os.W_OK):
# os.chmod(fullPath, stat.S_IWRITE)
# os.remove(fullPath)
# elif os.path.isdir(fullPath):
# shutil.rmtree(fullPath, onerror=_remove_readonly)
#
# Path: vimswitch/Settings.py
# class Settings:
#
# def __init__(self, homePath=''):
# """
# homePath is used as the prefix for all other paths. If homePath is not
# specified it gets set to the user's home directory.
# """
# self.homePath = homePath or os.path.expanduser('~')
# self.configPath = os.path.join(self.homePath, '.vimswitch')
# self.configFilePath = os.path.join(self.configPath, 'vimswitchrc')
# self.cachePath = os.path.join(self.configPath, 'profiles')
# self.downloadsPath = os.path.join(self.configPath, 'downloads')
# self.profileFiles = ['.vimrc', '_vimrc']
# self.profileDirs = ['.vim', '_vim']
# self.defaultProfile = Profile('default')
# self.currentProfile = None
#
# def __eq__(self, other):
# return self.__dict__ == other.__dict__
#
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
#
# Path: vimswitch/ApplicationDirs.py
# def getApplicationDirs(app):
# return app.get('applicationDirs', createApplicationDirs(app))
#
# Path: vimswitch/Application.py
# class Application:
# """
# A container for components that are used application-wide.
#
# Examples of how this class can be used:
#
# - Set a component
# `app.foo = myFoo`
#
# - Get (or create) a component:
# `foo = app.get('foo', Foo())`
# This will try to return `app.foo`. If that does not exist, then it will
# set `app.foo = Foo()` and return that instead.
#
# - Get an already created component
# `foo = app.foo`
# Use this when you are sure that app.foo has already been set
# """
#
# def get(self, attr, default):
# """
# Returns self.attr. If attr does not exist, then make self.attr = default
# and then return default.
# """
# if hasattr(self, attr):
# return getattr(self, attr)
# else:
# setattr(self, attr, default)
# return default
. Output only the next line. | dirExists = self.diskIo.dirExists |
Using the snippet: <|code_start|>
class TestApplicationDirs(FileSystemTestCase):
def setUp(self):
FileSystemTestCase.setUp(self)
app = Application()
app.settings = Settings(self.getWorkingDir())
self.settings = app.settings
self.diskIo = getDiskIo(app)
self.applicationDirs = getApplicationDirs(app)
def test_createIfNone_noApplicationDirs_createsApplicationDirs(self):
self.applicationDirs.createIfNone()
dirExists = self.diskIo.dirExists
self.assertTrue(dirExists(self.settings.configPath))
self.assertTrue(dirExists(self.settings.cachePath))
self.assertTrue(dirExists(self.settings.downloadsPath))
<|code_end|>
, determine the next line of code. You have imports:
from .FileSystemTestCase import FileSystemTestCase
from vimswitch.Settings import Settings
from vimswitch.DiskIo import getDiskIo
from vimswitch.ApplicationDirs import getApplicationDirs
from vimswitch.Application import Application
and context (class names, function names, or code) available:
# Path: vimswitch/test/FileSystemTestCase.py
# class FileSystemTestCase(BaseTestCase):
# """
# Inherit from this class when a unit test needs to access the disk. This
# class sets up a sandbox so that disk modifications only occur within a
# working directory. This keeps test code from affecting other files on the
# system.
#
# To get a path relative to the working directory use getTestPath(). To get a
# path to test data use getDataPath().
#
# The working directory is cleared after every test so there is no need to do
# it manually within your tests.
# """
#
# def setUp(self):
# self.sandbox = FileSystemSandbox()
# self.sandbox.enable(self.getWorkingDir())
# self.clearWorkingDirectory()
#
# def tearDown(self):
# self.clearWorkingDirectory()
# self.sandbox.disable()
#
# @classmethod
# def getMyDir(self):
# return os.path.dirname(__file__)
#
# @classmethod
# def getTestPath(self, path):
# "Returns path prepended by the working directory"
# fullPath = os.path.join(self.getWorkingDir(), path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getDataPath(self, path):
# "Returns path prepended by the test data directory"
# dataDir = 'data'
# fullPath = os.path.join(self.getMyDir(), dataDir, path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getWorkingDir(self):
# """"Returns the path to a directory where we can safely create files and
# directories during tests"""
# dirName = 'workingDir'
# return os.path.join(self.getMyDir(), dirName)
#
# def copyDataToWorkingDir(self, dataSrc, workingDirDest):
# "Copies a file or dir from the data directory to the working directory"
# dataSrc = self.getDataPath(dataSrc)
# workingDirDest = self.getTestPath(workingDirDest)
# if os.path.isdir(dataSrc):
# shutil.copytree(dataSrc, workingDirDest)
# else:
# shutil.copy(dataSrc, workingDirDest)
#
# def clearWorkingDirectory(self):
# for entry in os.listdir(self.getWorkingDir()):
# fullPath = os.path.join(self.getWorkingDir(), entry)
# if os.path.isfile(fullPath):
# # If file is readonly, make it writable
# if not os.access(fullPath, os.W_OK):
# os.chmod(fullPath, stat.S_IWRITE)
# os.remove(fullPath)
# elif os.path.isdir(fullPath):
# shutil.rmtree(fullPath, onerror=_remove_readonly)
#
# Path: vimswitch/Settings.py
# class Settings:
#
# def __init__(self, homePath=''):
# """
# homePath is used as the prefix for all other paths. If homePath is not
# specified it gets set to the user's home directory.
# """
# self.homePath = homePath or os.path.expanduser('~')
# self.configPath = os.path.join(self.homePath, '.vimswitch')
# self.configFilePath = os.path.join(self.configPath, 'vimswitchrc')
# self.cachePath = os.path.join(self.configPath, 'profiles')
# self.downloadsPath = os.path.join(self.configPath, 'downloads')
# self.profileFiles = ['.vimrc', '_vimrc']
# self.profileDirs = ['.vim', '_vim']
# self.defaultProfile = Profile('default')
# self.currentProfile = None
#
# def __eq__(self, other):
# return self.__dict__ == other.__dict__
#
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
#
# Path: vimswitch/ApplicationDirs.py
# def getApplicationDirs(app):
# return app.get('applicationDirs', createApplicationDirs(app))
#
# Path: vimswitch/Application.py
# class Application:
# """
# A container for components that are used application-wide.
#
# Examples of how this class can be used:
#
# - Set a component
# `app.foo = myFoo`
#
# - Get (or create) a component:
# `foo = app.get('foo', Foo())`
# This will try to return `app.foo`. If that does not exist, then it will
# set `app.foo = Foo()` and return that instead.
#
# - Get an already created component
# `foo = app.foo`
# Use this when you are sure that app.foo has already been set
# """
#
# def get(self, attr, default):
# """
# Returns self.attr. If attr does not exist, then make self.attr = default
# and then return default.
# """
# if hasattr(self, attr):
# return getattr(self, attr)
# else:
# setattr(self, attr, default)
# return default
. Output only the next line. | def test_createIfNone_applicationDirsExist_doesNothing(self): |
Based on the snippet: <|code_start|>
class TestApplicationDirs(FileSystemTestCase):
def setUp(self):
FileSystemTestCase.setUp(self)
app = Application()
app.settings = Settings(self.getWorkingDir())
<|code_end|>
, predict the immediate next line with the help of imports:
from .FileSystemTestCase import FileSystemTestCase
from vimswitch.Settings import Settings
from vimswitch.DiskIo import getDiskIo
from vimswitch.ApplicationDirs import getApplicationDirs
from vimswitch.Application import Application
and context (classes, functions, sometimes code) from other files:
# Path: vimswitch/test/FileSystemTestCase.py
# class FileSystemTestCase(BaseTestCase):
# """
# Inherit from this class when a unit test needs to access the disk. This
# class sets up a sandbox so that disk modifications only occur within a
# working directory. This keeps test code from affecting other files on the
# system.
#
# To get a path relative to the working directory use getTestPath(). To get a
# path to test data use getDataPath().
#
# The working directory is cleared after every test so there is no need to do
# it manually within your tests.
# """
#
# def setUp(self):
# self.sandbox = FileSystemSandbox()
# self.sandbox.enable(self.getWorkingDir())
# self.clearWorkingDirectory()
#
# def tearDown(self):
# self.clearWorkingDirectory()
# self.sandbox.disable()
#
# @classmethod
# def getMyDir(self):
# return os.path.dirname(__file__)
#
# @classmethod
# def getTestPath(self, path):
# "Returns path prepended by the working directory"
# fullPath = os.path.join(self.getWorkingDir(), path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getDataPath(self, path):
# "Returns path prepended by the test data directory"
# dataDir = 'data'
# fullPath = os.path.join(self.getMyDir(), dataDir, path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getWorkingDir(self):
# """"Returns the path to a directory where we can safely create files and
# directories during tests"""
# dirName = 'workingDir'
# return os.path.join(self.getMyDir(), dirName)
#
# def copyDataToWorkingDir(self, dataSrc, workingDirDest):
# "Copies a file or dir from the data directory to the working directory"
# dataSrc = self.getDataPath(dataSrc)
# workingDirDest = self.getTestPath(workingDirDest)
# if os.path.isdir(dataSrc):
# shutil.copytree(dataSrc, workingDirDest)
# else:
# shutil.copy(dataSrc, workingDirDest)
#
# def clearWorkingDirectory(self):
# for entry in os.listdir(self.getWorkingDir()):
# fullPath = os.path.join(self.getWorkingDir(), entry)
# if os.path.isfile(fullPath):
# # If file is readonly, make it writable
# if not os.access(fullPath, os.W_OK):
# os.chmod(fullPath, stat.S_IWRITE)
# os.remove(fullPath)
# elif os.path.isdir(fullPath):
# shutil.rmtree(fullPath, onerror=_remove_readonly)
#
# Path: vimswitch/Settings.py
# class Settings:
#
# def __init__(self, homePath=''):
# """
# homePath is used as the prefix for all other paths. If homePath is not
# specified it gets set to the user's home directory.
# """
# self.homePath = homePath or os.path.expanduser('~')
# self.configPath = os.path.join(self.homePath, '.vimswitch')
# self.configFilePath = os.path.join(self.configPath, 'vimswitchrc')
# self.cachePath = os.path.join(self.configPath, 'profiles')
# self.downloadsPath = os.path.join(self.configPath, 'downloads')
# self.profileFiles = ['.vimrc', '_vimrc']
# self.profileDirs = ['.vim', '_vim']
# self.defaultProfile = Profile('default')
# self.currentProfile = None
#
# def __eq__(self, other):
# return self.__dict__ == other.__dict__
#
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
#
# Path: vimswitch/ApplicationDirs.py
# def getApplicationDirs(app):
# return app.get('applicationDirs', createApplicationDirs(app))
#
# Path: vimswitch/Application.py
# class Application:
# """
# A container for components that are used application-wide.
#
# Examples of how this class can be used:
#
# - Set a component
# `app.foo = myFoo`
#
# - Get (or create) a component:
# `foo = app.get('foo', Foo())`
# This will try to return `app.foo`. If that does not exist, then it will
# set `app.foo = Foo()` and return that instead.
#
# - Get an already created component
# `foo = app.foo`
# Use this when you are sure that app.foo has already been set
# """
#
# def get(self, attr, default):
# """
# Returns self.attr. If attr does not exist, then make self.attr = default
# and then return default.
# """
# if hasattr(self, attr):
# return getattr(self, attr)
# else:
# setattr(self, attr, default)
# return default
. Output only the next line. | self.settings = app.settings |
Using the snippet: <|code_start|>
class TestApplicationDirs(FileSystemTestCase):
def setUp(self):
FileSystemTestCase.setUp(self)
app = Application()
app.settings = Settings(self.getWorkingDir())
self.settings = app.settings
self.diskIo = getDiskIo(app)
self.applicationDirs = getApplicationDirs(app)
def test_createIfNone_noApplicationDirs_createsApplicationDirs(self):
<|code_end|>
, determine the next line of code. You have imports:
from .FileSystemTestCase import FileSystemTestCase
from vimswitch.Settings import Settings
from vimswitch.DiskIo import getDiskIo
from vimswitch.ApplicationDirs import getApplicationDirs
from vimswitch.Application import Application
and context (class names, function names, or code) available:
# Path: vimswitch/test/FileSystemTestCase.py
# class FileSystemTestCase(BaseTestCase):
# """
# Inherit from this class when a unit test needs to access the disk. This
# class sets up a sandbox so that disk modifications only occur within a
# working directory. This keeps test code from affecting other files on the
# system.
#
# To get a path relative to the working directory use getTestPath(). To get a
# path to test data use getDataPath().
#
# The working directory is cleared after every test so there is no need to do
# it manually within your tests.
# """
#
# def setUp(self):
# self.sandbox = FileSystemSandbox()
# self.sandbox.enable(self.getWorkingDir())
# self.clearWorkingDirectory()
#
# def tearDown(self):
# self.clearWorkingDirectory()
# self.sandbox.disable()
#
# @classmethod
# def getMyDir(self):
# return os.path.dirname(__file__)
#
# @classmethod
# def getTestPath(self, path):
# "Returns path prepended by the working directory"
# fullPath = os.path.join(self.getWorkingDir(), path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getDataPath(self, path):
# "Returns path prepended by the test data directory"
# dataDir = 'data'
# fullPath = os.path.join(self.getMyDir(), dataDir, path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getWorkingDir(self):
# """"Returns the path to a directory where we can safely create files and
# directories during tests"""
# dirName = 'workingDir'
# return os.path.join(self.getMyDir(), dirName)
#
# def copyDataToWorkingDir(self, dataSrc, workingDirDest):
# "Copies a file or dir from the data directory to the working directory"
# dataSrc = self.getDataPath(dataSrc)
# workingDirDest = self.getTestPath(workingDirDest)
# if os.path.isdir(dataSrc):
# shutil.copytree(dataSrc, workingDirDest)
# else:
# shutil.copy(dataSrc, workingDirDest)
#
# def clearWorkingDirectory(self):
# for entry in os.listdir(self.getWorkingDir()):
# fullPath = os.path.join(self.getWorkingDir(), entry)
# if os.path.isfile(fullPath):
# # If file is readonly, make it writable
# if not os.access(fullPath, os.W_OK):
# os.chmod(fullPath, stat.S_IWRITE)
# os.remove(fullPath)
# elif os.path.isdir(fullPath):
# shutil.rmtree(fullPath, onerror=_remove_readonly)
#
# Path: vimswitch/Settings.py
# class Settings:
#
# def __init__(self, homePath=''):
# """
# homePath is used as the prefix for all other paths. If homePath is not
# specified it gets set to the user's home directory.
# """
# self.homePath = homePath or os.path.expanduser('~')
# self.configPath = os.path.join(self.homePath, '.vimswitch')
# self.configFilePath = os.path.join(self.configPath, 'vimswitchrc')
# self.cachePath = os.path.join(self.configPath, 'profiles')
# self.downloadsPath = os.path.join(self.configPath, 'downloads')
# self.profileFiles = ['.vimrc', '_vimrc']
# self.profileDirs = ['.vim', '_vim']
# self.defaultProfile = Profile('default')
# self.currentProfile = None
#
# def __eq__(self, other):
# return self.__dict__ == other.__dict__
#
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
#
# Path: vimswitch/ApplicationDirs.py
# def getApplicationDirs(app):
# return app.get('applicationDirs', createApplicationDirs(app))
#
# Path: vimswitch/Application.py
# class Application:
# """
# A container for components that are used application-wide.
#
# Examples of how this class can be used:
#
# - Set a component
# `app.foo = myFoo`
#
# - Get (or create) a component:
# `foo = app.get('foo', Foo())`
# This will try to return `app.foo`. If that does not exist, then it will
# set `app.foo = Foo()` and return that instead.
#
# - Get an already created component
# `foo = app.foo`
# Use this when you are sure that app.foo has already been set
# """
#
# def get(self, attr, default):
# """
# Returns self.attr. If attr does not exist, then make self.attr = default
# and then return default.
# """
# if hasattr(self, attr):
# return getattr(self, attr)
# else:
# setattr(self, attr, default)
# return default
. Output only the next line. | self.applicationDirs.createIfNone() |
Given the code snippet: <|code_start|>
class TestApplicationDirs(FileSystemTestCase):
def setUp(self):
FileSystemTestCase.setUp(self)
app = Application()
app.settings = Settings(self.getWorkingDir())
self.settings = app.settings
self.diskIo = getDiskIo(app)
self.applicationDirs = getApplicationDirs(app)
def test_createIfNone_noApplicationDirs_createsApplicationDirs(self):
self.applicationDirs.createIfNone()
dirExists = self.diskIo.dirExists
self.assertTrue(dirExists(self.settings.configPath))
<|code_end|>
, generate the next line using the imports in this file:
from .FileSystemTestCase import FileSystemTestCase
from vimswitch.Settings import Settings
from vimswitch.DiskIo import getDiskIo
from vimswitch.ApplicationDirs import getApplicationDirs
from vimswitch.Application import Application
and context (functions, classes, or occasionally code) from other files:
# Path: vimswitch/test/FileSystemTestCase.py
# class FileSystemTestCase(BaseTestCase):
# """
# Inherit from this class when a unit test needs to access the disk. This
# class sets up a sandbox so that disk modifications only occur within a
# working directory. This keeps test code from affecting other files on the
# system.
#
# To get a path relative to the working directory use getTestPath(). To get a
# path to test data use getDataPath().
#
# The working directory is cleared after every test so there is no need to do
# it manually within your tests.
# """
#
# def setUp(self):
# self.sandbox = FileSystemSandbox()
# self.sandbox.enable(self.getWorkingDir())
# self.clearWorkingDirectory()
#
# def tearDown(self):
# self.clearWorkingDirectory()
# self.sandbox.disable()
#
# @classmethod
# def getMyDir(self):
# return os.path.dirname(__file__)
#
# @classmethod
# def getTestPath(self, path):
# "Returns path prepended by the working directory"
# fullPath = os.path.join(self.getWorkingDir(), path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getDataPath(self, path):
# "Returns path prepended by the test data directory"
# dataDir = 'data'
# fullPath = os.path.join(self.getMyDir(), dataDir, path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getWorkingDir(self):
# """"Returns the path to a directory where we can safely create files and
# directories during tests"""
# dirName = 'workingDir'
# return os.path.join(self.getMyDir(), dirName)
#
# def copyDataToWorkingDir(self, dataSrc, workingDirDest):
# "Copies a file or dir from the data directory to the working directory"
# dataSrc = self.getDataPath(dataSrc)
# workingDirDest = self.getTestPath(workingDirDest)
# if os.path.isdir(dataSrc):
# shutil.copytree(dataSrc, workingDirDest)
# else:
# shutil.copy(dataSrc, workingDirDest)
#
# def clearWorkingDirectory(self):
# for entry in os.listdir(self.getWorkingDir()):
# fullPath = os.path.join(self.getWorkingDir(), entry)
# if os.path.isfile(fullPath):
# # If file is readonly, make it writable
# if not os.access(fullPath, os.W_OK):
# os.chmod(fullPath, stat.S_IWRITE)
# os.remove(fullPath)
# elif os.path.isdir(fullPath):
# shutil.rmtree(fullPath, onerror=_remove_readonly)
#
# Path: vimswitch/Settings.py
# class Settings:
#
# def __init__(self, homePath=''):
# """
# homePath is used as the prefix for all other paths. If homePath is not
# specified it gets set to the user's home directory.
# """
# self.homePath = homePath or os.path.expanduser('~')
# self.configPath = os.path.join(self.homePath, '.vimswitch')
# self.configFilePath = os.path.join(self.configPath, 'vimswitchrc')
# self.cachePath = os.path.join(self.configPath, 'profiles')
# self.downloadsPath = os.path.join(self.configPath, 'downloads')
# self.profileFiles = ['.vimrc', '_vimrc']
# self.profileDirs = ['.vim', '_vim']
# self.defaultProfile = Profile('default')
# self.currentProfile = None
#
# def __eq__(self, other):
# return self.__dict__ == other.__dict__
#
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
#
# Path: vimswitch/ApplicationDirs.py
# def getApplicationDirs(app):
# return app.get('applicationDirs', createApplicationDirs(app))
#
# Path: vimswitch/Application.py
# class Application:
# """
# A container for components that are used application-wide.
#
# Examples of how this class can be used:
#
# - Set a component
# `app.foo = myFoo`
#
# - Get (or create) a component:
# `foo = app.get('foo', Foo())`
# This will try to return `app.foo`. If that does not exist, then it will
# set `app.foo = Foo()` and return that instead.
#
# - Get an already created component
# `foo = app.foo`
# Use this when you are sure that app.foo has already been set
# """
#
# def get(self, attr, default):
# """
# Returns self.attr. If attr does not exist, then make self.attr = default
# and then return default.
# """
# if hasattr(self, attr):
# return getattr(self, attr)
# else:
# setattr(self, attr, default)
# return default
. Output only the next line. | self.assertTrue(dirExists(self.settings.cachePath)) |
Given snippet: <|code_start|>
class TestCommandLineParser(BaseTestCase):
def setUp(self):
self.commandLineParser = CommandLineParser()
def test_parse_emptyArgs_setsShowCurrentProfileAction(self):
argv = './vimswitch'.split()
self.commandLineParser.parse(argv)
self.assertEqual(self.commandLineParser.action, 'showCurrentProfile')
def test_parse_setsSwitchProfileAction(self):
argv = './vimswitch test/vimrc'.split()
self.commandLineParser.parse(argv)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .BaseTestCase import BaseTestCase
from vimswitch.CommandLineParser import CommandLineParser
from vimswitch.Profile import Profile
and context:
# Path: vimswitch/test/BaseTestCase.py
# class BaseTestCase(unittest.TestCase):
# def __init__(self, *args, **kwargs):
# unittest.TestCase.__init__(self, *args, **kwargs)
#
# # Python < 3.2 does not have assertNotRegex
# if not hasattr(self, 'assertNotRegex'):
# self.assertNotRegex = self.assertNotRegexpMatches
#
# def assertMultilineRegexpMatches(self, string, regexp):
# """
# Asserts that the entirety of `string` matches `regexp`. `regexp` can be
# a multiline string with indentation.
# """
# regexp = textwrap.dedent(regexp)
# regexp = regexp.strip()
# regexp = '^' + regexp + '$'
# regexp = re.compile(regexp, re.DOTALL)
#
# self.assertRegexpMatches(string, regexp)
#
# def assertStdout(self, stdout, regexp):
# "Asserts that the `stdout` io stream matches `regexp`"
# stdoutText = stdout.getvalue().strip()
# self.assertMultilineRegexpMatches(stdoutText, regexp)
#
# def resetStdout(self, stdout):
# stdout.seek(0)
# stdout.truncate(0)
#
# Path: vimswitch/CommandLineParser.py
# class CommandLineParser:
# def __init__(self):
# self.action = ''
# self.profile = None
# self.errorMessage = ''
# self.helpText = ''
#
# def parse(self, argv):
# parser = self._createParser()
# self.helpText = parser.format_help()
#
# argv = argv[1:] # Remove the program name from the arguments
# arguments = parser.parse_args(argv)
#
# self._processArguments(parser, arguments, argv)
#
# def _createParser(self):
# parser = CustomArgumentParser(
# prog='vimswitch',
# description='A utility for switching between vim profiles.')
# parser.add_argument('profile', nargs='?')
# parser.add_argument('-u', '--update', action='store_true',
# help='download profile again')
# parser.add_argument('-v', '--version', action='store_true',
# help='show version')
# return parser
#
# def _processArguments(self, parser, arguments, argv):
# if parser.hasError:
# self.errorMessage = parser.errorMessage
# self.action = 'invalidArgs'
# elif arguments.version:
# self.action = 'showVersion'
# elif arguments.update:
# self.action = 'updateProfile'
# profileName = arguments.profile
# if profileName is None:
# self.profile = None
# else:
# self.profile = Profile(profileName)
# elif arguments.profile is not None:
# self.action = 'switchProfile'
# profileName = arguments.profile
# self.profile = Profile(profileName)
# elif len(argv) == 0:
# self.action = 'showCurrentProfile'
#
# Path: vimswitch/Profile.py
# class Profile:
# def __init__(self, name):
# self.name = name
#
# def getName(self):
# return self.name
#
# def getDirName(self):
# return self.name.replace('/', '.')
#
# def __eq__(self, other):
# return isinstance(other, Profile) and self.name == other.name
#
# def __ne__(self, other):
# return not self.__eq__(other)
#
# def __repr__(self):
# return "Profile('%s')" % self.name
which might include code, classes, or functions. Output only the next line. | self.assertEqual(self.commandLineParser.action, 'switchProfile') |
Given the code snippet: <|code_start|>
class TestCommandLineParser(BaseTestCase):
def setUp(self):
self.commandLineParser = CommandLineParser()
def test_parse_emptyArgs_setsShowCurrentProfileAction(self):
argv = './vimswitch'.split()
self.commandLineParser.parse(argv)
self.assertEqual(self.commandLineParser.action, 'showCurrentProfile')
<|code_end|>
, generate the next line using the imports in this file:
from .BaseTestCase import BaseTestCase
from vimswitch.CommandLineParser import CommandLineParser
from vimswitch.Profile import Profile
and context (functions, classes, or occasionally code) from other files:
# Path: vimswitch/test/BaseTestCase.py
# class BaseTestCase(unittest.TestCase):
# def __init__(self, *args, **kwargs):
# unittest.TestCase.__init__(self, *args, **kwargs)
#
# # Python < 3.2 does not have assertNotRegex
# if not hasattr(self, 'assertNotRegex'):
# self.assertNotRegex = self.assertNotRegexpMatches
#
# def assertMultilineRegexpMatches(self, string, regexp):
# """
# Asserts that the entirety of `string` matches `regexp`. `regexp` can be
# a multiline string with indentation.
# """
# regexp = textwrap.dedent(regexp)
# regexp = regexp.strip()
# regexp = '^' + regexp + '$'
# regexp = re.compile(regexp, re.DOTALL)
#
# self.assertRegexpMatches(string, regexp)
#
# def assertStdout(self, stdout, regexp):
# "Asserts that the `stdout` io stream matches `regexp`"
# stdoutText = stdout.getvalue().strip()
# self.assertMultilineRegexpMatches(stdoutText, regexp)
#
# def resetStdout(self, stdout):
# stdout.seek(0)
# stdout.truncate(0)
#
# Path: vimswitch/CommandLineParser.py
# class CommandLineParser:
# def __init__(self):
# self.action = ''
# self.profile = None
# self.errorMessage = ''
# self.helpText = ''
#
# def parse(self, argv):
# parser = self._createParser()
# self.helpText = parser.format_help()
#
# argv = argv[1:] # Remove the program name from the arguments
# arguments = parser.parse_args(argv)
#
# self._processArguments(parser, arguments, argv)
#
# def _createParser(self):
# parser = CustomArgumentParser(
# prog='vimswitch',
# description='A utility for switching between vim profiles.')
# parser.add_argument('profile', nargs='?')
# parser.add_argument('-u', '--update', action='store_true',
# help='download profile again')
# parser.add_argument('-v', '--version', action='store_true',
# help='show version')
# return parser
#
# def _processArguments(self, parser, arguments, argv):
# if parser.hasError:
# self.errorMessage = parser.errorMessage
# self.action = 'invalidArgs'
# elif arguments.version:
# self.action = 'showVersion'
# elif arguments.update:
# self.action = 'updateProfile'
# profileName = arguments.profile
# if profileName is None:
# self.profile = None
# else:
# self.profile = Profile(profileName)
# elif arguments.profile is not None:
# self.action = 'switchProfile'
# profileName = arguments.profile
# self.profile = Profile(profileName)
# elif len(argv) == 0:
# self.action = 'showCurrentProfile'
#
# Path: vimswitch/Profile.py
# class Profile:
# def __init__(self, name):
# self.name = name
#
# def getName(self):
# return self.name
#
# def getDirName(self):
# return self.name.replace('/', '.')
#
# def __eq__(self, other):
# return isinstance(other, Profile) and self.name == other.name
#
# def __ne__(self, other):
# return not self.__eq__(other)
#
# def __repr__(self):
# return "Profile('%s')" % self.name
. Output only the next line. | def test_parse_setsSwitchProfileAction(self): |
Continue the code snippet: <|code_start|>
class TestCommandLineParser(BaseTestCase):
def setUp(self):
self.commandLineParser = CommandLineParser()
def test_parse_emptyArgs_setsShowCurrentProfileAction(self):
argv = './vimswitch'.split()
<|code_end|>
. Use current file imports:
from .BaseTestCase import BaseTestCase
from vimswitch.CommandLineParser import CommandLineParser
from vimswitch.Profile import Profile
and context (classes, functions, or code) from other files:
# Path: vimswitch/test/BaseTestCase.py
# class BaseTestCase(unittest.TestCase):
# def __init__(self, *args, **kwargs):
# unittest.TestCase.__init__(self, *args, **kwargs)
#
# # Python < 3.2 does not have assertNotRegex
# if not hasattr(self, 'assertNotRegex'):
# self.assertNotRegex = self.assertNotRegexpMatches
#
# def assertMultilineRegexpMatches(self, string, regexp):
# """
# Asserts that the entirety of `string` matches `regexp`. `regexp` can be
# a multiline string with indentation.
# """
# regexp = textwrap.dedent(regexp)
# regexp = regexp.strip()
# regexp = '^' + regexp + '$'
# regexp = re.compile(regexp, re.DOTALL)
#
# self.assertRegexpMatches(string, regexp)
#
# def assertStdout(self, stdout, regexp):
# "Asserts that the `stdout` io stream matches `regexp`"
# stdoutText = stdout.getvalue().strip()
# self.assertMultilineRegexpMatches(stdoutText, regexp)
#
# def resetStdout(self, stdout):
# stdout.seek(0)
# stdout.truncate(0)
#
# Path: vimswitch/CommandLineParser.py
# class CommandLineParser:
# def __init__(self):
# self.action = ''
# self.profile = None
# self.errorMessage = ''
# self.helpText = ''
#
# def parse(self, argv):
# parser = self._createParser()
# self.helpText = parser.format_help()
#
# argv = argv[1:] # Remove the program name from the arguments
# arguments = parser.parse_args(argv)
#
# self._processArguments(parser, arguments, argv)
#
# def _createParser(self):
# parser = CustomArgumentParser(
# prog='vimswitch',
# description='A utility for switching between vim profiles.')
# parser.add_argument('profile', nargs='?')
# parser.add_argument('-u', '--update', action='store_true',
# help='download profile again')
# parser.add_argument('-v', '--version', action='store_true',
# help='show version')
# return parser
#
# def _processArguments(self, parser, arguments, argv):
# if parser.hasError:
# self.errorMessage = parser.errorMessage
# self.action = 'invalidArgs'
# elif arguments.version:
# self.action = 'showVersion'
# elif arguments.update:
# self.action = 'updateProfile'
# profileName = arguments.profile
# if profileName is None:
# self.profile = None
# else:
# self.profile = Profile(profileName)
# elif arguments.profile is not None:
# self.action = 'switchProfile'
# profileName = arguments.profile
# self.profile = Profile(profileName)
# elif len(argv) == 0:
# self.action = 'showCurrentProfile'
#
# Path: vimswitch/Profile.py
# class Profile:
# def __init__(self, name):
# self.name = name
#
# def getName(self):
# return self.name
#
# def getDirName(self):
# return self.name.replace('/', '.')
#
# def __eq__(self, other):
# return isinstance(other, Profile) and self.name == other.name
#
# def __ne__(self, other):
# return not self.__eq__(other)
#
# def __repr__(self):
# return "Profile('%s')" % self.name
. Output only the next line. | self.commandLineParser.parse(argv) |
Given the following code snippet before the placeholder: <|code_start|>
class TestZipFile(FileSystemTestCase):
def setUp(self):
FileSystemTestCase.setUp(self)
self.diskIo = DiskIo()
def test_extract_extractsFile(self):
zipPath = self.getDataPath('simple.zip')
destPath = self.getTestPath('')
destFile1Path = self.getTestPath('file1.txt')
destFile2Path = self.getTestPath('file2.txt')
zipFile = ZipFile(zipPath)
zipFile.extractall(destPath)
file1Expected = 'test data'
file1Actual = self.diskIo.getFileContents(destFile1Path)
file2Expected = 'test data 2'
file2Actual = self.diskIo.getFileContents(destFile2Path)
<|code_end|>
, predict the next line using imports from the current file:
from .FileSystemTestCase import FileSystemTestCase
from vimswitch.DiskIo import DiskIo
from zipfile import ZipFile
and context including class names, function names, and sometimes code from other files:
# Path: vimswitch/test/FileSystemTestCase.py
# class FileSystemTestCase(BaseTestCase):
# """
# Inherit from this class when a unit test needs to access the disk. This
# class sets up a sandbox so that disk modifications only occur within a
# working directory. This keeps test code from affecting other files on the
# system.
#
# To get a path relative to the working directory use getTestPath(). To get a
# path to test data use getDataPath().
#
# The working directory is cleared after every test so there is no need to do
# it manually within your tests.
# """
#
# def setUp(self):
# self.sandbox = FileSystemSandbox()
# self.sandbox.enable(self.getWorkingDir())
# self.clearWorkingDirectory()
#
# def tearDown(self):
# self.clearWorkingDirectory()
# self.sandbox.disable()
#
# @classmethod
# def getMyDir(self):
# return os.path.dirname(__file__)
#
# @classmethod
# def getTestPath(self, path):
# "Returns path prepended by the working directory"
# fullPath = os.path.join(self.getWorkingDir(), path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getDataPath(self, path):
# "Returns path prepended by the test data directory"
# dataDir = 'data'
# fullPath = os.path.join(self.getMyDir(), dataDir, path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getWorkingDir(self):
# """"Returns the path to a directory where we can safely create files and
# directories during tests"""
# dirName = 'workingDir'
# return os.path.join(self.getMyDir(), dirName)
#
# def copyDataToWorkingDir(self, dataSrc, workingDirDest):
# "Copies a file or dir from the data directory to the working directory"
# dataSrc = self.getDataPath(dataSrc)
# workingDirDest = self.getTestPath(workingDirDest)
# if os.path.isdir(dataSrc):
# shutil.copytree(dataSrc, workingDirDest)
# else:
# shutil.copy(dataSrc, workingDirDest)
#
# def clearWorkingDirectory(self):
# for entry in os.listdir(self.getWorkingDir()):
# fullPath = os.path.join(self.getWorkingDir(), entry)
# if os.path.isfile(fullPath):
# # If file is readonly, make it writable
# if not os.access(fullPath, os.W_OK):
# os.chmod(fullPath, stat.S_IWRITE)
# os.remove(fullPath)
# elif os.path.isdir(fullPath):
# shutil.rmtree(fullPath, onerror=_remove_readonly)
#
# Path: vimswitch/DiskIo.py
# class DiskIo:
#
# def createFile(self, filePath, contents):
# with open(filePath, 'w') as file:
# file.write(contents)
#
# def getFileContents(self, filePath):
# with open(filePath, 'r') as file:
# return file.read()
#
# def copyFile(self, srcPath, destPath):
# shutil.copy(srcPath, destPath)
#
# def move(self, srcPath, destPath):
# shutil.move(srcPath, destPath)
#
# def deleteFile(self, filePath):
# os.remove(filePath)
#
# def fileExists(self, filePath):
# return os.path.isfile(filePath)
#
# def createDir(self, dirPath):
# return os.mkdir(dirPath)
#
# def createDirWithParents(self, dirPath):
# return os.makedirs(dirPath)
#
# def copyDir(self, srcPath, destPath):
# """
# Recursively copies the src directory to a new dest directory. Creates
# the parent directories of the destination if required.
#
# Raises OSError if the destination directory already exists.
# """
# return shutil.copytree(srcPath, destPath)
#
# def deleteDir(self, dirPath):
# """
# Recursively delete a directory. Read-only files inside the directory
# will also be deleted.
# """
# shutil.rmtree(dirPath, onerror=self._remove_readonly)
#
# def dirExists(self, dirPath):
# return os.path.isdir(dirPath)
#
# def isDirEmpty(self, dirPath):
# return len(os.listdir(dirPath)) == 0
#
# def getDirContents(self, dirPath):
# return os.listdir(dirPath)
#
# def anyExists(self, path):
# return self.fileExists(path) or self.dirExists(path)
#
# def setReadOnly(self, path, readOnly):
# st = os.stat(path)
# if readOnly:
# os.chmod(path, st.st_mode & ~stat.S_IWRITE)
# else:
# os.chmod(path, st.st_mode | stat.S_IWRITE)
#
# def isReadOnly(self, path):
# mode = os.stat(path)[stat.ST_MODE]
# return not mode & stat.S_IWRITE
#
# # Private
#
# def _remove_readonly(self, func, path, excinfo):
# os.chmod(path, stat.S_IWRITE)
# func(path)
. Output only the next line. | self.assertTrue(file1Actual, file1Expected) |
Predict the next line after this snippet: <|code_start|>
class ProfileCache:
def __init__(self, settings, diskIo):
self.settings = settings
self.diskIo = diskIo
def contains(self, profile):
profileLocation = self.getProfileLocation(profile)
return self.diskIo.dirExists(profileLocation)
def delete(self, profile):
<|code_end|>
using the current file's imports:
import os
from .Settings import getSettings
from .DiskIo import getDiskIo
and any relevant context from other files:
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
#
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
. Output only the next line. | profileDirPath = self.getProfileLocation(profile) |
Given snippet: <|code_start|>
class ProfileCache:
def __init__(self, settings, diskIo):
self.settings = settings
self.diskIo = diskIo
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
from .Settings import getSettings
from .DiskIo import getDiskIo
and context:
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
#
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
which might include code, classes, or functions. Output only the next line. | def contains(self, profile): |
Predict the next line for this snippet: <|code_start|>
class SwitchProfileAction(Action):
def __init__(self, settings, profileCache, profileCopier, profileRetriever):
Action.__init__(self)
self.settings = settings
self.profileCache = profileCache
self.profileCopier = profileCopier
self.profileRetriever = profileRetriever
self.update = False
self.profile = None
def execute(self):
self._saveCurrentProfile()
self._retrieveProfile(self.profile)
self.profileCopier.copyToHome(self.profile)
self.settings.currentProfile = self.profile
print('Switched to profile: %s' % self.profile.name)
def _saveCurrentProfile(self):
currentProfile = self._getCurrentProfile()
print('Saving profile: %s' % currentProfile.name)
self.profileCopier.copyFromHome(currentProfile)
def _retrieveProfile(self, profile):
<|code_end|>
with the help of current file imports:
from .Action import Action
from .ProfileCache import getProfileCache
from .ProfileCopier import getProfileCopier
from .ProfileRetriever import getProfileRetriever
from .Settings import getSettings
and context from other files:
# Path: vimswitch/Action.py
# class Action:
# def __init__(self):
# self.exitCode = 0
#
# def execute():
# raise NotImplementedError
#
# Path: vimswitch/ProfileCache.py
# def getProfileCache(app):
# return app.get('profileCache', createProfileCache(app))
#
# Path: vimswitch/ProfileCopier.py
# def getProfileCopier(app):
# return app.get('profileCopier', createProfileCopier(app))
#
# Path: vimswitch/ProfileRetriever.py
# def getProfileRetriever(app):
# return app.get('profileRetriever', createProfileRetriever(app))
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
, which may contain function names, class names, or code. Output only the next line. | if not self.profileCache.contains(profile) or self.update: |
Given snippet: <|code_start|> def __init__(self, settings, profileCache, profileCopier, profileRetriever):
Action.__init__(self)
self.settings = settings
self.profileCache = profileCache
self.profileCopier = profileCopier
self.profileRetriever = profileRetriever
self.update = False
self.profile = None
def execute(self):
self._saveCurrentProfile()
self._retrieveProfile(self.profile)
self.profileCopier.copyToHome(self.profile)
self.settings.currentProfile = self.profile
print('Switched to profile: %s' % self.profile.name)
def _saveCurrentProfile(self):
currentProfile = self._getCurrentProfile()
print('Saving profile: %s' % currentProfile.name)
self.profileCopier.copyFromHome(currentProfile)
def _retrieveProfile(self, profile):
if not self.profileCache.contains(profile) or self.update:
self.profileRetriever.retrieve(profile)
def _getCurrentProfile(self):
if self.settings.currentProfile is None:
currentProfile = self.settings.defaultProfile
else:
currentProfile = self.settings.currentProfile
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .Action import Action
from .ProfileCache import getProfileCache
from .ProfileCopier import getProfileCopier
from .ProfileRetriever import getProfileRetriever
from .Settings import getSettings
and context:
# Path: vimswitch/Action.py
# class Action:
# def __init__(self):
# self.exitCode = 0
#
# def execute():
# raise NotImplementedError
#
# Path: vimswitch/ProfileCache.py
# def getProfileCache(app):
# return app.get('profileCache', createProfileCache(app))
#
# Path: vimswitch/ProfileCopier.py
# def getProfileCopier(app):
# return app.get('profileCopier', createProfileCopier(app))
#
# Path: vimswitch/ProfileRetriever.py
# def getProfileRetriever(app):
# return app.get('profileRetriever', createProfileRetriever(app))
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
which might include code, classes, or functions. Output only the next line. | return currentProfile |
Continue the code snippet: <|code_start|>
class SwitchProfileAction(Action):
def __init__(self, settings, profileCache, profileCopier, profileRetriever):
Action.__init__(self)
self.settings = settings
self.profileCache = profileCache
<|code_end|>
. Use current file imports:
from .Action import Action
from .ProfileCache import getProfileCache
from .ProfileCopier import getProfileCopier
from .ProfileRetriever import getProfileRetriever
from .Settings import getSettings
and context (classes, functions, or code) from other files:
# Path: vimswitch/Action.py
# class Action:
# def __init__(self):
# self.exitCode = 0
#
# def execute():
# raise NotImplementedError
#
# Path: vimswitch/ProfileCache.py
# def getProfileCache(app):
# return app.get('profileCache', createProfileCache(app))
#
# Path: vimswitch/ProfileCopier.py
# def getProfileCopier(app):
# return app.get('profileCopier', createProfileCopier(app))
#
# Path: vimswitch/ProfileRetriever.py
# def getProfileRetriever(app):
# return app.get('profileRetriever', createProfileRetriever(app))
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
. Output only the next line. | self.profileCopier = profileCopier |
Using the snippet: <|code_start|>
class SwitchProfileAction(Action):
def __init__(self, settings, profileCache, profileCopier, profileRetriever):
Action.__init__(self)
self.settings = settings
self.profileCache = profileCache
self.profileCopier = profileCopier
self.profileRetriever = profileRetriever
self.update = False
self.profile = None
def execute(self):
self._saveCurrentProfile()
self._retrieveProfile(self.profile)
self.profileCopier.copyToHome(self.profile)
self.settings.currentProfile = self.profile
print('Switched to profile: %s' % self.profile.name)
def _saveCurrentProfile(self):
currentProfile = self._getCurrentProfile()
print('Saving profile: %s' % currentProfile.name)
<|code_end|>
, determine the next line of code. You have imports:
from .Action import Action
from .ProfileCache import getProfileCache
from .ProfileCopier import getProfileCopier
from .ProfileRetriever import getProfileRetriever
from .Settings import getSettings
and context (class names, function names, or code) available:
# Path: vimswitch/Action.py
# class Action:
# def __init__(self):
# self.exitCode = 0
#
# def execute():
# raise NotImplementedError
#
# Path: vimswitch/ProfileCache.py
# def getProfileCache(app):
# return app.get('profileCache', createProfileCache(app))
#
# Path: vimswitch/ProfileCopier.py
# def getProfileCopier(app):
# return app.get('profileCopier', createProfileCopier(app))
#
# Path: vimswitch/ProfileRetriever.py
# def getProfileRetriever(app):
# return app.get('profileRetriever', createProfileRetriever(app))
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
. Output only the next line. | self.profileCopier.copyFromHome(currentProfile) |
Given snippet: <|code_start|>
class SwitchProfileAction(Action):
def __init__(self, settings, profileCache, profileCopier, profileRetriever):
Action.__init__(self)
self.settings = settings
self.profileCache = profileCache
self.profileCopier = profileCopier
self.profileRetriever = profileRetriever
self.update = False
self.profile = None
def execute(self):
self._saveCurrentProfile()
self._retrieveProfile(self.profile)
self.profileCopier.copyToHome(self.profile)
self.settings.currentProfile = self.profile
print('Switched to profile: %s' % self.profile.name)
def _saveCurrentProfile(self):
currentProfile = self._getCurrentProfile()
print('Saving profile: %s' % currentProfile.name)
self.profileCopier.copyFromHome(currentProfile)
def _retrieveProfile(self, profile):
if not self.profileCache.contains(profile) or self.update:
self.profileRetriever.retrieve(profile)
def _getCurrentProfile(self):
if self.settings.currentProfile is None:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .Action import Action
from .ProfileCache import getProfileCache
from .ProfileCopier import getProfileCopier
from .ProfileRetriever import getProfileRetriever
from .Settings import getSettings
and context:
# Path: vimswitch/Action.py
# class Action:
# def __init__(self):
# self.exitCode = 0
#
# def execute():
# raise NotImplementedError
#
# Path: vimswitch/ProfileCache.py
# def getProfileCache(app):
# return app.get('profileCache', createProfileCache(app))
#
# Path: vimswitch/ProfileCopier.py
# def getProfileCopier(app):
# return app.get('profileCopier', createProfileCopier(app))
#
# Path: vimswitch/ProfileRetriever.py
# def getProfileRetriever(app):
# return app.get('profileRetriever', createProfileRetriever(app))
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
which might include code, classes, or functions. Output only the next line. | currentProfile = self.settings.defaultProfile |
Based on the snippet: <|code_start|>
if __name__ == '__main__':
vimSwitch = VimSwitch()
exitCode = vimSwitch.main(sys.argv)
<|code_end|>
, predict the immediate next line with the help of imports:
from vimswitch.VimSwitch import VimSwitch
import sys
and context (classes, functions, sometimes code) from other files:
# Path: vimswitch/VimSwitch.py
# class VimSwitch:
# def __init__(self, app=Application()):
# self.app = app
# self.raiseExceptions = False
#
# def main(self, argv):
# """
# Runs VimSwitch with the given args. Returns 0 on success, or -1 if an
# error occurred.
# """
# try:
# self.loadSettings()
# commandLineParser = getCommandLineParser(self.app)
# commandLineParser.parse(argv)
# actionResolver = getActionResolver(self.app)
# actionResolver.doActions()
# self.saveSettings()
# return actionResolver.exitCode
# except Exception as e:
# message = 'Error: %s' % str(e)
# print(message)
# return -1
#
# def loadSettings(self):
# applicationDirs = getApplicationDirs(self.app)
# applicationDirs.createIfNone()
# settings = getSettings(self.app)
# configFile = getConfigFile(self.app)
# configFile.loadSettings(settings, settings.configFilePath)
#
# def saveSettings(self):
# settings = getSettings(self.app)
# configFile = getConfigFile(self.app)
# configFile.saveSettings(settings, settings.configFilePath)
. Output only the next line. | sys.exit(exitCode) |
Given snippet: <|code_start|>
class TestProfile(BaseTestCase):
def test_getDirName_withSlashes_replacedByDot(self):
profile = Profile('user/repo')
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .BaseTestCase import BaseTestCase
from vimswitch.Profile import Profile
and context:
# Path: vimswitch/test/BaseTestCase.py
# class BaseTestCase(unittest.TestCase):
# def __init__(self, *args, **kwargs):
# unittest.TestCase.__init__(self, *args, **kwargs)
#
# # Python < 3.2 does not have assertNotRegex
# if not hasattr(self, 'assertNotRegex'):
# self.assertNotRegex = self.assertNotRegexpMatches
#
# def assertMultilineRegexpMatches(self, string, regexp):
# """
# Asserts that the entirety of `string` matches `regexp`. `regexp` can be
# a multiline string with indentation.
# """
# regexp = textwrap.dedent(regexp)
# regexp = regexp.strip()
# regexp = '^' + regexp + '$'
# regexp = re.compile(regexp, re.DOTALL)
#
# self.assertRegexpMatches(string, regexp)
#
# def assertStdout(self, stdout, regexp):
# "Asserts that the `stdout` io stream matches `regexp`"
# stdoutText = stdout.getvalue().strip()
# self.assertMultilineRegexpMatches(stdoutText, regexp)
#
# def resetStdout(self, stdout):
# stdout.seek(0)
# stdout.truncate(0)
#
# Path: vimswitch/Profile.py
# class Profile:
# def __init__(self, name):
# self.name = name
#
# def getName(self):
# return self.name
#
# def getDirName(self):
# return self.name.replace('/', '.')
#
# def __eq__(self, other):
# return isinstance(other, Profile) and self.name == other.name
#
# def __ne__(self, other):
# return not self.__eq__(other)
#
# def __repr__(self):
# return "Profile('%s')" % self.name
which might include code, classes, or functions. Output only the next line. | self.assertEquals(profile.getDirName(), 'user.repo') |
Given the code snippet: <|code_start|>
class TestProfile(BaseTestCase):
def test_getDirName_withSlashes_replacedByDot(self):
profile = Profile('user/repo')
<|code_end|>
, generate the next line using the imports in this file:
from .BaseTestCase import BaseTestCase
from vimswitch.Profile import Profile
and context (functions, classes, or occasionally code) from other files:
# Path: vimswitch/test/BaseTestCase.py
# class BaseTestCase(unittest.TestCase):
# def __init__(self, *args, **kwargs):
# unittest.TestCase.__init__(self, *args, **kwargs)
#
# # Python < 3.2 does not have assertNotRegex
# if not hasattr(self, 'assertNotRegex'):
# self.assertNotRegex = self.assertNotRegexpMatches
#
# def assertMultilineRegexpMatches(self, string, regexp):
# """
# Asserts that the entirety of `string` matches `regexp`. `regexp` can be
# a multiline string with indentation.
# """
# regexp = textwrap.dedent(regexp)
# regexp = regexp.strip()
# regexp = '^' + regexp + '$'
# regexp = re.compile(regexp, re.DOTALL)
#
# self.assertRegexpMatches(string, regexp)
#
# def assertStdout(self, stdout, regexp):
# "Asserts that the `stdout` io stream matches `regexp`"
# stdoutText = stdout.getvalue().strip()
# self.assertMultilineRegexpMatches(stdoutText, regexp)
#
# def resetStdout(self, stdout):
# stdout.seek(0)
# stdout.truncate(0)
#
# Path: vimswitch/Profile.py
# class Profile:
# def __init__(self, name):
# self.name = name
#
# def getName(self):
# return self.name
#
# def getDirName(self):
# return self.name.replace('/', '.')
#
# def __eq__(self, other):
# return isinstance(other, Profile) and self.name == other.name
#
# def __ne__(self, other):
# return not self.__eq__(other)
#
# def __repr__(self):
# return "Profile('%s')" % self.name
. Output only the next line. | self.assertEquals(profile.getDirName(), 'user.repo') |
Next line prediction: <|code_start|>
class ShowCurrentProfileAction(Action):
def __init__(self, settings):
Action.__init__(self)
<|code_end|>
. Use current file imports:
(from .Action import Action
from .Settings import getSettings)
and context including class names, function names, or small code snippets from other files:
# Path: vimswitch/Action.py
# class Action:
# def __init__(self):
# self.exitCode = 0
#
# def execute():
# raise NotImplementedError
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
. Output only the next line. | self.settings = settings |
Using the snippet: <|code_start|>
class ShowCurrentProfileAction(Action):
def __init__(self, settings):
Action.__init__(self)
self.settings = settings
def execute(self):
if self.settings.currentProfile is None:
<|code_end|>
, determine the next line of code. You have imports:
from .Action import Action
from .Settings import getSettings
and context (class names, function names, or code) available:
# Path: vimswitch/Action.py
# class Action:
# def __init__(self):
# self.exitCode = 0
#
# def execute():
# raise NotImplementedError
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
. Output only the next line. | profileName = 'None' |
Here is a snippet: <|code_start|>
class ProfileCopier:
def __init__(self, settings, profileCache, profileDataIo):
self.settings = settings
self.profileCache = profileCache
self.profileDataIo = profileDataIo
<|code_end|>
. Write the next line using the current file imports:
from .Settings import getSettings
from .ProfileCache import getProfileCache
from .ProfileDataIo import getProfileDataIo
and context from other files:
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
#
# Path: vimswitch/ProfileCache.py
# def getProfileCache(app):
# return app.get('profileCache', createProfileCache(app))
#
# Path: vimswitch/ProfileDataIo.py
# def getProfileDataIo(app):
# return app.get('profileDataIo', createProfileDataIo(app))
, which may include functions, classes, or code. Output only the next line. | def copyToHome(self, profile): |
Using the snippet: <|code_start|>
class ProfileCopier:
def __init__(self, settings, profileCache, profileDataIo):
self.settings = settings
<|code_end|>
, determine the next line of code. You have imports:
from .Settings import getSettings
from .ProfileCache import getProfileCache
from .ProfileDataIo import getProfileDataIo
and context (class names, function names, or code) available:
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
#
# Path: vimswitch/ProfileCache.py
# def getProfileCache(app):
# return app.get('profileCache', createProfileCache(app))
#
# Path: vimswitch/ProfileDataIo.py
# def getProfileDataIo(app):
# return app.get('profileDataIo', createProfileDataIo(app))
. Output only the next line. | self.profileCache = profileCache |
Based on the snippet: <|code_start|>
class ProfileCopier:
def __init__(self, settings, profileCache, profileDataIo):
self.settings = settings
self.profileCache = profileCache
self.profileDataIo = profileDataIo
<|code_end|>
, predict the immediate next line with the help of imports:
from .Settings import getSettings
from .ProfileCache import getProfileCache
from .ProfileDataIo import getProfileDataIo
and context (classes, functions, sometimes code) from other files:
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
#
# Path: vimswitch/ProfileCache.py
# def getProfileCache(app):
# return app.get('profileCache', createProfileCache(app))
#
# Path: vimswitch/ProfileDataIo.py
# def getProfileDataIo(app):
# return app.get('profileDataIo', createProfileDataIo(app))
. Output only the next line. | def copyToHome(self, profile): |
Using the snippet: <|code_start|>
class ApplicationDirs:
def __init__(self, settings, diskIo):
self.settings = settings
self.diskIo = diskIo
def createIfNone(self):
self._createDir(self.settings.configPath)
self._createDir(self.settings.cachePath)
self._createDir(self.settings.downloadsPath)
def _createDir(self, path):
if not self.diskIo.dirExists(path):
self.diskIo.createDir(path)
<|code_end|>
, determine the next line of code. You have imports:
from .DiskIo import getDiskIo
from .Settings import getSettings
and context (class names, function names, or code) available:
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
. Output only the next line. | def getApplicationDirs(app): |
Next line prediction: <|code_start|>
class ApplicationDirs:
def __init__(self, settings, diskIo):
self.settings = settings
self.diskIo = diskIo
def createIfNone(self):
self._createDir(self.settings.configPath)
self._createDir(self.settings.cachePath)
self._createDir(self.settings.downloadsPath)
def _createDir(self, path):
if not self.diskIo.dirExists(path):
self.diskIo.createDir(path)
def getApplicationDirs(app):
return app.get('applicationDirs', createApplicationDirs(app))
<|code_end|>
. Use current file imports:
(from .DiskIo import getDiskIo
from .Settings import getSettings)
and context including class names, function names, or small code snippets from other files:
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
. Output only the next line. | def createApplicationDirs(app): |
Based on the snippet: <|code_start|>
class ProfileDataIo:
def __init__(self, settings, diskIo):
self.settings = settings
<|code_end|>
, predict the immediate next line with the help of imports:
import os
from .Settings import getSettings
from .DiskIo import getDiskIo
and context (classes, functions, sometimes code) from other files:
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
#
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
. Output only the next line. | self.diskIo = diskIo |
Predict the next line after this snippet: <|code_start|>
class TestShowCurrentProfileAction(BaseTestCase):
def setUp(self):
self.app = Application()
self.action = createShowCurrentProfileAction(self.app)
<|code_end|>
using the current file's imports:
from .BaseTestCase import BaseTestCase
from mock import patch
from vimswitch.Application import Application
from vimswitch.Profile import Profile
from vimswitch.ShowCurrentProfileAction import createShowCurrentProfileAction
from vimswitch.six import StringIO
and any relevant context from other files:
# Path: vimswitch/test/BaseTestCase.py
# class BaseTestCase(unittest.TestCase):
# def __init__(self, *args, **kwargs):
# unittest.TestCase.__init__(self, *args, **kwargs)
#
# # Python < 3.2 does not have assertNotRegex
# if not hasattr(self, 'assertNotRegex'):
# self.assertNotRegex = self.assertNotRegexpMatches
#
# def assertMultilineRegexpMatches(self, string, regexp):
# """
# Asserts that the entirety of `string` matches `regexp`. `regexp` can be
# a multiline string with indentation.
# """
# regexp = textwrap.dedent(regexp)
# regexp = regexp.strip()
# regexp = '^' + regexp + '$'
# regexp = re.compile(regexp, re.DOTALL)
#
# self.assertRegexpMatches(string, regexp)
#
# def assertStdout(self, stdout, regexp):
# "Asserts that the `stdout` io stream matches `regexp`"
# stdoutText = stdout.getvalue().strip()
# self.assertMultilineRegexpMatches(stdoutText, regexp)
#
# def resetStdout(self, stdout):
# stdout.seek(0)
# stdout.truncate(0)
#
# Path: vimswitch/Application.py
# class Application:
# """
# A container for components that are used application-wide.
#
# Examples of how this class can be used:
#
# - Set a component
# `app.foo = myFoo`
#
# - Get (or create) a component:
# `foo = app.get('foo', Foo())`
# This will try to return `app.foo`. If that does not exist, then it will
# set `app.foo = Foo()` and return that instead.
#
# - Get an already created component
# `foo = app.foo`
# Use this when you are sure that app.foo has already been set
# """
#
# def get(self, attr, default):
# """
# Returns self.attr. If attr does not exist, then make self.attr = default
# and then return default.
# """
# if hasattr(self, attr):
# return getattr(self, attr)
# else:
# setattr(self, attr, default)
# return default
#
# Path: vimswitch/Profile.py
# class Profile:
# def __init__(self, name):
# self.name = name
#
# def getName(self):
# return self.name
#
# def getDirName(self):
# return self.name.replace('/', '.')
#
# def __eq__(self, other):
# return isinstance(other, Profile) and self.name == other.name
#
# def __ne__(self, other):
# return not self.__eq__(other)
#
# def __repr__(self):
# return "Profile('%s')" % self.name
#
# Path: vimswitch/ShowCurrentProfileAction.py
# def createShowCurrentProfileAction(app):
# settings = getSettings(app)
# showCurrentProfileAction = ShowCurrentProfileAction(settings)
# return showCurrentProfileAction
. Output only the next line. | @patch('sys.stdout', new_callable=StringIO) |
Given the following code snippet before the placeholder: <|code_start|>
class TestShowCurrentProfileAction(BaseTestCase):
def setUp(self):
self.app = Application()
self.action = createShowCurrentProfileAction(self.app)
@patch('sys.stdout', new_callable=StringIO)
def test_execute_printsCurrentProfile(self, stdout):
self.app.settings.currentProfile = Profile('test/vimrc')
self.action.execute()
self.assertStdout(stdout, 'Current profile: test/vimrc')
@patch('sys.stdout', new_callable=StringIO)
def test_execute_currentProfileIsNone_printsNone(self, stdout):
<|code_end|>
, predict the next line using imports from the current file:
from .BaseTestCase import BaseTestCase
from mock import patch
from vimswitch.Application import Application
from vimswitch.Profile import Profile
from vimswitch.ShowCurrentProfileAction import createShowCurrentProfileAction
from vimswitch.six import StringIO
and context including class names, function names, and sometimes code from other files:
# Path: vimswitch/test/BaseTestCase.py
# class BaseTestCase(unittest.TestCase):
# def __init__(self, *args, **kwargs):
# unittest.TestCase.__init__(self, *args, **kwargs)
#
# # Python < 3.2 does not have assertNotRegex
# if not hasattr(self, 'assertNotRegex'):
# self.assertNotRegex = self.assertNotRegexpMatches
#
# def assertMultilineRegexpMatches(self, string, regexp):
# """
# Asserts that the entirety of `string` matches `regexp`. `regexp` can be
# a multiline string with indentation.
# """
# regexp = textwrap.dedent(regexp)
# regexp = regexp.strip()
# regexp = '^' + regexp + '$'
# regexp = re.compile(regexp, re.DOTALL)
#
# self.assertRegexpMatches(string, regexp)
#
# def assertStdout(self, stdout, regexp):
# "Asserts that the `stdout` io stream matches `regexp`"
# stdoutText = stdout.getvalue().strip()
# self.assertMultilineRegexpMatches(stdoutText, regexp)
#
# def resetStdout(self, stdout):
# stdout.seek(0)
# stdout.truncate(0)
#
# Path: vimswitch/Application.py
# class Application:
# """
# A container for components that are used application-wide.
#
# Examples of how this class can be used:
#
# - Set a component
# `app.foo = myFoo`
#
# - Get (or create) a component:
# `foo = app.get('foo', Foo())`
# This will try to return `app.foo`. If that does not exist, then it will
# set `app.foo = Foo()` and return that instead.
#
# - Get an already created component
# `foo = app.foo`
# Use this when you are sure that app.foo has already been set
# """
#
# def get(self, attr, default):
# """
# Returns self.attr. If attr does not exist, then make self.attr = default
# and then return default.
# """
# if hasattr(self, attr):
# return getattr(self, attr)
# else:
# setattr(self, attr, default)
# return default
#
# Path: vimswitch/Profile.py
# class Profile:
# def __init__(self, name):
# self.name = name
#
# def getName(self):
# return self.name
#
# def getDirName(self):
# return self.name.replace('/', '.')
#
# def __eq__(self, other):
# return isinstance(other, Profile) and self.name == other.name
#
# def __ne__(self, other):
# return not self.__eq__(other)
#
# def __repr__(self):
# return "Profile('%s')" % self.name
#
# Path: vimswitch/ShowCurrentProfileAction.py
# def createShowCurrentProfileAction(app):
# settings = getSettings(app)
# showCurrentProfileAction = ShowCurrentProfileAction(settings)
# return showCurrentProfileAction
. Output only the next line. | self.app.settings.currentProfile = None |
Given the following code snippet before the placeholder: <|code_start|>
class TestShowCurrentProfileAction(BaseTestCase):
def setUp(self):
self.app = Application()
self.action = createShowCurrentProfileAction(self.app)
@patch('sys.stdout', new_callable=StringIO)
def test_execute_printsCurrentProfile(self, stdout):
self.app.settings.currentProfile = Profile('test/vimrc')
self.action.execute()
self.assertStdout(stdout, 'Current profile: test/vimrc')
@patch('sys.stdout', new_callable=StringIO)
def test_execute_currentProfileIsNone_printsNone(self, stdout):
self.app.settings.currentProfile = None
<|code_end|>
, predict the next line using imports from the current file:
from .BaseTestCase import BaseTestCase
from mock import patch
from vimswitch.Application import Application
from vimswitch.Profile import Profile
from vimswitch.ShowCurrentProfileAction import createShowCurrentProfileAction
from vimswitch.six import StringIO
and context including class names, function names, and sometimes code from other files:
# Path: vimswitch/test/BaseTestCase.py
# class BaseTestCase(unittest.TestCase):
# def __init__(self, *args, **kwargs):
# unittest.TestCase.__init__(self, *args, **kwargs)
#
# # Python < 3.2 does not have assertNotRegex
# if not hasattr(self, 'assertNotRegex'):
# self.assertNotRegex = self.assertNotRegexpMatches
#
# def assertMultilineRegexpMatches(self, string, regexp):
# """
# Asserts that the entirety of `string` matches `regexp`. `regexp` can be
# a multiline string with indentation.
# """
# regexp = textwrap.dedent(regexp)
# regexp = regexp.strip()
# regexp = '^' + regexp + '$'
# regexp = re.compile(regexp, re.DOTALL)
#
# self.assertRegexpMatches(string, regexp)
#
# def assertStdout(self, stdout, regexp):
# "Asserts that the `stdout` io stream matches `regexp`"
# stdoutText = stdout.getvalue().strip()
# self.assertMultilineRegexpMatches(stdoutText, regexp)
#
# def resetStdout(self, stdout):
# stdout.seek(0)
# stdout.truncate(0)
#
# Path: vimswitch/Application.py
# class Application:
# """
# A container for components that are used application-wide.
#
# Examples of how this class can be used:
#
# - Set a component
# `app.foo = myFoo`
#
# - Get (or create) a component:
# `foo = app.get('foo', Foo())`
# This will try to return `app.foo`. If that does not exist, then it will
# set `app.foo = Foo()` and return that instead.
#
# - Get an already created component
# `foo = app.foo`
# Use this when you are sure that app.foo has already been set
# """
#
# def get(self, attr, default):
# """
# Returns self.attr. If attr does not exist, then make self.attr = default
# and then return default.
# """
# if hasattr(self, attr):
# return getattr(self, attr)
# else:
# setattr(self, attr, default)
# return default
#
# Path: vimswitch/Profile.py
# class Profile:
# def __init__(self, name):
# self.name = name
#
# def getName(self):
# return self.name
#
# def getDirName(self):
# return self.name.replace('/', '.')
#
# def __eq__(self, other):
# return isinstance(other, Profile) and self.name == other.name
#
# def __ne__(self, other):
# return not self.__eq__(other)
#
# def __repr__(self):
# return "Profile('%s')" % self.name
#
# Path: vimswitch/ShowCurrentProfileAction.py
# def createShowCurrentProfileAction(app):
# settings = getSettings(app)
# showCurrentProfileAction = ShowCurrentProfileAction(settings)
# return showCurrentProfileAction
. Output only the next line. | self.action.execute() |
Here is a snippet: <|code_start|> self.assertFileContents('extractionDir/.vim/plugin/dummy_plugin.vim', '" dummy vim plugin')
def test_extract_multipleRootDirs_raisesError(self):
self.copyDataToWorkingDir('github_zipball_multiple_root_dirs.zip', 'zipball.zip')
zipballPath = self.getTestPath('zipball.zip')
extractionDirPath = self.getTestPath('extractionDir')
self.diskIo.createDir(extractionDirPath)
with self.assertRaises(IOError) as cm:
self.githubZipballExtractor.extractZipball(zipballPath, extractionDirPath)
self.assertRegexpMatches(str(cm.exception), 'Zipball .* has more than one root directory')
def test_extract_noRootDir_raisesError(self):
self.copyDataToWorkingDir('github_zipball_no_root_dir.zip', 'zipball.zip')
zipballPath = self.getTestPath('zipball.zip')
extractionDirPath = self.getTestPath('extractionDir')
self.diskIo.createDir(extractionDirPath)
with self.assertRaises(IOError) as cm:
self.githubZipballExtractor.extractZipball(zipballPath, extractionDirPath)
self.assertRegexpMatches(str(cm.exception), 'Zipball .* has no root directory')
# Helpers
def assertFileContents(self, path, expectedContents):
diskIo = self.diskIo
path = self.getTestPath(path)
actualContents = diskIo.getFileContents(path)
<|code_end|>
. Write the next line using the current file imports:
from .FileSystemTestCase import FileSystemTestCase
from vimswitch.Application import Application
from vimswitch.GithubZipballExtractor import getGithubZipballExtractor
and context from other files:
# Path: vimswitch/test/FileSystemTestCase.py
# class FileSystemTestCase(BaseTestCase):
# """
# Inherit from this class when a unit test needs to access the disk. This
# class sets up a sandbox so that disk modifications only occur within a
# working directory. This keeps test code from affecting other files on the
# system.
#
# To get a path relative to the working directory use getTestPath(). To get a
# path to test data use getDataPath().
#
# The working directory is cleared after every test so there is no need to do
# it manually within your tests.
# """
#
# def setUp(self):
# self.sandbox = FileSystemSandbox()
# self.sandbox.enable(self.getWorkingDir())
# self.clearWorkingDirectory()
#
# def tearDown(self):
# self.clearWorkingDirectory()
# self.sandbox.disable()
#
# @classmethod
# def getMyDir(self):
# return os.path.dirname(__file__)
#
# @classmethod
# def getTestPath(self, path):
# "Returns path prepended by the working directory"
# fullPath = os.path.join(self.getWorkingDir(), path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getDataPath(self, path):
# "Returns path prepended by the test data directory"
# dataDir = 'data'
# fullPath = os.path.join(self.getMyDir(), dataDir, path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getWorkingDir(self):
# """"Returns the path to a directory where we can safely create files and
# directories during tests"""
# dirName = 'workingDir'
# return os.path.join(self.getMyDir(), dirName)
#
# def copyDataToWorkingDir(self, dataSrc, workingDirDest):
# "Copies a file or dir from the data directory to the working directory"
# dataSrc = self.getDataPath(dataSrc)
# workingDirDest = self.getTestPath(workingDirDest)
# if os.path.isdir(dataSrc):
# shutil.copytree(dataSrc, workingDirDest)
# else:
# shutil.copy(dataSrc, workingDirDest)
#
# def clearWorkingDirectory(self):
# for entry in os.listdir(self.getWorkingDir()):
# fullPath = os.path.join(self.getWorkingDir(), entry)
# if os.path.isfile(fullPath):
# # If file is readonly, make it writable
# if not os.access(fullPath, os.W_OK):
# os.chmod(fullPath, stat.S_IWRITE)
# os.remove(fullPath)
# elif os.path.isdir(fullPath):
# shutil.rmtree(fullPath, onerror=_remove_readonly)
#
# Path: vimswitch/Application.py
# class Application:
# """
# A container for components that are used application-wide.
#
# Examples of how this class can be used:
#
# - Set a component
# `app.foo = myFoo`
#
# - Get (or create) a component:
# `foo = app.get('foo', Foo())`
# This will try to return `app.foo`. If that does not exist, then it will
# set `app.foo = Foo()` and return that instead.
#
# - Get an already created component
# `foo = app.foo`
# Use this when you are sure that app.foo has already been set
# """
#
# def get(self, attr, default):
# """
# Returns self.attr. If attr does not exist, then make self.attr = default
# and then return default.
# """
# if hasattr(self, attr):
# return getattr(self, attr)
# else:
# setattr(self, attr, default)
# return default
#
# Path: vimswitch/GithubZipballExtractor.py
# def getGithubZipballExtractor(app):
# return app.get('githubZipballExtractor', createGithubZipballExtractor(app))
, which may include functions, classes, or code. Output only the next line. | self.assertEqual(actualContents, expectedContents) |
Here is a snippet: <|code_start|> self.copyDataToWorkingDir('vimrc-master.zip', 'zipball.zip')
zipballPath = self.getTestPath('zipball.zip')
extractionDirPath = self.getTestPath('extractionDir')
self.diskIo.createDir(extractionDirPath)
self.githubZipballExtractor.extractZipball(zipballPath, extractionDirPath)
self.assertFileContents('extractionDir/.vimrc', '" test vimrc data')
self.assertDirExists('extractionDir/.vim')
self.assertDirExists('extractionDir/.vim/plugin')
self.assertFileContents('extractionDir/.vim/plugin/dummy_plugin.vim', '" dummy vim plugin')
def test_extract_multipleRootDirs_raisesError(self):
self.copyDataToWorkingDir('github_zipball_multiple_root_dirs.zip', 'zipball.zip')
zipballPath = self.getTestPath('zipball.zip')
extractionDirPath = self.getTestPath('extractionDir')
self.diskIo.createDir(extractionDirPath)
with self.assertRaises(IOError) as cm:
self.githubZipballExtractor.extractZipball(zipballPath, extractionDirPath)
self.assertRegexpMatches(str(cm.exception), 'Zipball .* has more than one root directory')
def test_extract_noRootDir_raisesError(self):
self.copyDataToWorkingDir('github_zipball_no_root_dir.zip', 'zipball.zip')
zipballPath = self.getTestPath('zipball.zip')
extractionDirPath = self.getTestPath('extractionDir')
self.diskIo.createDir(extractionDirPath)
with self.assertRaises(IOError) as cm:
<|code_end|>
. Write the next line using the current file imports:
from .FileSystemTestCase import FileSystemTestCase
from vimswitch.Application import Application
from vimswitch.GithubZipballExtractor import getGithubZipballExtractor
and context from other files:
# Path: vimswitch/test/FileSystemTestCase.py
# class FileSystemTestCase(BaseTestCase):
# """
# Inherit from this class when a unit test needs to access the disk. This
# class sets up a sandbox so that disk modifications only occur within a
# working directory. This keeps test code from affecting other files on the
# system.
#
# To get a path relative to the working directory use getTestPath(). To get a
# path to test data use getDataPath().
#
# The working directory is cleared after every test so there is no need to do
# it manually within your tests.
# """
#
# def setUp(self):
# self.sandbox = FileSystemSandbox()
# self.sandbox.enable(self.getWorkingDir())
# self.clearWorkingDirectory()
#
# def tearDown(self):
# self.clearWorkingDirectory()
# self.sandbox.disable()
#
# @classmethod
# def getMyDir(self):
# return os.path.dirname(__file__)
#
# @classmethod
# def getTestPath(self, path):
# "Returns path prepended by the working directory"
# fullPath = os.path.join(self.getWorkingDir(), path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getDataPath(self, path):
# "Returns path prepended by the test data directory"
# dataDir = 'data'
# fullPath = os.path.join(self.getMyDir(), dataDir, path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getWorkingDir(self):
# """"Returns the path to a directory where we can safely create files and
# directories during tests"""
# dirName = 'workingDir'
# return os.path.join(self.getMyDir(), dirName)
#
# def copyDataToWorkingDir(self, dataSrc, workingDirDest):
# "Copies a file or dir from the data directory to the working directory"
# dataSrc = self.getDataPath(dataSrc)
# workingDirDest = self.getTestPath(workingDirDest)
# if os.path.isdir(dataSrc):
# shutil.copytree(dataSrc, workingDirDest)
# else:
# shutil.copy(dataSrc, workingDirDest)
#
# def clearWorkingDirectory(self):
# for entry in os.listdir(self.getWorkingDir()):
# fullPath = os.path.join(self.getWorkingDir(), entry)
# if os.path.isfile(fullPath):
# # If file is readonly, make it writable
# if not os.access(fullPath, os.W_OK):
# os.chmod(fullPath, stat.S_IWRITE)
# os.remove(fullPath)
# elif os.path.isdir(fullPath):
# shutil.rmtree(fullPath, onerror=_remove_readonly)
#
# Path: vimswitch/Application.py
# class Application:
# """
# A container for components that are used application-wide.
#
# Examples of how this class can be used:
#
# - Set a component
# `app.foo = myFoo`
#
# - Get (or create) a component:
# `foo = app.get('foo', Foo())`
# This will try to return `app.foo`. If that does not exist, then it will
# set `app.foo = Foo()` and return that instead.
#
# - Get an already created component
# `foo = app.foo`
# Use this when you are sure that app.foo has already been set
# """
#
# def get(self, attr, default):
# """
# Returns self.attr. If attr does not exist, then make self.attr = default
# and then return default.
# """
# if hasattr(self, attr):
# return getattr(self, attr)
# else:
# setattr(self, attr, default)
# return default
#
# Path: vimswitch/GithubZipballExtractor.py
# def getGithubZipballExtractor(app):
# return app.get('githubZipballExtractor', createGithubZipballExtractor(app))
, which may include functions, classes, or code. Output only the next line. | self.githubZipballExtractor.extractZipball(zipballPath, extractionDirPath) |
Based on the snippet: <|code_start|>
class TestGithubZipballExtractor(FileSystemTestCase):
def setUp(self):
FileSystemTestCase.setUp(self)
app = Application()
self.githubZipballExtractor = getGithubZipballExtractor(app)
self.diskIo = app.diskIo
def test_extract_extractsRepoFilesIntoPath(self):
self.copyDataToWorkingDir('vimrc-master.zip', 'zipball.zip')
<|code_end|>
, predict the immediate next line with the help of imports:
from .FileSystemTestCase import FileSystemTestCase
from vimswitch.Application import Application
from vimswitch.GithubZipballExtractor import getGithubZipballExtractor
and context (classes, functions, sometimes code) from other files:
# Path: vimswitch/test/FileSystemTestCase.py
# class FileSystemTestCase(BaseTestCase):
# """
# Inherit from this class when a unit test needs to access the disk. This
# class sets up a sandbox so that disk modifications only occur within a
# working directory. This keeps test code from affecting other files on the
# system.
#
# To get a path relative to the working directory use getTestPath(). To get a
# path to test data use getDataPath().
#
# The working directory is cleared after every test so there is no need to do
# it manually within your tests.
# """
#
# def setUp(self):
# self.sandbox = FileSystemSandbox()
# self.sandbox.enable(self.getWorkingDir())
# self.clearWorkingDirectory()
#
# def tearDown(self):
# self.clearWorkingDirectory()
# self.sandbox.disable()
#
# @classmethod
# def getMyDir(self):
# return os.path.dirname(__file__)
#
# @classmethod
# def getTestPath(self, path):
# "Returns path prepended by the working directory"
# fullPath = os.path.join(self.getWorkingDir(), path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getDataPath(self, path):
# "Returns path prepended by the test data directory"
# dataDir = 'data'
# fullPath = os.path.join(self.getMyDir(), dataDir, path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getWorkingDir(self):
# """"Returns the path to a directory where we can safely create files and
# directories during tests"""
# dirName = 'workingDir'
# return os.path.join(self.getMyDir(), dirName)
#
# def copyDataToWorkingDir(self, dataSrc, workingDirDest):
# "Copies a file or dir from the data directory to the working directory"
# dataSrc = self.getDataPath(dataSrc)
# workingDirDest = self.getTestPath(workingDirDest)
# if os.path.isdir(dataSrc):
# shutil.copytree(dataSrc, workingDirDest)
# else:
# shutil.copy(dataSrc, workingDirDest)
#
# def clearWorkingDirectory(self):
# for entry in os.listdir(self.getWorkingDir()):
# fullPath = os.path.join(self.getWorkingDir(), entry)
# if os.path.isfile(fullPath):
# # If file is readonly, make it writable
# if not os.access(fullPath, os.W_OK):
# os.chmod(fullPath, stat.S_IWRITE)
# os.remove(fullPath)
# elif os.path.isdir(fullPath):
# shutil.rmtree(fullPath, onerror=_remove_readonly)
#
# Path: vimswitch/Application.py
# class Application:
# """
# A container for components that are used application-wide.
#
# Examples of how this class can be used:
#
# - Set a component
# `app.foo = myFoo`
#
# - Get (or create) a component:
# `foo = app.get('foo', Foo())`
# This will try to return `app.foo`. If that does not exist, then it will
# set `app.foo = Foo()` and return that instead.
#
# - Get an already created component
# `foo = app.foo`
# Use this when you are sure that app.foo has already been set
# """
#
# def get(self, attr, default):
# """
# Returns self.attr. If attr does not exist, then make self.attr = default
# and then return default.
# """
# if hasattr(self, attr):
# return getattr(self, attr)
# else:
# setattr(self, attr, default)
# return default
#
# Path: vimswitch/GithubZipballExtractor.py
# def getGithubZipballExtractor(app):
# return app.get('githubZipballExtractor', createGithubZipballExtractor(app))
. Output only the next line. | zipballPath = self.getTestPath('zipball.zip') |
Here is a snippet: <|code_start|>
class ShowVersionAction(Action):
def __init__(self):
Action.__init__(self)
def execute(self):
appVersion = vimswitch.version.__version__
pythonVersion = platform.python_version()
print("vimswitch %s (python %s)" % (appVersion, pythonVersion))
<|code_end|>
. Write the next line using the current file imports:
from .Action import Action
import platform
import vimswitch.version
and context from other files:
# Path: vimswitch/Action.py
# class Action:
# def __init__(self):
# self.exitCode = 0
#
# def execute():
# raise NotImplementedError
, which may include functions, classes, or code. Output only the next line. | def createShowVersionAction(app): |
Based on the snippet: <|code_start|>
def DiskIoStub():
diskIo = MagicMock(DiskIo)
return diskIo
def ProfileDataIoStub():
profileDataIo = MagicMock(ProfileDataIo)
<|code_end|>
, predict the immediate next line with the help of imports:
from mock import MagicMock
from vimswitch.DiskIo import DiskIo
from vimswitch.ProfileDataIo import ProfileDataIo
and context (classes, functions, sometimes code) from other files:
# Path: vimswitch/DiskIo.py
# class DiskIo:
#
# def createFile(self, filePath, contents):
# with open(filePath, 'w') as file:
# file.write(contents)
#
# def getFileContents(self, filePath):
# with open(filePath, 'r') as file:
# return file.read()
#
# def copyFile(self, srcPath, destPath):
# shutil.copy(srcPath, destPath)
#
# def move(self, srcPath, destPath):
# shutil.move(srcPath, destPath)
#
# def deleteFile(self, filePath):
# os.remove(filePath)
#
# def fileExists(self, filePath):
# return os.path.isfile(filePath)
#
# def createDir(self, dirPath):
# return os.mkdir(dirPath)
#
# def createDirWithParents(self, dirPath):
# return os.makedirs(dirPath)
#
# def copyDir(self, srcPath, destPath):
# """
# Recursively copies the src directory to a new dest directory. Creates
# the parent directories of the destination if required.
#
# Raises OSError if the destination directory already exists.
# """
# return shutil.copytree(srcPath, destPath)
#
# def deleteDir(self, dirPath):
# """
# Recursively delete a directory. Read-only files inside the directory
# will also be deleted.
# """
# shutil.rmtree(dirPath, onerror=self._remove_readonly)
#
# def dirExists(self, dirPath):
# return os.path.isdir(dirPath)
#
# def isDirEmpty(self, dirPath):
# return len(os.listdir(dirPath)) == 0
#
# def getDirContents(self, dirPath):
# return os.listdir(dirPath)
#
# def anyExists(self, path):
# return self.fileExists(path) or self.dirExists(path)
#
# def setReadOnly(self, path, readOnly):
# st = os.stat(path)
# if readOnly:
# os.chmod(path, st.st_mode & ~stat.S_IWRITE)
# else:
# os.chmod(path, st.st_mode | stat.S_IWRITE)
#
# def isReadOnly(self, path):
# mode = os.stat(path)[stat.ST_MODE]
# return not mode & stat.S_IWRITE
#
# # Private
#
# def _remove_readonly(self, func, path, excinfo):
# os.chmod(path, stat.S_IWRITE)
# func(path)
#
# Path: vimswitch/ProfileDataIo.py
# class ProfileDataIo:
# def __init__(self, settings, diskIo):
# self.settings = settings
# self.diskIo = diskIo
#
# def delete(self, path):
# """Deletes profile data found at path"""
# for file in self.settings.profileFiles:
# filePath = os.path.join(path, file)
# if self.diskIo.fileExists(filePath):
# self.diskIo.deleteFile(filePath)
#
# for dir in self.settings.profileDirs:
# dirPath = os.path.join(path, dir)
# if self.diskIo.dirExists(dirPath):
# self.diskIo.deleteDir(dirPath)
#
# def copy(self, srcPath, destPath):
# """
# Copies profile data from srcPath to destPath. Will replace existing
# files at destPath.
# """
# for file in self.settings.profileFiles:
# srcFilePath = os.path.join(srcPath, file)
# destFilePath = os.path.join(destPath, file)
# if self.diskIo.fileExists(srcFilePath):
# self.diskIo.copyFile(srcFilePath, destFilePath)
#
# for dir in self.settings.profileDirs:
# srcDirPath = os.path.join(srcPath, dir)
# destDirPath = os.path.join(destPath, dir)
# if self.diskIo.dirExists(srcDirPath):
# self.diskIo.copyDir(srcDirPath, destDirPath)
. Output only the next line. | return profileDataIo |
Continue the code snippet: <|code_start|>
class TestConfigFile(FileSystemTestCase):
def setUp(self):
FileSystemTestCase.setUp(self)
self.app = Application()
self.configFile = getConfigFile(self.app)
# ConfigFile.loadSettings()
def test_loadSettings_allAttributes(self):
self.copyDataToWorkingDir('vimswitchrc', 'vimswitchrc')
configFilePath = self.getTestPath('vimswitchrc')
settings = Settings()
self.configFile.loadSettings(settings, configFilePath)
self.assertEqual(settings.currentProfile, Profile('test/vimrc'))
def test_loadSettings_fileDoesNotExist_settingsUnchanged(self):
nonExistantPath = self.getTestPath('non_existant')
settings = Settings()
settingsCopy = deepcopy(settings)
<|code_end|>
. Use current file imports:
from .FileSystemTestCase import FileSystemTestCase
from copy import deepcopy
from vimswitch.Application import Application
from vimswitch.Profile import Profile
from vimswitch.Settings import Settings
from vimswitch.ConfigFile import getConfigFile
from vimswitch.DiskIo import getDiskIo
import vimswitch.six.moves.configparser as configparser
and context (classes, functions, or code) from other files:
# Path: vimswitch/test/FileSystemTestCase.py
# class FileSystemTestCase(BaseTestCase):
# """
# Inherit from this class when a unit test needs to access the disk. This
# class sets up a sandbox so that disk modifications only occur within a
# working directory. This keeps test code from affecting other files on the
# system.
#
# To get a path relative to the working directory use getTestPath(). To get a
# path to test data use getDataPath().
#
# The working directory is cleared after every test so there is no need to do
# it manually within your tests.
# """
#
# def setUp(self):
# self.sandbox = FileSystemSandbox()
# self.sandbox.enable(self.getWorkingDir())
# self.clearWorkingDirectory()
#
# def tearDown(self):
# self.clearWorkingDirectory()
# self.sandbox.disable()
#
# @classmethod
# def getMyDir(self):
# return os.path.dirname(__file__)
#
# @classmethod
# def getTestPath(self, path):
# "Returns path prepended by the working directory"
# fullPath = os.path.join(self.getWorkingDir(), path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getDataPath(self, path):
# "Returns path prepended by the test data directory"
# dataDir = 'data'
# fullPath = os.path.join(self.getMyDir(), dataDir, path)
# return os.path.normpath(fullPath)
#
# @classmethod
# def getWorkingDir(self):
# """"Returns the path to a directory where we can safely create files and
# directories during tests"""
# dirName = 'workingDir'
# return os.path.join(self.getMyDir(), dirName)
#
# def copyDataToWorkingDir(self, dataSrc, workingDirDest):
# "Copies a file or dir from the data directory to the working directory"
# dataSrc = self.getDataPath(dataSrc)
# workingDirDest = self.getTestPath(workingDirDest)
# if os.path.isdir(dataSrc):
# shutil.copytree(dataSrc, workingDirDest)
# else:
# shutil.copy(dataSrc, workingDirDest)
#
# def clearWorkingDirectory(self):
# for entry in os.listdir(self.getWorkingDir()):
# fullPath = os.path.join(self.getWorkingDir(), entry)
# if os.path.isfile(fullPath):
# # If file is readonly, make it writable
# if not os.access(fullPath, os.W_OK):
# os.chmod(fullPath, stat.S_IWRITE)
# os.remove(fullPath)
# elif os.path.isdir(fullPath):
# shutil.rmtree(fullPath, onerror=_remove_readonly)
#
# Path: vimswitch/Application.py
# class Application:
# """
# A container for components that are used application-wide.
#
# Examples of how this class can be used:
#
# - Set a component
# `app.foo = myFoo`
#
# - Get (or create) a component:
# `foo = app.get('foo', Foo())`
# This will try to return `app.foo`. If that does not exist, then it will
# set `app.foo = Foo()` and return that instead.
#
# - Get an already created component
# `foo = app.foo`
# Use this when you are sure that app.foo has already been set
# """
#
# def get(self, attr, default):
# """
# Returns self.attr. If attr does not exist, then make self.attr = default
# and then return default.
# """
# if hasattr(self, attr):
# return getattr(self, attr)
# else:
# setattr(self, attr, default)
# return default
#
# Path: vimswitch/Profile.py
# class Profile:
# def __init__(self, name):
# self.name = name
#
# def getName(self):
# return self.name
#
# def getDirName(self):
# return self.name.replace('/', '.')
#
# def __eq__(self, other):
# return isinstance(other, Profile) and self.name == other.name
#
# def __ne__(self, other):
# return not self.__eq__(other)
#
# def __repr__(self):
# return "Profile('%s')" % self.name
#
# Path: vimswitch/Settings.py
# class Settings:
#
# def __init__(self, homePath=''):
# """
# homePath is used as the prefix for all other paths. If homePath is not
# specified it gets set to the user's home directory.
# """
# self.homePath = homePath or os.path.expanduser('~')
# self.configPath = os.path.join(self.homePath, '.vimswitch')
# self.configFilePath = os.path.join(self.configPath, 'vimswitchrc')
# self.cachePath = os.path.join(self.configPath, 'profiles')
# self.downloadsPath = os.path.join(self.configPath, 'downloads')
# self.profileFiles = ['.vimrc', '_vimrc']
# self.profileDirs = ['.vim', '_vim']
# self.defaultProfile = Profile('default')
# self.currentProfile = None
#
# def __eq__(self, other):
# return self.__dict__ == other.__dict__
#
# Path: vimswitch/ConfigFile.py
# def getConfigFile(app):
# return app.get('configFile', createConfigFile(app))
#
# Path: vimswitch/DiskIo.py
# def getDiskIo(app):
# return app.get('diskIo', createDiskIo(app))
. Output only the next line. | self.configFile.loadSettings(settings, nonExistantPath) |
Predict the next line for this snippet: <|code_start|>
class UpdateProfileAction(Action):
def __init__(self, settings, switchProfileAction):
Action.__init__(self)
self.settings = settings
self.switchProfileAction = switchProfileAction
self.profile = None
<|code_end|>
with the help of current file imports:
from .Action import Action
from .Settings import getSettings
from .SwitchProfileAction import createSwitchProfileAction
and context from other files:
# Path: vimswitch/Action.py
# class Action:
# def __init__(self):
# self.exitCode = 0
#
# def execute():
# raise NotImplementedError
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
#
# Path: vimswitch/SwitchProfileAction.py
# def createSwitchProfileAction(app):
# settings = getSettings(app)
# profileCache = getProfileCache(app)
# profileCopier = getProfileCopier(app)
# profileRetriever = getProfileRetriever(app)
# switchProfileAction = SwitchProfileAction(settings, profileCache, profileCopier, profileRetriever)
# return switchProfileAction
, which may contain function names, class names, or code. Output only the next line. | def execute(self): |
Next line prediction: <|code_start|> Action.__init__(self)
self.settings = settings
self.switchProfileAction = switchProfileAction
self.profile = None
def execute(self):
self.profile = self._getProfile()
if self.profile == self.settings.defaultProfile:
print('Cannot update default profile')
self.exitCode = -1
return
self.switchProfileAction.update = True
self.switchProfileAction.profile = self.profile
self.switchProfileAction.execute()
def _getProfile(self):
if self.profile is None:
if self.settings.currentProfile is None:
return self.settings.defaultProfile
else:
return self.settings.currentProfile
else:
return self.profile
def createUpdateProfileAction(app):
settings = getSettings(app)
switchProfileAction = createSwitchProfileAction(app)
<|code_end|>
. Use current file imports:
(from .Action import Action
from .Settings import getSettings
from .SwitchProfileAction import createSwitchProfileAction)
and context including class names, function names, or small code snippets from other files:
# Path: vimswitch/Action.py
# class Action:
# def __init__(self):
# self.exitCode = 0
#
# def execute():
# raise NotImplementedError
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
#
# Path: vimswitch/SwitchProfileAction.py
# def createSwitchProfileAction(app):
# settings = getSettings(app)
# profileCache = getProfileCache(app)
# profileCopier = getProfileCopier(app)
# profileRetriever = getProfileRetriever(app)
# switchProfileAction = SwitchProfileAction(settings, profileCache, profileCopier, profileRetriever)
# return switchProfileAction
. Output only the next line. | updateProfileAction = UpdateProfileAction(settings, switchProfileAction) |
Given the code snippet: <|code_start|>
class UpdateProfileAction(Action):
def __init__(self, settings, switchProfileAction):
Action.__init__(self)
self.settings = settings
self.switchProfileAction = switchProfileAction
self.profile = None
def execute(self):
self.profile = self._getProfile()
if self.profile == self.settings.defaultProfile:
print('Cannot update default profile')
self.exitCode = -1
return
self.switchProfileAction.update = True
self.switchProfileAction.profile = self.profile
self.switchProfileAction.execute()
<|code_end|>
, generate the next line using the imports in this file:
from .Action import Action
from .Settings import getSettings
from .SwitchProfileAction import createSwitchProfileAction
and context (functions, classes, or occasionally code) from other files:
# Path: vimswitch/Action.py
# class Action:
# def __init__(self):
# self.exitCode = 0
#
# def execute():
# raise NotImplementedError
#
# Path: vimswitch/Settings.py
# def getSettings(app):
# return app.get('settings', createSettings(app))
#
# Path: vimswitch/SwitchProfileAction.py
# def createSwitchProfileAction(app):
# settings = getSettings(app)
# profileCache = getProfileCache(app)
# profileCopier = getProfileCopier(app)
# profileRetriever = getProfileRetriever(app)
# switchProfileAction = SwitchProfileAction(settings, profileCache, profileCopier, profileRetriever)
# return switchProfileAction
. Output only the next line. | def _getProfile(self): |
Given the following code snippet before the placeholder: <|code_start|>
class InvalidArgsAction(Action):
def __init__(self):
Action.__init__(self)
self.errorMessage = ''
<|code_end|>
, predict the next line using imports from the current file:
from .Action import Action
and context including class names, function names, and sometimes code from other files:
# Path: vimswitch/Action.py
# class Action:
# def __init__(self):
# self.exitCode = 0
#
# def execute():
# raise NotImplementedError
. Output only the next line. | self.helpText = '' |
Given the code snippet: <|code_start|>
def test_copyToHome_deletesHomeData(self):
self.profileCopier.copyToHome(self.profile)
homePath = os.path.normpath('/home/foo')
self.profileDataIo.delete.assert_called_with(homePath)
def test_copyToHome_deletesHomeDir_fromSettings(self):
self.settings.homePath = 'testHomeDir'
self.profileCopier.copyToHome(self.profile)
self.profileDataIo.delete.assert_called_with(os.path.normpath('testHomeDir'))
def test_copyToHome_copiesFromProfileToHome(self):
self.profileCopier.copyToHome(self.profile)
profilePath = os.path.normpath('/home/foo/.vimswitch/profiles/test.vimrc')
homePath = os.path.normpath('/home/foo')
self.profileDataIo.copy.assert_called_with(profilePath, homePath)
def test_copyToHome_copiesFromCacheDir_fromSettings(self):
self.settings.cachePath = 'testCachePath'
self.profileCopier.copyToHome(self.profile)
profilePath = os.path.normpath('testCachePath/test.vimrc')
homePath = os.path.normpath('/home/foo')
self.profileDataIo.copy.assert_called_with(profilePath, homePath)
<|code_end|>
, generate the next line using the imports in this file:
from . import Stubs
from .BaseTestCase import BaseTestCase
from mock import MagicMock
from vimswitch.Profile import Profile
from vimswitch.ProfileCache import ProfileCache
from vimswitch.ProfileCopier import ProfileCopier
from vimswitch.Settings import Settings
import os
and context (functions, classes, or occasionally code) from other files:
# Path: vimswitch/test/BaseTestCase.py
# class BaseTestCase(unittest.TestCase):
# def __init__(self, *args, **kwargs):
# unittest.TestCase.__init__(self, *args, **kwargs)
#
# # Python < 3.2 does not have assertNotRegex
# if not hasattr(self, 'assertNotRegex'):
# self.assertNotRegex = self.assertNotRegexpMatches
#
# def assertMultilineRegexpMatches(self, string, regexp):
# """
# Asserts that the entirety of `string` matches `regexp`. `regexp` can be
# a multiline string with indentation.
# """
# regexp = textwrap.dedent(regexp)
# regexp = regexp.strip()
# regexp = '^' + regexp + '$'
# regexp = re.compile(regexp, re.DOTALL)
#
# self.assertRegexpMatches(string, regexp)
#
# def assertStdout(self, stdout, regexp):
# "Asserts that the `stdout` io stream matches `regexp`"
# stdoutText = stdout.getvalue().strip()
# self.assertMultilineRegexpMatches(stdoutText, regexp)
#
# def resetStdout(self, stdout):
# stdout.seek(0)
# stdout.truncate(0)
#
# Path: vimswitch/Profile.py
# class Profile:
# def __init__(self, name):
# self.name = name
#
# def getName(self):
# return self.name
#
# def getDirName(self):
# return self.name.replace('/', '.')
#
# def __eq__(self, other):
# return isinstance(other, Profile) and self.name == other.name
#
# def __ne__(self, other):
# return not self.__eq__(other)
#
# def __repr__(self):
# return "Profile('%s')" % self.name
#
# Path: vimswitch/ProfileCache.py
# class ProfileCache:
# def __init__(self, settings, diskIo):
# self.settings = settings
# self.diskIo = diskIo
#
# def contains(self, profile):
# profileLocation = self.getProfileLocation(profile)
# return self.diskIo.dirExists(profileLocation)
#
# def delete(self, profile):
# profileDirPath = self.getProfileLocation(profile)
# self.diskIo.deleteDir(profileDirPath)
#
# def getProfileLocation(self, profile):
# """Returns the path where profile is located"""
# fullPath = os.path.join(self.settings.cachePath, profile.getDirName())
# return os.path.normpath(fullPath)
#
# def createEmptyProfile(self, profile):
# location = self.getProfileLocation(profile)
# self.diskIo.createDir(location)
#
# Path: vimswitch/ProfileCopier.py
# class ProfileCopier:
# def __init__(self, settings, profileCache, profileDataIo):
# self.settings = settings
# self.profileCache = profileCache
# self.profileDataIo = profileDataIo
#
# def copyToHome(self, profile):
# """
# Copies the cached profile to home, thus making it active
# """
# # TODO: If profileDataIo.copy fails, then we are left with an empty
# # profile at home. So we should use the 'operate on temp then rename'
# # pattern
# homePath = self.settings.homePath
# profilePath = self.profileCache.getProfileLocation(profile)
# self.profileDataIo.delete(homePath)
# self.profileDataIo.copy(profilePath, homePath)
#
# def copyFromHome(self, profile):
# """
# Copies the active profile data at home to a specified profile in cache.
# If the profile already exists in cache, it gets overwritten.
# """
# if not self.profileCache.contains(profile):
# self.profileCache.createEmptyProfile(profile)
# profilePath = self.profileCache.getProfileLocation(profile)
# homePath = self.settings.homePath
# self.profileDataIo.delete(profilePath)
# self.profileDataIo.copy(homePath, profilePath)
#
# Path: vimswitch/Settings.py
# class Settings:
#
# def __init__(self, homePath=''):
# """
# homePath is used as the prefix for all other paths. If homePath is not
# specified it gets set to the user's home directory.
# """
# self.homePath = homePath or os.path.expanduser('~')
# self.configPath = os.path.join(self.homePath, '.vimswitch')
# self.configFilePath = os.path.join(self.configPath, 'vimswitchrc')
# self.cachePath = os.path.join(self.configPath, 'profiles')
# self.downloadsPath = os.path.join(self.configPath, 'downloads')
# self.profileFiles = ['.vimrc', '_vimrc']
# self.profileDirs = ['.vim', '_vim']
# self.defaultProfile = Profile('default')
# self.currentProfile = None
#
# def __eq__(self, other):
# return self.__dict__ == other.__dict__
. Output only the next line. | def test_copyToHome_copiesToHomeDir_fromSettings(self): |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.