Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Predict the next line after this snippet: <|code_start|>
def test_normalize_language_explanation():
#for s in [' X [aaa]', 'L [aaa] = "X"', 'X = L [aaa]']:
# assert normalize_language_explanation(s) == 'X [aaa]'
assert normalize_language_explanation(' abcdefg') == 'abcdefg'
def test_ModelInstance():
mi = ModelInstance(Doctype)
<|code_end|>
using the current file's imports:
import pytest
import colander
from glottolog3.models import Doctype
from glottolog3.util import normalize_language_explanation, ModelInstance
and any relevant context from other files:
# Path: glottolog3/models.py
# class Doctype(Base, IdNameDescriptionMixin):
# """
# id -> pk
# id -> id
# abbr -> abbr
# name -> name
# """
# abbr = Column(Unicode)
#
# ord = Column(Integer)
#
# def __str__(self):
# return capwords(self.name.replace('_', ' '))
#
# Path: glottolog3/util.py
# def normalize_language_explanation(chunk):
# """
# i) X [aaa]
# ii) L [aaa] = "X"
# iii) X = L [aaa]
#
# :return: X [aaa]
# """
# if '[' in chunk and not chunk.endswith(']'):
# chunk += ']'
# chunk = chunk.strip()
# if '=' not in chunk:
# return chunk
# chunks = chunk.split('=')
# left = '='.join(chunks[:-1]).strip()
# right = chunks[-1].strip()
# if right.startswith('"') and right.endswith('"') and '[' not in right and '[' in left:
# # case ii)
# return right[1:-1].strip() + ' [' + left.split('[', 1)[1]
# if '[' in right and '[' not in left:
# # case iii)
# return left + ' [' + right.split('[', 1)[1]
# return chunk
#
# class ModelInstance(object):
# def __init__(self, cls, attr='id', collection=None, alias=None):
# self.cls = cls
# self.attr = attr
# self.alias = alias
# self.collection = collection
#
# def serialize(self, node, appstruct):
# if appstruct is colander.null:
# return colander.null
# if self.cls and not isinstance(appstruct, self.cls):
# raise colander.Invalid(node, '%r is not a %s' % (appstruct, self.cls))
# return getattr(appstruct, self.attr)
#
# def deserialize(self, node, cstruct):
# if cstruct is colander.null:
# return colander.null
# value = None
# if self.collection:
# for obj in self.collection:
# if getattr(obj, self.attr) == cstruct \
# or (self.alias and getattr(obj, self.alias) == cstruct):
# value = obj
# else:
# value = self.cls.get(cstruct, key=self.attr, default=None) if self.cls else cstruct
# if self.alias and value is None:
# value = self.cls.get(cstruct, key=self.alias, default=None) if self.cls else cstruct
# if value is None:
# raise colander.Invalid(node, 'no single result found')
# return value
#
# def cstruct_children(self, node, cstruct): # pragma: no cover
# return []
. Output only the next line. | assert mi.serialize(None, colander.null) == colander.null |
Predict the next line for this snippet: <|code_start|>
TEST_DB = 'glottolog3-test'
@pytest.fixture
def repos():
return pathlib.Path(__file__).parent / 'repos'
@pytest.fixture
def testdb(mocker):
subprocess.check_call(['dropdb', '-U', 'postgres', '--if-exists', TEST_DB])
subprocess.check_call(['createdb', '-U', 'postgres', TEST_DB])
engine = create_engine('postgresql://postgres@/' + TEST_DB)
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
yield DBSession
close_all_sessions()
<|code_end|>
with the help of current file imports:
import logging
import pathlib
import subprocess
import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import close_all_sessions
from clld.db.meta import DBSession, Base
from glottolog3 import models
from glottolog3.__main__ import main
from glottolog3.scripts import check_db_consistency
from glottolog3.scripts import initializedb
and context from other files:
# Path: glottolog3/models.py
# def get_parameter(pid):
# def get_source(key):
# def github_url(self):
# def __str__(self):
# def get_stats(cls):
# def get_identifier_objs(self, type_):
# def get_ancestors(self, session=None):
# def github_url(self):
# def __json__(self, req=None, core=False):
# def ancestor(l):
# def get_geocoords(self):
# def valueset_dict(self):
# def classification(self, type_):
# def fc(self):
# def sc(self):
# def _crefs(self, t):
# def crefs(self):
# def screfs(self):
# def __rdf__(self, request):
# def jqtree(self, icon_map=None):
# def __rdf__(self, request):
# def __bibtex__(self):
# def url(self, req):
# class Provider(Base, IdNameDescriptionMixin):
# class Doctype(Base, IdNameDescriptionMixin):
# class Refdoctype(Base):
# class Refprovider(Base):
# class LanguoidLevel(DeclEnum):
# class Languoid(CustomModelMixin, Language):
# class Ref(CustomModelMixin, Source):
# class TreeClosureTable(Base):
# class LegacyCode(Base):
# GLOTTOLOG_NAME = u'glottolog'
#
# Path: glottolog3/__main__.py
# def main(args=None, catch_all=False, parsed_args=None, log=None):
# try:
# repos = Config.from_file().get_clone('glottolog')
# except KeyError: # pragma: no cover
# repos = pathlib.Path('.')
# parser, subparsers = get_parser_and_subparsers('glottolog3')
# parser.add_argument(
# '--repos',
# help="clone of glottolog/glottolog",
# default=repos,
# type=pathlib.Path)
# parser.add_argument(
# '--repos-version',
# help="version of repository data. Requires a git clone!",
# default=None)
# parser.add_argument(
# '--pkg-dir',
# help=argparse.SUPPRESS,
# default=pathlib.Path(__file__).parent)
# register_subcommands(subparsers, glottolog3.commands)
#
# args = parsed_args or parser.parse_args(args=args)
#
# if not hasattr(args, "main"): # pragma: no cover
# parser.print_help()
# return 1
#
# with contextlib.ExitStack() as stack:
# if not log: # pragma: no cover
# stack.enter_context(Logging(args.log, level=args.log_level))
# else:
# args.log = log
# if args.repos_version: # pragma: no cover
# # If a specific version of the data is to be used, we make
# # use of a Catalog as context manager:
# stack.enter_context(Catalog(args.repos, tag=args.repos_version))
# args.repos = Glottolog(args.repos)
# args.log.info('glottolog/glottolog at {0}'.format(args.repos.repos))
# try:
# return args.main(args) or 0
# except KeyboardInterrupt: # pragma: no cover
# return 0
# except ParserError as e: # pragma: no cover
# print(e)
# return main([args._command, '-h'])
# except Exception as e: # pragma: no cover
# if catch_all:
# print(e)
# return 1
# raise
, which may contain function names, class names, or code. Output only the next line. | DBSession.remove() |
Given the following code snippet before the placeholder: <|code_start|>
TEST_DB = 'glottolog3-test'
@pytest.fixture
def repos():
return pathlib.Path(__file__).parent / 'repos'
@pytest.fixture
def testdb(mocker):
subprocess.check_call(['dropdb', '-U', 'postgres', '--if-exists', TEST_DB])
subprocess.check_call(['createdb', '-U', 'postgres', TEST_DB])
engine = create_engine('postgresql://postgres@/' + TEST_DB)
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
yield DBSession
close_all_sessions()
DBSession.remove()
engine.dispose()
<|code_end|>
, predict the next line using imports from the current file:
import logging
import pathlib
import subprocess
import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import close_all_sessions
from clld.db.meta import DBSession, Base
from glottolog3 import models
from glottolog3.__main__ import main
from glottolog3.scripts import check_db_consistency
from glottolog3.scripts import initializedb
and context including class names, function names, and sometimes code from other files:
# Path: glottolog3/models.py
# def get_parameter(pid):
# def get_source(key):
# def github_url(self):
# def __str__(self):
# def get_stats(cls):
# def get_identifier_objs(self, type_):
# def get_ancestors(self, session=None):
# def github_url(self):
# def __json__(self, req=None, core=False):
# def ancestor(l):
# def get_geocoords(self):
# def valueset_dict(self):
# def classification(self, type_):
# def fc(self):
# def sc(self):
# def _crefs(self, t):
# def crefs(self):
# def screfs(self):
# def __rdf__(self, request):
# def jqtree(self, icon_map=None):
# def __rdf__(self, request):
# def __bibtex__(self):
# def url(self, req):
# class Provider(Base, IdNameDescriptionMixin):
# class Doctype(Base, IdNameDescriptionMixin):
# class Refdoctype(Base):
# class Refprovider(Base):
# class LanguoidLevel(DeclEnum):
# class Languoid(CustomModelMixin, Language):
# class Ref(CustomModelMixin, Source):
# class TreeClosureTable(Base):
# class LegacyCode(Base):
# GLOTTOLOG_NAME = u'glottolog'
#
# Path: glottolog3/__main__.py
# def main(args=None, catch_all=False, parsed_args=None, log=None):
# try:
# repos = Config.from_file().get_clone('glottolog')
# except KeyError: # pragma: no cover
# repos = pathlib.Path('.')
# parser, subparsers = get_parser_and_subparsers('glottolog3')
# parser.add_argument(
# '--repos',
# help="clone of glottolog/glottolog",
# default=repos,
# type=pathlib.Path)
# parser.add_argument(
# '--repos-version',
# help="version of repository data. Requires a git clone!",
# default=None)
# parser.add_argument(
# '--pkg-dir',
# help=argparse.SUPPRESS,
# default=pathlib.Path(__file__).parent)
# register_subcommands(subparsers, glottolog3.commands)
#
# args = parsed_args or parser.parse_args(args=args)
#
# if not hasattr(args, "main"): # pragma: no cover
# parser.print_help()
# return 1
#
# with contextlib.ExitStack() as stack:
# if not log: # pragma: no cover
# stack.enter_context(Logging(args.log, level=args.log_level))
# else:
# args.log = log
# if args.repos_version: # pragma: no cover
# # If a specific version of the data is to be used, we make
# # use of a Catalog as context manager:
# stack.enter_context(Catalog(args.repos, tag=args.repos_version))
# args.repos = Glottolog(args.repos)
# args.log.info('glottolog/glottolog at {0}'.format(args.repos.repos))
# try:
# return args.main(args) or 0
# except KeyboardInterrupt: # pragma: no cover
# return 0
# except ParserError as e: # pragma: no cover
# print(e)
# return main([args._command, '-h'])
# except Exception as e: # pragma: no cover
# if catch_all:
# print(e)
# return 1
# raise
. Output only the next line. | subprocess.check_call(['dropdb', '-U', 'postgres', '--if-exists', TEST_DB]) |
Next line prediction: <|code_start|>
__all__ = ['get_releases', 'get_release']
def get_releases(args):
cfg = configparser.ConfigParser(interpolation=configparser.ExtendedInterpolation())
<|code_end|>
. Use current file imports:
(import configparser
from glottolog3.releases import Release)
and context including class names, function names, or small code snippets from other files:
# Path: glottolog3/releases.py
# class Release:
# tag = attr.ib()
# version = attr.ib()
# cdstar_oid = attr.ib()
# sql_dump_md5 = attr.ib()
# sql_dump_url = attr.ib()
#
# @classmethod
# def from_config(cls, cfg, section):
# return cls(tag=section, **cfg[section])
#
# def dump_fname(self, zipped=False):
# return pathlib.Path('glottolog-{0}.sql{1}'.format(self.version, '.gz' if zipped else ''))
#
# def download_sql_dump(self, log):
# target = self.dump_fname(zipped=True)
# log.info('retrieving {0}'.format(self.sql_dump_url))
# urlretrieve(self.sql_dump_url, str(target))
# assert md5(target) == self.sql_dump_md5
# unpacked = target.with_suffix('')
# with gzip.open(str(target)) as f, unpacked.open('wb') as u:
# shutil.copyfileobj(f, u)
# target.unlink()
# log.info('SQL dump for Glottolog release {0} written to {1}'.format(self.version, unpacked))
#
# def load_sql_dump(self, log):
# dump = self.dump_fname()
# dbname = dump.stem
# db = DB('postgresql://postgres@/{0.stem}'.format(dump))
#
# if db.exists():
# log.warn('db {0} exists! Drop first to recreate.'.format(dump.stem))
# else:
# if not dump.exists():
# self.download_sql_dump(log)
# db.create()
# subprocess.check_call(['psql', '-d', dbname, '-f', str(dump)])
# log.info('db {0} created'.format(dbname))
. Output only the next line. | with args.pkg_dir.joinpath('releases.ini').open(encoding='utf-8') as f: |
Next line prediction: <|code_start|>
class Language(object):
def __init__(self, pk, name, longitude, latitude, id_):
self.pk = pk
self.name = name
self.longitude = longitude
self.latitude = latitude
self.id = id_
def __json__(self, req):
return self.__dict__
class LanguoidGeoJson(GeoJson):
def __init__(self, obj, icon_map=None):
super(LanguoidGeoJson, self).__init__(obj)
self.icon_map = icon_map or {}
def feature_iterator(self, ctx, req):
res = [(ctx.pk, ctx.name, ctx.longitude, ctx.latitude, ctx.id)] \
if ctx.latitude else []
return res + list(ctx.get_geocoords())
def featurecollection_properties(self, ctx, req):
<|code_end|>
. Use current file imports:
(from clld.web.maps import Map, Layer, Legend
from clld.web.adapters.geojson import GeoJson
from clld.web.util.htmllib import HTML, literal
from glottolog3.models import LanguoidLevel
from glottolog3.util import languoid_link)
and context including class names, function names, or small code snippets from other files:
# Path: glottolog3/models.py
# class LanguoidLevel(DeclEnum):
# family = 'family', 'family'
# language = 'language', 'language'
# dialect = 'dialect', 'dialect'
. Output only the next line. | return {'layer': getattr(ctx, 'id', '')} |
Given snippet: <|code_start|> QMessageBox.Ok)
return
self.fileBox.clear()
for xml in all_xmls:
self.fileBox.addItem(xml)
self.btnRun.setEnabled(True)
def run(self):
dlg = LandXMLtoTinDialog(self.dir_names, self.dir_paths, self.fileBox.currentText(),
self.overwriteBox.isChecked())
dlg.exec_()
class MxdToPng(QWidget):
def __init__(self):
super().__init__()
self.dir_names = []
self.dir_paths = []
self._initWidgets()
self._setLayout()
self.btnOpen.clicked.connect(self.btnOpenEvent)
self.btnRun.clicked.connect(self.carto)
self.setWindowTitle('Convertir .mxd en images')
def _initWidgets(self):
# create the open button
self.btnOpen = QPushButton('Ouvrir', self, icon=self.style().standardIcon(QStyle.SP_DialogOpenButton))
self.btnOpen.setToolTip('<b>Ouvrir</b> des fichiers .xml')
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import sys
import os
import uuid
import shutil
import subprocess
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QColor
from PyQt5.QtWidgets import (QAbstractItemView, QApplication, QCheckBox, QComboBox, QDialog, QDialogButtonBox,
QFileDialog, QGroupBox, QHBoxLayout, QLabel, QLineEdit, QMessageBox, QPushButton,
QRadioButton, QSpacerItem, QStyle, QTableWidget, QTableWidgetItem, QVBoxLayout, QWidget)
from pyteltools.conf import settings
from pyteltools.gui.util import MultiFolderDialog
from pyteltools.utils.log import new_logger
and context:
# Path: pyteltools/gui/util.py
# class MultiFolderDialog(QFileDialog):
# """
# Dialog to select one or more folders
# """
# def __init__(self, title, multi_selection=True):
# super().__init__()
# self.setWindowTitle(title)
# self.setFileMode(QFileDialog.DirectoryOnly)
# self.setOption(QFileDialog.DontUseNativeDialog, True)
# if multi_selection:
# file_view = self.findChild(QListView, 'listView')
# if file_view:
# file_view.setSelectionMode(QAbstractItemView.MultiSelection)
# self.tree = self.findChild(QTreeView)
# if multi_selection and self.tree:
# self.tree.setSelectionMode(QAbstractItemView.MultiSelection)
#
# Path: pyteltools/utils/log.py
# def new_logger(name):
# """!
# Get a new logger
# @param name <str>: logger name
# """
# logger = logging.getLogger(name)
# if settings.COLOR_LOGS:
# coloredlogs.install(logger=logger, level=settings.LOGGING_LEVEL, fmt=settings.LOGGING_FMT_CLI,
# level_styles=LEVEL_STYLES, field_styles=FIELD_STYLES)
# else:
# handler = logging.StreamHandler()
# handler.setFormatter(logging.Formatter(settings.LOGGING_FMT_CLI))
# logger.addHandler(handler)
# logger.setLevel(settings.LOGGING_LEVEL)
# return logger
which might include code, classes, or functions. Output only the next line. | self.btnOpen.setFixedSize(105, 50) |
Predict the next line for this snippet: <|code_start|> self.png_path = png_path
self.overwrite = overwrite
self.table = QTableWidget()
self.table.setRowCount(len(dir_names))
self.table.setColumnCount(2)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table.horizontalHeader().setDefaultSectionSize(100)
self.table.setHorizontalHeaderLabels(['dossier', 'png'])
yellow = QColor(245, 255, 207, 255)
for i, name in enumerate(dir_names):
self.table.setItem(i, 0, QTableWidgetItem(name))
self.table.setItem(i, 1, QTableWidgetItem(''))
self.table.item(i, 1).setBackground(yellow)
self.btnClose = QPushButton('Fermer', None)
self.btnClose.setEnabled(False)
self.btnClose.setFixedSize(120, 30)
self.btnClose.clicked.connect(self.accept)
vlayout = QVBoxLayout()
vlayout.addWidget(QLabel("Patientez jusqu'à ce que toutes les cases jaunes deviennet vertes..."))
vlayout.addWidget(self.table)
vlayout.addStretch()
vlayout.addWidget(self.btnClose, Qt.AlignRight)
self.setLayout(vlayout)
self.resize(500, 300)
<|code_end|>
with the help of current file imports:
import sys
import os
import uuid
import shutil
import subprocess
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QColor
from PyQt5.QtWidgets import (QAbstractItemView, QApplication, QCheckBox, QComboBox, QDialog, QDialogButtonBox,
QFileDialog, QGroupBox, QHBoxLayout, QLabel, QLineEdit, QMessageBox, QPushButton,
QRadioButton, QSpacerItem, QStyle, QTableWidget, QTableWidgetItem, QVBoxLayout, QWidget)
from pyteltools.conf import settings
from pyteltools.gui.util import MultiFolderDialog
from pyteltools.utils.log import new_logger
and context from other files:
# Path: pyteltools/gui/util.py
# class MultiFolderDialog(QFileDialog):
# """
# Dialog to select one or more folders
# """
# def __init__(self, title, multi_selection=True):
# super().__init__()
# self.setWindowTitle(title)
# self.setFileMode(QFileDialog.DirectoryOnly)
# self.setOption(QFileDialog.DontUseNativeDialog, True)
# if multi_selection:
# file_view = self.findChild(QListView, 'listView')
# if file_view:
# file_view.setSelectionMode(QAbstractItemView.MultiSelection)
# self.tree = self.findChild(QTreeView)
# if multi_selection and self.tree:
# self.tree.setSelectionMode(QAbstractItemView.MultiSelection)
#
# Path: pyteltools/utils/log.py
# def new_logger(name):
# """!
# Get a new logger
# @param name <str>: logger name
# """
# logger = logging.getLogger(name)
# if settings.COLOR_LOGS:
# coloredlogs.install(logger=logger, level=settings.LOGGING_LEVEL, fmt=settings.LOGGING_FMT_CLI,
# level_styles=LEVEL_STYLES, field_styles=FIELD_STYLES)
# else:
# handler = logging.StreamHandler()
# handler.setFormatter(logging.Formatter(settings.LOGGING_FMT_CLI))
# logger.addHandler(handler)
# logger.setLevel(settings.LOGGING_LEVEL)
# return logger
, which may contain function names, class names, or code. Output only the next line. | self.setWindowTitle('Produire les cartes sous format PNG') |
Given the code snippet: <|code_start|>
class SerafinData:
def __init__(self, job_id, filename, language):
self.job_id = job_id
self.language = language
self.filename = filename
self.index = None
self.triangles = {}
self.header = None
self.time = [] # <[float]>
self.time_second = [] # <[datetime.timedelta]> FIXME: should be renamed differently!
self.start_time = None
self.selected_vars = []
self.selected_vars_names = {}
self.selected_time_indices = []
self.equations = []
<|code_end|>
, generate the next line using the imports in this file:
from copy import deepcopy
from . import Serafin
from .util import logger
import datetime
and context (functions, classes, or occasionally code) from other files:
# Path: pyteltools/slf/util.py
. Output only the next line. | self.us_equation = None |
Using the snippet: <|code_start|> mainLayout.addLayout(hlayout, Qt.AlignLeft)
mainLayout.addItem(QSpacerItem(50, 20))
mainLayout.addWidget(buttons)
self.setLayout(mainLayout)
self.setWindowTitle('Add new transformation')
self.resize(self.sizeHint())
def default(self):
for box in [self.dx, self.dy, self.dz, self.angle]:
box.setText('0')
self.scalexy.setText('1')
self.scalez.setText('1')
def optimize(self):
dlg = OptimizationDialog(self.from_label, self.to_label)
if dlg.exec_() == QDialog.Rejected:
return
trans = dlg.trans
self.dx.setText(str(trans.translation.dx))
self.dy.setText(str(trans.translation.dy))
self.dz.setText(str(trans.translation.dz))
self.angle.setText(str(trans.rotation.angle))
self.scalexy.setText(str(trans.scaling.horizontal_factor))
self.scalez.setText(str(trans.scaling.vertical_factor))
def check(self):
try:
angle, scalexy, scalez, dx, dy, dz = map(float, [box.text() for box in [self.angle,
self.scalexy, self.scalez,
<|code_end|>
, determine the next line of code. You have imports:
import numpy as np
import sys
from PyQt5.QtCore import (QPoint, QRect, Qt)
from PyQt5.QtGui import (QBrush, QColor, QPainter, QPen)
from PyQt5.QtWidgets import (QApplication, QDialog, QDialogButtonBox, QFileDialog, QGridLayout, QGroupBox,
QHBoxLayout, QLabel, QLineEdit, QMessageBox, QPlainTextEdit, QPushButton,
QRadioButton, QSpacerItem, QStatusBar, QVBoxLayout, QWidget)
from pyteltools.geom.transformation import Transformation, is_connected, transformation_optimization as optimize
and context (class names, function names, or code) available:
# Path: pyteltools/geom/transformation.py
# class Transformation:
# """!
# @brief Transformation between two coordinate systems
# A transformation is a composition of rotation, scaling and translation on 3d vectors.
# """
# def __init__(self, angle, horizontal_factor, vertical_factor, dx, dy, dz):
# self.rotation = Rotation(angle)
# self.scaling = Scaling(horizontal_factor, vertical_factor)
# self.translation = Translation(dx, dy, dz)
#
# def __repr__(self):
# return ' '.join(map(str, [self.rotation.angle, self.scaling.horizontal_factor, self.scaling.vertical_factor,
# self.translation.dx, self.translation.dy, self.translation.dz]))
#
# def __call__(self, coordinates):
# return self.translation.vector + self.scaling.vector * self.rotation.rotation_matrix.dot(coordinates)
#
# def __str__(self):
# return '\n'.join(['Rotation:\t%.4f (rad)' % self.rotation.angle,
# 'Scaling:\tXY %.4f \tZ %.4f ' %
# (self.scaling.horizontal_factor, self.scaling.vertical_factor),
# 'Translation:\tX %.4f \t Y %.4f \t Z %.4f' %
# (self.translation.dx, self.translation.dy, self.translation.dz)])
#
# def inverse(self):
# """!
# @brief The inverse transformation
# The inverse transformation is a transformation with inverse rotation, inverse scaling
# and a translation vector that is equal to the result of inverse rotation and inverse scaling
# of the inverse translation vector
# """
# inverse_rotation = self.rotation.inverse()
# inverse_scaling = self.scaling.inverse()
# inverse_translation = self.translation.inverse()
# inverse_dx, inverse_dy, inverse_dz = inverse_scaling.vector * \
# inverse_rotation.rotation_matrix.dot(inverse_translation.vector)
# return Transformation(inverse_rotation.angle,
# inverse_scaling.horizontal_factor, inverse_scaling.vertical_factor,
# inverse_dx, inverse_dy, inverse_dz)
#
# def is_connected(nodes, edge_list):
# """!
# @brief ad hoc function for checking if an undirected graph is connected
# @param nodes <list>: the list of nodes in the graph
# @param edge_list <iterable>: edges in the graph
# @return <bool>: True if the graph is connected
# """
# adj = {}
# for i in nodes:
# adj[i] = set()
# for u, v in edge_list:
# adj[u].add(v)
#
# visited = {}
# for node in nodes:
# visited[node] = False
#
# stack = [nodes[0]]
# while stack:
# current_node = stack.pop()
# if not visited[current_node]:
# visited[current_node] = True
# for neighbor in adj[current_node]:
# stack.append(neighbor)
# return all(visited.values())
#
# def transformation_optimization(from_points, to_points, ignore_z):
# """!
# @brief Wrapper for optimization methods for transformations from one coordinate system to another
# @param from_points <list>: coordinates of points in the first coordinate system
# @param to_points <list>: the coordinates of the same points in the second coordinate system
# @param ignore_z <bool>: if True, optimize for 4 parameters instead of 6 (identity along z-axis)
# @return <tuple>: the final transformation, final cost function value, boolean indicating success and a message
# """
# if ignore_z:
# return four_parameters_optimization(from_points, to_points)
# return six_parameters_optimization(from_points, to_points)
. Output only the next line. | self.dx, self.dy, self.dz]]) |
Predict the next line for this snippet: <|code_start|>""" Test for the remove.py module in the vcontrol/rest/providers directory """
PROVIDERS_FILE_PATH = "../vcontrol/rest/providers/providers.txt"
class ContextDummy():
env = threadeddict()
env['HTTP_HOST'] = 'localhost:8080'
class WebDummy():
# dummy class to emulate the web.ctx.env call in remove.py
ctx = ContextDummy()
def test_successful_provider_removal():
""" Here we give the module a text file with PROVIDER: written in it,
it should remove that line in the file """
remove_provider = remove.RemoveProviderR()
remove.web = WebDummy() # override the web variable in remove.py
<|code_end|>
with the help of current file imports:
from os import remove as delete_file
from web import threadeddict
from vcontrol.rest.providers import remove
and context from other files:
# Path: vcontrol/rest/providers/remove.py
# class RemoveProviderR:
# def GET(self, provider):
, which may contain function names, class names, or code. Output only the next line. | test_provider = "PROV" |
Given snippet: <|code_start|>
class BuildCommandR:
"""
This endpoint is building Docker images on an machine.
"""
allow_origin, rest_url = get_allowed.get_allowed()
INDEX_HTML = """
<html>
<head>
<script src="http://code.jquery.com/jquery-3.1.0.min.js"></script>
<script>
$(function() {
function update() {
$.getJSON('/v1/commands/build/%s/%s', {}, function(data) {
if (data.state != 'done') {
"""
INDEX_HTML_TYPE_A = """
$('#status').append($('<div>'+data.content+'</div>'));
"""
INDEX_HTML_TYPE_B = """
$('#status').text(data.content);
"""
INDEX_HTML_END = """
setTimeout(update, 0);
}
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from ..helpers import get_allowed
from ..helpers import json_yield
import subprocess
import uuid
import web
and context:
# Path: vcontrol/rest/helpers/get_allowed.py
# def get_allowed():
# rest_url = ""
# if "ALLOW_ORIGIN" in os.environ:
# allow_origin = os.environ["ALLOW_ORIGIN"]
# host_port = allow_origin.split("//")[1]
# host = host_port.split(":")[0]
# port = str(int(host_port.split(":")[1])+1)
# rest_url = host+":"+port
# else:
# allow_origin = ""
# return allow_origin, rest_url
#
# Path: vcontrol/rest/helpers/json_yield.py
# def json_yield_none(fn):
# def _(self, key, *o, **k):
# def json_yield_one(fn):
# def _(self, arg, key, *o, **k):
# def json_yield_two(fn):
# def _(self, arg1, arg2, key, *o, **k):
which might include code, classes, or functions. Output only the next line. | }); |
Here is a snippet: <|code_start|>
class BuildCommandR:
"""
This endpoint is building Docker images on an machine.
"""
allow_origin, rest_url = get_allowed.get_allowed()
INDEX_HTML = """
<html>
<head>
<script src="http://code.jquery.com/jquery-3.1.0.min.js"></script>
<script>
$(function() {
function update() {
$.getJSON('/v1/commands/build/%s/%s', {}, function(data) {
if (data.state != 'done') {
"""
INDEX_HTML_TYPE_A = """
$('#status').append($('<div>'+data.content+'</div>'));
"""
INDEX_HTML_TYPE_B = """
$('#status').text(data.content);
"""
INDEX_HTML_END = """
setTimeout(update, 0);
}
<|code_end|>
. Write the next line using the current file imports:
from ..helpers import get_allowed
from ..helpers import json_yield
import subprocess
import uuid
import web
and context from other files:
# Path: vcontrol/rest/helpers/get_allowed.py
# def get_allowed():
# rest_url = ""
# if "ALLOW_ORIGIN" in os.environ:
# allow_origin = os.environ["ALLOW_ORIGIN"]
# host_port = allow_origin.split("//")[1]
# host = host_port.split(":")[0]
# port = str(int(host_port.split(":")[1])+1)
# rest_url = host+":"+port
# else:
# allow_origin = ""
# return allow_origin, rest_url
#
# Path: vcontrol/rest/helpers/json_yield.py
# def json_yield_none(fn):
# def _(self, key, *o, **k):
# def json_yield_one(fn):
# def _(self, arg, key, *o, **k):
# def json_yield_two(fn):
# def _(self, arg1, arg2, key, *o, **k):
, which may include functions, classes, or code. Output only the next line. | }); |
Given the following code snippet before the placeholder: <|code_start|> INDEX_HTML = """
<html>
<head>
<script src="http://code.jquery.com/jquery-3.1.0.min.js"></script>
<script>
$(function() {
function update() {
$.post('/v1/machines/create/%s', %s, function(data) {
if (data.state != 'done') {
"""
INDEX_HTML_TYPE_A = """
$('#status').append($('<div>'+data.content+'</div>'));
"""
INDEX_HTML_TYPE_B = """
$('#status').text(data.content);
"""
INDEX_HTML_END = """
setTimeout(update, 0);
}
}, 'json');
}
update();
});
</script>
</head>
<body>
<div id="status">Creating machine, please wait...</div>
</body>
<|code_end|>
, predict the next line using imports from the current file:
from ..helpers import get_allowed
from ..helpers import json_yield
import ast
import base64
import json
import os
import re
import subprocess
import uuid
import web
and context including class names, function names, and sometimes code from other files:
# Path: vcontrol/rest/helpers/get_allowed.py
# def get_allowed():
# rest_url = ""
# if "ALLOW_ORIGIN" in os.environ:
# allow_origin = os.environ["ALLOW_ORIGIN"]
# host_port = allow_origin.split("//")[1]
# host = host_port.split(":")[0]
# port = str(int(host_port.split(":")[1])+1)
# rest_url = host+":"+port
# else:
# allow_origin = ""
# return allow_origin, rest_url
#
# Path: vcontrol/rest/helpers/json_yield.py
# def json_yield_none(fn):
# def _(self, key, *o, **k):
# def json_yield_one(fn):
# def _(self, arg, key, *o, **k):
# def json_yield_two(fn):
# def _(self, arg1, arg2, key, *o, **k):
. Output only the next line. | </html> |
Continue the code snippet: <|code_start|>
class CreateMachineR:
"""
This endpoint is for creating a new machine of Vent on a provider.
"""
allow_origin, rest_url = get_allowed.get_allowed()
INDEX_HTML = """
<html>
<head>
<script src="http://code.jquery.com/jquery-3.1.0.min.js"></script>
<script>
$(function() {
function update() {
$.post('/v1/machines/create/%s', %s, function(data) {
if (data.state != 'done') {
"""
INDEX_HTML_TYPE_A = """
$('#status').append($('<div>'+data.content+'</div>'));
"""
INDEX_HTML_TYPE_B = """
$('#status').text(data.content);
"""
INDEX_HTML_END = """
setTimeout(update, 0);
}
<|code_end|>
. Use current file imports:
from ..helpers import get_allowed
from ..helpers import json_yield
import ast
import base64
import json
import os
import re
import subprocess
import uuid
import web
and context (classes, functions, or code) from other files:
# Path: vcontrol/rest/helpers/get_allowed.py
# def get_allowed():
# rest_url = ""
# if "ALLOW_ORIGIN" in os.environ:
# allow_origin = os.environ["ALLOW_ORIGIN"]
# host_port = allow_origin.split("//")[1]
# host = host_port.split(":")[0]
# port = str(int(host_port.split(":")[1])+1)
# rest_url = host+":"+port
# else:
# allow_origin = ""
# return allow_origin, rest_url
#
# Path: vcontrol/rest/helpers/json_yield.py
# def json_yield_none(fn):
# def _(self, key, *o, **k):
# def json_yield_one(fn):
# def _(self, arg, key, *o, **k):
# def json_yield_two(fn):
# def _(self, arg1, arg2, key, *o, **k):
. Output only the next line. | }, 'json'); |
Given the code snippet: <|code_start|>
class CleanCommandR:
"""
This endpoint is for cleaning all containers of a namespace on a Vent
machine.
"""
allow_origin, rest_url = get_allowed.get_allowed()
INDEX_HTML = """
<html>
<head>
<script src="http://code.jquery.com/jquery-3.1.0.min.js"></script>
<script>
$(function() {
function update() {
$.getJSON('/v1/commands/clean/%s/%s/%s', {}, function(data) {
if (data.state != 'done') {
"""
INDEX_HTML_TYPE_A = """
$('#status').append($('<div>'+data.content+'</div>'));
"""
INDEX_HTML_TYPE_B = """
$('#status').text(data.content);
"""
INDEX_HTML_END = """
<|code_end|>
, generate the next line using the imports in this file:
from ..helpers import get_allowed
from ..helpers import json_yield
import subprocess
import uuid
import web
and context (functions, classes, or occasionally code) from other files:
# Path: vcontrol/rest/helpers/get_allowed.py
# def get_allowed():
# rest_url = ""
# if "ALLOW_ORIGIN" in os.environ:
# allow_origin = os.environ["ALLOW_ORIGIN"]
# host_port = allow_origin.split("//")[1]
# host = host_port.split(":")[0]
# port = str(int(host_port.split(":")[1])+1)
# rest_url = host+":"+port
# else:
# allow_origin = ""
# return allow_origin, rest_url
#
# Path: vcontrol/rest/helpers/json_yield.py
# def json_yield_none(fn):
# def _(self, key, *o, **k):
# def json_yield_one(fn):
# def _(self, arg, key, *o, **k):
# def json_yield_two(fn):
# def _(self, arg1, arg2, key, *o, **k):
. Output only the next line. | setTimeout(update, 0); |
Predict the next line for this snippet: <|code_start|>
class CleanCommandR:
"""
This endpoint is for cleaning all containers of a namespace on a Vent
machine.
"""
allow_origin, rest_url = get_allowed.get_allowed()
INDEX_HTML = """
<html>
<head>
<script src="http://code.jquery.com/jquery-3.1.0.min.js"></script>
<script>
$(function() {
function update() {
$.getJSON('/v1/commands/clean/%s/%s/%s', {}, function(data) {
if (data.state != 'done') {
"""
INDEX_HTML_TYPE_A = """
$('#status').append($('<div>'+data.content+'</div>'));
"""
INDEX_HTML_TYPE_B = """
<|code_end|>
with the help of current file imports:
from ..helpers import get_allowed
from ..helpers import json_yield
import subprocess
import uuid
import web
and context from other files:
# Path: vcontrol/rest/helpers/get_allowed.py
# def get_allowed():
# rest_url = ""
# if "ALLOW_ORIGIN" in os.environ:
# allow_origin = os.environ["ALLOW_ORIGIN"]
# host_port = allow_origin.split("//")[1]
# host = host_port.split(":")[0]
# port = str(int(host_port.split(":")[1])+1)
# rest_url = host+":"+port
# else:
# allow_origin = ""
# return allow_origin, rest_url
#
# Path: vcontrol/rest/helpers/json_yield.py
# def json_yield_none(fn):
# def _(self, key, *o, **k):
# def json_yield_one(fn):
# def _(self, arg, key, *o, **k):
# def json_yield_two(fn):
# def _(self, arg1, arg2, key, *o, **k):
, which may contain function names, class names, or code. Output only the next line. | $('#status').text(data.content); |
Continue the code snippet: <|code_start|>
def process(input):
howareyou = [
'I\'m amazing, dude!',
'I\'m awesome, dude!'
]
output = {
'input': input,
'output': TextTemplate(random.choice(howareyou)).get_message(),
'success': True
<|code_end|>
. Use current file imports:
import random
from templates.text import TextTemplate
and context (classes, functions, or code) from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | } |
Predict the next line for this snippet: <|code_start|>
def process(input):
talktome = [
'I am talking to you, dude!',
'Dude!'
]
output = {
'input': input,
'output': TextTemplate(random.choice(talktome)).get_message(),
'success': True
}
<|code_end|>
with the help of current file imports:
import random
from templates.text import TextTemplate
and context from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
, which may contain function names, class names, or code. Output only the next line. | return output |
Given the following code snippet before the placeholder: <|code_start|>
def process(input):
cheer = [
'Yayy!',
'Whoohoo!',
<|code_end|>
, predict the next line using imports from the current file:
import random
from templates.text import TextTemplate
and context including class names, function names, and sometimes code from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | 'Wow! You are a cheerful one!' |
Using the snippet: <|code_start|>
def process(input):
duude = [
'Duuuuude! Relax!',
'You need a White Russian cocktail! So do I',
<|code_end|>
, determine the next line of code. You have imports:
import random
from templates.text import TextTemplate
and context (class names, function names, or code) available:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | 'Damn dude!', |
Predict the next line for this snippet: <|code_start|>
def process(input):
bye = [
'Bye dude!',
'Goodbye, dude!',
'See ya later, dude!',
'Peace out, dude!',
'Later, dude!'
]
output = {
<|code_end|>
with the help of current file imports:
import random
from templates.text import TextTemplate
and context from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
, which may contain function names, class names, or code. Output only the next line. | 'input': input, |
Continue the code snippet: <|code_start|>
def process(input):
iamawesome = [
'I know! I\'m pretty cool!',
<|code_end|>
. Use current file imports:
import random
from templates.text import TextTemplate
and context (classes, functions, or code) from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | 'I know! B-)', |
Next line prediction: <|code_start|>
def process(input):
gm = [
'Morning, dude!',
'Good morning, dude!'
]
output = {
'input': input,
'output': TextTemplate(random.choice(gm)).get_message(),
'success': True
}
<|code_end|>
. Use current file imports:
(import random
from templates.text import TextTemplate)
and context including class names, function names, or small code snippets from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | return output |
Based on the snippet: <|code_start|>
def process(input):
frustration = [
'Easy there, dude!',
'Control dude!',
'You need to chill, dude!'
]
output = {
'input': input,
'output': TextTemplate(random.choice(frustration)).get_message(),
'success': True
}
<|code_end|>
, predict the immediate next line with the help of imports:
import random
from templates.text import TextTemplate
and context (classes, functions, sometimes code) from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | return output |
Continue the code snippet: <|code_start|>
def process(input):
manparvesh = [
'Never met him, but heard he\'s a super cool and awesome dude!',
'He\'s awesome, dude!'
]
output = {
'input': input,
'output': TextTemplate(random.choice(manparvesh)).get_message(),
'success': True
}
<|code_end|>
. Use current file imports:
import random
from templates.text import TextTemplate
and context (classes, functions, or code) from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | return output |
Given the following code snippet before the placeholder: <|code_start|>
def process(input):
whomadeyou = [
'An awesome dude, dude!',
'A super cool dude, dude!',
'Batman! Nananana!'
]
output = {
'input': input,
'output': TextTemplate(random.choice(whomadeyou)).get_message(),
<|code_end|>
, predict the next line using imports from the current file:
import random
from templates.text import TextTemplate
and context including class names, function names, and sometimes code from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | 'success': True |
Continue the code snippet: <|code_start|>
def process(input):
ge = [
'Evening, dude!',
'Good evening, dude!'
<|code_end|>
. Use current file imports:
import random
from templates.text import TextTemplate
and context (classes, functions, or code) from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | ] |
Given the following code snippet before the placeholder: <|code_start|>
x = "Let me explain something to you. I'm the Dude. "
x += "So that's what you call me. You know, that"
x += " or, uh, His Dudeness, or uh, Duder, or El Duderino"
x += " if you're not into the whole brevity thing"
def process(input):
output = {
'input': input,
'output': TextTemplate(x).get_message(),
'success': True
<|code_end|>
, predict the next line using imports from the current file:
from templates.text import TextTemplate
and context including class names, function names, and sometimes code from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | } |
Using the snippet: <|code_start|>
def process(input):
tellmesomething = '''What do you want to know?
Sample queries that work are:
Hi, dude!
Duuuuuude!
Yay!
How are you?
<|code_end|>
, determine the next line of code. You have imports:
from templates.text import TextTemplate
and context (class names, function names, or code) available:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | What are you doing? |
Given the code snippet: <|code_start|>
def process(input):
help = '''Hey there! I'm the Dude! \n
Sample queries that work are:
Hi, dude!
Duuuuuude!
Yay!
How are you?
What are you doing?
Do you know about God?
Who made you?
Who is Man Parvesh?
:P
:D
Goodbye dude!
help
Who are you?
Tell me a joke
Tell me a quote'''
output = {
'input': input,
'output': TextTemplate(help).get_message(),
'success': True
}
<|code_end|>
, generate the next line using the imports in this file:
from templates.text import TextTemplate
and context (functions, classes, or occasionally code) from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | return output |
Using the snippet: <|code_start|>
def process(input):
changethis = [
'Too lazy for that, dude!',
'Relax, dude! Don\'t interfere with my laziness!'
]
output = {
'input': input,
'output': TextTemplate(random.choice(changethis)).get_message(),
'success': True
<|code_end|>
, determine the next line of code. You have imports:
import random
from templates.text import TextTemplate
and context (class names, function names, or code) available:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | } |
Next line prediction: <|code_start|>
def process(input):
ok = 'Yo'
output = {
'input': input,
'output': TextTemplate(ok).get_message(),
<|code_end|>
. Use current file imports:
(from templates.text import TextTemplate)
and context including class names, function names, or small code snippets from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | 'success': True |
Given the code snippet: <|code_start|>
def process(input):
emoji = [
':P',
':)',
':O',
<|code_end|>
, generate the next line using the imports in this file:
import random
from templates.text import TextTemplate
and context (functions, classes, or occasionally code) from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | 'B-)', |
Based on the snippet: <|code_start|>
def process(input):
output = {}
try:
<|code_end|>
, predict the immediate next line with the help of imports:
import requests
import json
import config
from templates.text import TextTemplate
from random import choice
and context (classes, functions, sometimes code) from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | with open(config.QUOTES_SOURCE_FILE) as quotes_file: |
Using the snippet: <|code_start|>
def process(input):
hello = [
'Hi dude!',
<|code_end|>
, determine the next line of code. You have imports:
import random
from templates.text import TextTemplate
and context (class names, function names, or code) available:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | 'Hey there, dude!', |
Predict the next line for this snippet: <|code_start|>
def process(input):
whatshouldido = [
'You should learn to chill, dude!',
'Have a White Russian cocktail, dude!',
'Relax, dude!',
'Have fun, dude!'
]
<|code_end|>
with the help of current file imports:
import random
from templates.text import TextTemplate
and context from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
, which may contain function names, class names, or code. Output only the next line. | output = { |
Using the snippet: <|code_start|>
def process(input):
output = {}
try:
with open(config.JOKES_SOURCE_FILE) as jokes_file:
jokes = json.load(jokes_file)
<|code_end|>
, determine the next line of code. You have imports:
import requests
import json
import config
from templates.text import TextTemplate
from random import choice
and context (class names, function names, or code) available:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | jokes_list = jokes['jokes'] |
Continue the code snippet: <|code_start|>
def process(input):
cuss = [
'Damn! You need language lessons, dude!',
'Easy there, dude!',
'Relax, dude!',
'Control, dude!'
]
output = {
'input': input,
'output': TextTemplate(random.choice(cuss)).get_message(),
<|code_end|>
. Use current file imports:
import random
from templates.text import TextTemplate
and context (classes, functions, or code) from other files:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
. Output only the next line. | 'success': True |
Given snippet: <|code_start|>
def process(input):
whatareyoudoing = [
'I\'m talking to you while having a White Russian cocktail, dude!',
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import random
from templates.text import TextTemplate
and context:
# Path: templates/text.py
# class TextTemplate:
# def __init__(self, text='', post_text='', limit=TEXT_CHARACTER_LIMIT):
# self.template = template['value']
# self.text = text
# self.post_text = post_text
# self.limit = limit
#
# def set_text(self, text=''):
# self.text = text
#
# def set_post_text(self, post_text=''):
# self.post_text = post_text
#
# def set_limit(self, limit=TEXT_CHARACTER_LIMIT):
# self.limit = limit
#
# def get_message(self):
# n = self.limit - len(self.post_text)
# if n > len(self.text):
# self.template['text'] = self.text + self.post_text
# else:
# s = self.text[:n-3].rsplit(' ', 1)[0] + '...' + self.post_text
# self.template['text'] = s
# return self.template
which might include code, classes, or functions. Output only the next line. | 'Chillin\'!' |
Given the code snippet: <|code_start|> ctype = self.request.headers.get('Content-Type', '').lower()
if ctype == 'application/x-www-form-urlencoded':
if not data.startswith('d='):
log.msg('jsonp_send: Invalid payload.')
self.write("Payload expected.")
self.set_status(500)
return
data = urllib.unquote_plus(data[2:])
if not data:
log.msg('jsonp_send: Payload expected.')
self.write("Payload expected.")
self.set_status(500)
return
try:
messages = proto.json_decode(data)
except:
# TODO: Proper error handling
log.msg('jsonp_send: Invalid json encoding')
self.write("Broken JSON encoding.")
self.set_status(500)
return
try:
session.messagesReceived(messages)
<|code_end|>
, generate the next line using the imports in this file:
import urllib
from cyclone.web import asynchronous
from twisted.python import log
from sockjs.cyclone import proto
from sockjs.cyclone.transports import pollingbase
and context (functions, classes, or occasionally code) from other files:
# Path: sockjs/cyclone/proto.py
# CONNECT = 'o'
# DISCONNECT = 'c'
# MESSAGE = 'm'
# HEARTBEAT = 'h'
# def disconnect(code, reason):
#
# Path: sockjs/cyclone/transports/pollingbase.py
# class PollingTransportBase(basehandler.PreflightHandler, base.BaseTransportMixin):
# def initialize(self, server):
# def _get_session(self, session_id):
# def _attach_session(self, session_id, start_heartbeat=True):
# def _detach(self):
# def check_xsrf_cookie(self):
# def send_message(self, message, stats=True):
# def session_closed(self):
# def on_connection_close(self, reason):
. Output only the next line. | except Exception: |
Given snippet: <|code_start|>
class JSONPTransport(pollingbase.PollingTransportBase):
name = 'jsonp'
@asynchronous
def get(self, session_id):
# Start response
self.handle_session_cookie()
self.disable_cache()
# Grab callback parameter
self.callback = self.get_argument('c', None)
if not self.callback:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import urllib
from cyclone.web import asynchronous
from twisted.python import log
from sockjs.cyclone import proto
from sockjs.cyclone.transports import pollingbase
and context:
# Path: sockjs/cyclone/proto.py
# CONNECT = 'o'
# DISCONNECT = 'c'
# MESSAGE = 'm'
# HEARTBEAT = 'h'
# def disconnect(code, reason):
#
# Path: sockjs/cyclone/transports/pollingbase.py
# class PollingTransportBase(basehandler.PreflightHandler, base.BaseTransportMixin):
# def initialize(self, server):
# def _get_session(self, session_id):
# def _attach_session(self, session_id, start_heartbeat=True):
# def _detach(self):
# def check_xsrf_cookie(self):
# def send_message(self, message, stats=True):
# def session_closed(self):
# def on_connection_close(self, reason):
which might include code, classes, or functions. Output only the next line. | self.write('"callback" parameter required') |
Predict the next line for this snippet: <|code_start|>
# HTMLFILE template
HTMLFILE_HEAD = r'''
<!doctype html>
<html><head>
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<|code_end|>
with the help of current file imports:
from cyclone.web import asynchronous
from sockjs.cyclone import proto
from sockjs.cyclone.transports import streamingbase
and context from other files:
# Path: sockjs/cyclone/proto.py
# CONNECT = 'o'
# DISCONNECT = 'c'
# MESSAGE = 'm'
# HEARTBEAT = 'h'
# def disconnect(code, reason):
#
# Path: sockjs/cyclone/transports/streamingbase.py
# class StreamingTransportBase(pollingbase.PollingTransportBase):
# def initialize(self, server):
# def should_finish(self, data_len):
# def session_closed(self):
, which may contain function names, class names, or code. Output only the next line. | <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> |
Given the code snippet: <|code_start|>
# HTMLFILE template
HTMLFILE_HEAD = r'''
<!doctype html>
<html><head>
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<|code_end|>
, generate the next line using the imports in this file:
from cyclone.web import asynchronous
from sockjs.cyclone import proto
from sockjs.cyclone.transports import streamingbase
and context (functions, classes, or occasionally code) from other files:
# Path: sockjs/cyclone/proto.py
# CONNECT = 'o'
# DISCONNECT = 'c'
# MESSAGE = 'm'
# HEARTBEAT = 'h'
# def disconnect(code, reason):
#
# Path: sockjs/cyclone/transports/streamingbase.py
# class StreamingTransportBase(pollingbase.PollingTransportBase):
# def initialize(self, server):
# def should_finish(self, data_len):
# def session_closed(self):
. Output only the next line. | <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> |
Here is a snippet: <|code_start|> res = self.sc.remove(self.session.session_id)
self.assertTrue(res)
self.assertFalse(self._check_session_is_in_items())
def test_remove_calls_session_on_delete(self):
self.sc.add(self.session)
self.assertFalse(self.session._delete_called)
self.sc.remove(self.session.session_id)
self.assertTrue(self.session._delete_called)
def test_remove_on_non_existing_session_returns_False(self):
res = self.sc.remove(42)
self.assertFalse(res)
def test_expire_with_no_sessions_doesnt_raise(self):
self.sc.remove(42)
def test_expire_does_nothing_if_no_sessions_are_expired(self):
sessions = [ SessionFake() for i in range(10) ]
for index, s in enumerate(sessions):
s.session_id = index
s.expiry = 10
s.expiry_date = 10
self.sc.add(s)
self.sc.expire(current_time=0)
for s in sessions:
<|code_end|>
. Write the next line using the current file imports:
from twisted.trial import unittest
from sockjs.cyclone.sessioncontainer import SessionContainer
from types import MethodType
and context from other files:
# Path: sockjs/cyclone/sessioncontainer.py
# class SessionContainer(object):
# """ Session container object. """
# def __init__(self):
# self._items = dict()
# self._queue = PriorityQueue()
#
# def add(self, session):
# """ Add session to the container.
#
# @param session: Session object
# """
# self._items[session.session_id] = session
#
# if session.expiry is not None:
# self._queue.push(session)
#
# def get(self, session_id):
# """ Return session object or None if it is not available
#
# @param session_id: Session identifier
# """
# return self._items.get(session_id, None)
#
# def remove(self, session_id):
# """ Remove session object from the container
#
# @param session_id: Session identifier
# """
# session = self._items.get(session_id, None)
#
# if session is not None:
# session.promoted = -1
# session.on_delete(True)
# del self._items[session_id]
# return True
#
# return False
#
# def expire(self, current_time=None):
# """ Expire any old entries
#
# @param current_time: Optional time to be used to clean up queue (can be
# used in unit tests)
# """
# if self._queue.is_empty():
# return
#
# if current_time is None:
# current_time = time.time()
#
# while not self._queue.is_empty():
# # Get top most item
# top = self._queue.peek()
#
# # Early exit if item was not promoted and its expiration time
# # is greater than now.
# if top.promoted is None and top.expiry_date > current_time:
# break
#
# # Pop item from the stack
# top = self._queue.pop()
#
# need_reschedule = (top.promoted is not None
# and top.promoted > current_time)
#
# # Give chance to reschedule
# if not need_reschedule:
# top.promoted = None
# top.on_delete(False)
#
# need_reschedule = (top.promoted is not None
# and top.promoted > current_time)
#
# # If item is promoted and expiration time somewhere in future
# # just reschedule it
# if need_reschedule:
# top.expiry_date = top.promoted
# top.promoted = None
# self._queue.push(top)
# else:
# del self._items[top.session_id]
, which may include functions, classes, or code. Output only the next line. | self.assertTrue(self._check_session_is_in_items(session=s)) |
Using the snippet: <|code_start|>
class XhrStreamingTransport(streamingbase.StreamingTransportBase):
name = 'xhr_streaming'
@asynchronous
def post(self, session_id):
# Handle cookie
self.preflight()
self.handle_session_cookie()
self.set_header('Content-Type', 'application/javascript; charset=UTF-8')
self.disable_cache()
# Send prelude and flush any pending messages
# prelude is needed to workaround an ie8 weirdness:
# 'http://blogs.msdn.com/b/ieinternals/archive/2010/04/06/'
# 'comet-streaming-in-internet-explorer-with-xmlhttprequest-'
# 'and-xdomainrequest.aspx'
self.write('h' * 2048 + '\n')
self.flush()
if not self._attach_session(session_id):
<|code_end|>
, determine the next line of code. You have imports:
from cyclone.web import asynchronous
from sockjs.cyclone.transports import streamingbase
and context (class names, function names, or code) available:
# Path: sockjs/cyclone/transports/streamingbase.py
# class StreamingTransportBase(pollingbase.PollingTransportBase):
# def initialize(self, server):
# def should_finish(self, data_len):
# def session_closed(self):
. Output only the next line. | self.finish() |
Here is a snippet: <|code_start|>
class EventSourceTransport(streamingbase.StreamingTransportBase):
name = 'eventsource'
@asynchronous
def get(self, session_id):
# Start response
self.preflight()
self.handle_session_cookie()
self.disable_cache()
self.set_header('Content-Type', 'text/event-stream; charset=UTF-8')
self.write('\r\n')
self.flush()
<|code_end|>
. Write the next line using the current file imports:
from cyclone.web import asynchronous
from sockjs.cyclone.transports import streamingbase
and context from other files:
# Path: sockjs/cyclone/transports/streamingbase.py
# class StreamingTransportBase(pollingbase.PollingTransportBase):
# def initialize(self, server):
# def should_finish(self, data_len):
# def session_closed(self):
, which may include functions, classes, or code. Output only the next line. | if not self._attach_session(session_id): |
Predict the next line after this snippet: <|code_start|>
self.handler = None
def close(self, code=3000, message='Go away!'):
""" Close session or endpoint connection.
@param code: Closing code
@param message: Close message
"""
if self.state != SESSION_STATE.CLOSED:
try:
self.conn.connectionLost()
except Exception as e:
log.msg("Failed to call connectionLost(): %r." % e)
finally:
self.state = SESSION_STATE.CLOSED
self.close_reason = (code, message)
# Bump stats
self.stats.sessionClosed(self.transport_name)
# If we have active handler, notify that session was closed
if self.handler is not None:
self.handler.session_closed()
def delayed_close(self):
""" Delayed close - won't close immediately, but on the next reactor
loop. """
self.state = SESSION_STATE.CLOSING
<|code_end|>
using the current file's imports:
import random
import hashlib
import time
from twisted.python import log
from twisted.internet import reactor
from twisted.internet import task
from twisted.python.constants import NamedConstant, Names
from sockjs.cyclone import proto
from sockjs.cyclone import utils
and any relevant context from other files:
# Path: sockjs/cyclone/proto.py
# CONNECT = 'o'
# DISCONNECT = 'c'
# MESSAGE = 'm'
# HEARTBEAT = 'h'
# def disconnect(code, reason):
#
# Path: sockjs/cyclone/utils.py
# class SendQueue(object):
# class PriorityQueue(object):
# def __init__(self, separator=','):
# def push(self, msg):
# def get(self):
# def clear(self):
# def is_empty(self):
# def __init__(self):
# def push(self, el):
# def peek(self):
# def pop(self):
# def is_empty(self):
# def __contains__(self, el):
# def __len__(self):
. Output only the next line. | reactor.callLater(0, self.close) |
Predict the next line after this snippet: <|code_start|> self.conn_info = None
self.conn = conn(self)
self.close_reason = None
def set_handler(self, handler):
""" Set transport handler
@param handler: Handler, should derive from the
C{sockjs.cyclone.transports.base.BaseTransportMixin}
"""
if self.handler is not None:
raise Exception('Attempted to overwrite BaseSession handler')
self.handler = handler
self.transport_name = self.handler.name
if self.conn_info is None:
self.conn_info = handler.get_conn_info()
self.stats.sessionOpened(self.transport_name)
return True
def verify_state(self):
""" Verify if session was not yet opened. If it is, open it and call
connection's C{connectionMade} """
if self.state == SESSION_STATE.CONNECTING:
self.state = SESSION_STATE.OPEN
<|code_end|>
using the current file's imports:
import random
import hashlib
import time
from twisted.python import log
from twisted.internet import reactor
from twisted.internet import task
from twisted.python.constants import NamedConstant, Names
from sockjs.cyclone import proto
from sockjs.cyclone import utils
and any relevant context from other files:
# Path: sockjs/cyclone/proto.py
# CONNECT = 'o'
# DISCONNECT = 'c'
# MESSAGE = 'm'
# HEARTBEAT = 'h'
# def disconnect(code, reason):
#
# Path: sockjs/cyclone/utils.py
# class SendQueue(object):
# class PriorityQueue(object):
# def __init__(self, separator=','):
# def push(self, msg):
# def get(self):
# def clear(self):
# def is_empty(self):
# def __init__(self):
# def push(self, el):
# def peek(self):
# def pop(self):
# def is_empty(self):
# def __contains__(self, el):
# def __len__(self):
. Output only the next line. | self.conn.connectionMade(self.conn_info) |
Next line prediction: <|code_start|>
class StreamingTransportBase(pollingbase.PollingTransportBase):
def initialize(self, server):
super(StreamingTransportBase, self).initialize(server)
self.amount_limit = self.server.settings['response_limit']
# HTTP 1.0 client might send keep-alive
if (hasattr(self.request, 'connection')
<|code_end|>
. Use current file imports:
(from sockjs.cyclone.transports import pollingbase)
and context including class names, function names, or small code snippets from other files:
# Path: sockjs/cyclone/transports/pollingbase.py
# class PollingTransportBase(basehandler.PreflightHandler, base.BaseTransportMixin):
# def initialize(self, server):
# def _get_session(self, session_id):
# def _attach_session(self, session_id, start_heartbeat=True):
# def _detach(self):
# def check_xsrf_cookie(self):
# def send_message(self, message, stats=True):
# def session_closed(self):
# def on_connection_close(self, reason):
. Output only the next line. | and not self.request.supports_http_1_1()): |
Using the snippet: <|code_start|> self.q.pop()
self.assertFalse(1 in self.q)
def test_len(self):
self.assertEquals(len(self.q), 0)
self.q.push(1)
self.assertEquals(len(self.q), 1)
self.q.pop()
self.assertEquals(len(self.q), 0)
class SendQueueTest(unittest.TestCase):
def test_single_value_doesnt_use_separator(self):
q = SendQueue()
q.push('xxx')
self.assertFalse(q.SEPARATOR in q.get())
def test_two_values_use_separator(self):
q = SendQueue()
one = 'one'
two = 'two'
q.push(one)
q.push(two)
self.assertEquals(q.get(), '%s%s%s' % (one, q.SEPARATOR, two))
def test_is_empty(self):
q = SendQueue()
self.assertTrue(q.is_empty())
<|code_end|>
, determine the next line of code. You have imports:
from twisted.trial import unittest
from sockjs.cyclone.utils import SendQueue, PriorityQueue
and context (class names, function names, or code) available:
# Path: sockjs/cyclone/utils.py
# class SendQueue(object):
# """ Simple send queue. Stores messages and returns a string of all messages.
# """
# def __init__(self, separator=','):
# self.SEPARATOR = separator
# self._queue = []
#
# def push(self, msg):
# """ pushes a new message in the queue. """
# self._queue.append(msg)
#
# def get(self):
# """ returns enqueued messages in a single string, separator-joined """
# return self.SEPARATOR.join(self._queue)
#
# def clear(self):
# """ empties the queue. """
# self._queue = []
#
# def is_empty(self):
# """ check if the queue is empty. """
# return not self._queue
#
# class PriorityQueue(object):
# """ Simplistic priority queue.
# """
# def __init__(self):
# self._queue = []
#
# self.counter = itertools.count() # needed to preserve insertion order
# # in elements with the same priority
#
# def push(self, el):
# """ Put a new element in the queue. """
# count = next(self.counter)
# heapq.heappush(self._queue, (el, count))
#
# def peek(self):
# """ Returns the highest priority element from the queue without
# removing it. """
# return self._queue[0][0]
#
# def pop(self):
# """ Remove and returns the highest priority element form the queue. """
# return heapq.heappop(self._queue)[0]
#
# def is_empty(self):
# """ Checks if the queue is empty. """
# return not self._queue
#
# def __contains__(self, el):
# return el in ( e[0] for e in self._queue )
#
# def __len__(self):
# return len(self._queue)
. Output only the next line. | q.push('x') |
Continue the code snippet: <|code_start|> def __cmp__(self, other):
return cmp(self.val, other.val)
self.q.push(El('other', 2))
self.q.push(El('first', 1))
self.q.push(El('second', 1))
self.q.push(El('third', 1))
self.assertEquals(self.q.pop().id, 'first')
self.assertEquals(self.q.pop().id, 'second')
self.assertEquals(self.q.pop().id, 'third')
self.assertEquals(self.q.pop().id, 'other')
def test_contains(self):
self.assertFalse(1 in self.q)
self.q.push(1)
self.assertTrue(1 in self.q)
self.q.pop()
self.assertFalse(1 in self.q)
def test_len(self):
self.assertEquals(len(self.q), 0)
self.q.push(1)
self.assertEquals(len(self.q), 1)
self.q.pop()
self.assertEquals(len(self.q), 0)
class SendQueueTest(unittest.TestCase):
<|code_end|>
. Use current file imports:
from twisted.trial import unittest
from sockjs.cyclone.utils import SendQueue, PriorityQueue
and context (classes, functions, or code) from other files:
# Path: sockjs/cyclone/utils.py
# class SendQueue(object):
# """ Simple send queue. Stores messages and returns a string of all messages.
# """
# def __init__(self, separator=','):
# self.SEPARATOR = separator
# self._queue = []
#
# def push(self, msg):
# """ pushes a new message in the queue. """
# self._queue.append(msg)
#
# def get(self):
# """ returns enqueued messages in a single string, separator-joined """
# return self.SEPARATOR.join(self._queue)
#
# def clear(self):
# """ empties the queue. """
# self._queue = []
#
# def is_empty(self):
# """ check if the queue is empty. """
# return not self._queue
#
# class PriorityQueue(object):
# """ Simplistic priority queue.
# """
# def __init__(self):
# self._queue = []
#
# self.counter = itertools.count() # needed to preserve insertion order
# # in elements with the same priority
#
# def push(self, el):
# """ Put a new element in the queue. """
# count = next(self.counter)
# heapq.heappush(self._queue, (el, count))
#
# def peek(self):
# """ Returns the highest priority element from the queue without
# removing it. """
# return self._queue[0][0]
#
# def pop(self):
# """ Remove and returns the highest priority element form the queue. """
# return heapq.heappop(self._queue)[0]
#
# def is_empty(self):
# """ Checks if the queue is empty. """
# return not self._queue
#
# def __contains__(self, el):
# return el in ( e[0] for e in self._queue )
#
# def __len__(self):
# return len(self._queue)
. Output only the next line. | def test_single_value_doesnt_use_separator(self): |
Here is a snippet: <|code_start|>
class RawSession(session.BaseSession):
""" Raw session without any sockjs protocol encoding/decoding.
Simply works as a proxy between C{SockJSConnection} class and
C{RawWebSocketTransport}. """
def send_message(self, msg, stats=True):
self.handler.send_pack(msg)
def messageReceived(self, msg):
<|code_end|>
. Write the next line using the current file imports:
from twisted.python import log
from sockjs.cyclone import session
from sockjs.cyclone.transports import base
from sockjs.cyclone import websocket
and context from other files:
# Path: sockjs/cyclone/session.py
# class SESSION_STATE(Names):
# class BaseSession(object):
# class SessionMixin(object):
# class Session(BaseSession, SessionMixin):
# class MultiplexChannelSession(BaseSession):
# CONNECTING = NamedConstant()
# OPEN = NamedConstant()
# CLOSING = NamedConstant()
# CLOSED = NamedConstant()
# def __init__(self, conn, server):
# def set_handler(self, handler):
# def verify_state(self):
# def remove_handler(self, handler):
# def close(self, code=3000, message='Go away!'):
# def delayed_close(self):
# def get_close_reason(self):
# def is_closed(self):
# def send_message(self, msg, stats=True):
# def send_jsonified(self, msg, stats=True):
# def broadcast(self, clients, msg):
# def __init__(self, session_id=None, expiry=None, time_module=time):
# def _random_key(self):
# def is_alive(self):
# def promote(self):
# def on_delete(self, forced):
# def __cmp__(self, other):
# def __repr__(self):
# def __init__(self, conn, server, session_id, expiry=None):
# def on_delete(self, forced):
# def set_handler(self, handler, start_heartbeat=True):
# def verify_state(self):
# def remove_handler(self, handler):
# def send_message(self, msg, stats=True):
# def send_jsonified(self, msg, stats=True):
# def flush(self):
# def close(self, code=3000, message='Go away!'):
# def start_heartbeat(self):
# def stop_heartbeat(self):
# def delay_heartbeat(self):
# def _heartbeat(self):
# def messagesReceived(self, msg_list):
# def __init__(self, conn, server, base, name):
# def send_message(self, msg, stats=True):
# def messageReceived(self, msg):
# def close(self, code=3000, message='Go away!'):
# def _close(self, code=3000, message='Go away!'):
#
# Path: sockjs/cyclone/transports/base.py
# class BaseTransportMixin(object):
# class MultiplexTransport(BaseTransportMixin):
# def get_conn_info(self):
# def session_closed(self):
# def __init__(self, conn_info):
# def get_conn_info(self):
#
# Path: sockjs/cyclone/websocket.py
# class WebSocketHandler(cyclone.websocket.WebSocketHandler):
# def _execute(self, *args, **kwargs):
# def _closeIfInvalidMethod(self):
# def _writeAndClose(self, resp):
# def _closeIfInvalidUpgradeHeader(self):
# def _closeIfInvalidConnectionHeader(self):
, which may include functions, classes, or code. Output only the next line. | self.conn.messageReceived(msg) |
Predict the next line after this snippet: <|code_start|>
class RawSession(session.BaseSession):
""" Raw session without any sockjs protocol encoding/decoding.
Simply works as a proxy between C{SockJSConnection} class and
C{RawWebSocketTransport}. """
def send_message(self, msg, stats=True):
self.handler.send_pack(msg)
def messageReceived(self, msg):
<|code_end|>
using the current file's imports:
from twisted.python import log
from sockjs.cyclone import session
from sockjs.cyclone.transports import base
from sockjs.cyclone import websocket
and any relevant context from other files:
# Path: sockjs/cyclone/session.py
# class SESSION_STATE(Names):
# class BaseSession(object):
# class SessionMixin(object):
# class Session(BaseSession, SessionMixin):
# class MultiplexChannelSession(BaseSession):
# CONNECTING = NamedConstant()
# OPEN = NamedConstant()
# CLOSING = NamedConstant()
# CLOSED = NamedConstant()
# def __init__(self, conn, server):
# def set_handler(self, handler):
# def verify_state(self):
# def remove_handler(self, handler):
# def close(self, code=3000, message='Go away!'):
# def delayed_close(self):
# def get_close_reason(self):
# def is_closed(self):
# def send_message(self, msg, stats=True):
# def send_jsonified(self, msg, stats=True):
# def broadcast(self, clients, msg):
# def __init__(self, session_id=None, expiry=None, time_module=time):
# def _random_key(self):
# def is_alive(self):
# def promote(self):
# def on_delete(self, forced):
# def __cmp__(self, other):
# def __repr__(self):
# def __init__(self, conn, server, session_id, expiry=None):
# def on_delete(self, forced):
# def set_handler(self, handler, start_heartbeat=True):
# def verify_state(self):
# def remove_handler(self, handler):
# def send_message(self, msg, stats=True):
# def send_jsonified(self, msg, stats=True):
# def flush(self):
# def close(self, code=3000, message='Go away!'):
# def start_heartbeat(self):
# def stop_heartbeat(self):
# def delay_heartbeat(self):
# def _heartbeat(self):
# def messagesReceived(self, msg_list):
# def __init__(self, conn, server, base, name):
# def send_message(self, msg, stats=True):
# def messageReceived(self, msg):
# def close(self, code=3000, message='Go away!'):
# def _close(self, code=3000, message='Go away!'):
#
# Path: sockjs/cyclone/transports/base.py
# class BaseTransportMixin(object):
# class MultiplexTransport(BaseTransportMixin):
# def get_conn_info(self):
# def session_closed(self):
# def __init__(self, conn_info):
# def get_conn_info(self):
#
# Path: sockjs/cyclone/websocket.py
# class WebSocketHandler(cyclone.websocket.WebSocketHandler):
# def _execute(self, *args, **kwargs):
# def _closeIfInvalidMethod(self):
# def _writeAndClose(self, resp):
# def _closeIfInvalidUpgradeHeader(self):
# def _closeIfInvalidConnectionHeader(self):
. Output only the next line. | self.conn.messageReceived(msg) |
Based on the snippet: <|code_start|>
class RawSession(session.BaseSession):
""" Raw session without any sockjs protocol encoding/decoding.
Simply works as a proxy between C{SockJSConnection} class and
C{RawWebSocketTransport}. """
def send_message(self, msg, stats=True):
self.handler.send_pack(msg)
def messageReceived(self, msg):
<|code_end|>
, predict the immediate next line with the help of imports:
from twisted.python import log
from sockjs.cyclone import session
from sockjs.cyclone.transports import base
from sockjs.cyclone import websocket
and context (classes, functions, sometimes code) from other files:
# Path: sockjs/cyclone/session.py
# class SESSION_STATE(Names):
# class BaseSession(object):
# class SessionMixin(object):
# class Session(BaseSession, SessionMixin):
# class MultiplexChannelSession(BaseSession):
# CONNECTING = NamedConstant()
# OPEN = NamedConstant()
# CLOSING = NamedConstant()
# CLOSED = NamedConstant()
# def __init__(self, conn, server):
# def set_handler(self, handler):
# def verify_state(self):
# def remove_handler(self, handler):
# def close(self, code=3000, message='Go away!'):
# def delayed_close(self):
# def get_close_reason(self):
# def is_closed(self):
# def send_message(self, msg, stats=True):
# def send_jsonified(self, msg, stats=True):
# def broadcast(self, clients, msg):
# def __init__(self, session_id=None, expiry=None, time_module=time):
# def _random_key(self):
# def is_alive(self):
# def promote(self):
# def on_delete(self, forced):
# def __cmp__(self, other):
# def __repr__(self):
# def __init__(self, conn, server, session_id, expiry=None):
# def on_delete(self, forced):
# def set_handler(self, handler, start_heartbeat=True):
# def verify_state(self):
# def remove_handler(self, handler):
# def send_message(self, msg, stats=True):
# def send_jsonified(self, msg, stats=True):
# def flush(self):
# def close(self, code=3000, message='Go away!'):
# def start_heartbeat(self):
# def stop_heartbeat(self):
# def delay_heartbeat(self):
# def _heartbeat(self):
# def messagesReceived(self, msg_list):
# def __init__(self, conn, server, base, name):
# def send_message(self, msg, stats=True):
# def messageReceived(self, msg):
# def close(self, code=3000, message='Go away!'):
# def _close(self, code=3000, message='Go away!'):
#
# Path: sockjs/cyclone/transports/base.py
# class BaseTransportMixin(object):
# class MultiplexTransport(BaseTransportMixin):
# def get_conn_info(self):
# def session_closed(self):
# def __init__(self, conn_info):
# def get_conn_info(self):
#
# Path: sockjs/cyclone/websocket.py
# class WebSocketHandler(cyclone.websocket.WebSocketHandler):
# def _execute(self, *args, **kwargs):
# def _closeIfInvalidMethod(self):
# def _writeAndClose(self, resp):
# def _closeIfInvalidUpgradeHeader(self):
# def _closeIfInvalidConnectionHeader(self):
. Output only the next line. | self.conn.messageReceived(msg) |
Here is a snippet: <|code_start|>
class ConnectionInfoTest(unittest.TestCase):
def test_get_cookie(self):
c = ConnectionInfo(None, dict(cookie='mycookie'), None, {}, None)
self.assertEquals(c.get_cookie('cookie'), 'mycookie')
def test_get_cookie_returns_None_on_not_found(self):
c = ConnectionInfo(None, dict(), None, {}, None)
self.assertTrue(c.get_cookie('cookie') is None)
def test_get_argument(self):
c = ConnectionInfo(None, None, dict(arg=('myarg', '')), {}, None)
self.assertEquals(c.get_argument('arg'), 'myarg')
<|code_end|>
. Write the next line using the current file imports:
from twisted.trial import unittest
from sockjs.cyclone.session import SessionMixin
from sockjs.cyclone.conn import ConnectionInfo
and context from other files:
# Path: sockjs/cyclone/session.py
# class SessionMixin(object):
# """ Represents one session object stored in the session container.
# Derive from this object to store additional data.
# """
#
# def __init__(self, session_id=None, expiry=None, time_module=time):
# """ Constructor.
#
# @param session_id: Optional session id. If not provided, will generate
# new session id.
#
# @param expiry: Expiration time in seconds. If not provided, will never
# expire.
#
# @param time_module: only used for unit testing. A provider for a time()
# function
# """
# self.time_module = time_module
#
# self.session_id = session_id or self._random_key()
# self.promoted = None
# self.expiry = expiry
#
# if self.expiry is not None:
# self.expiry_date = self.time_module.time() + self.expiry
#
# def _random_key(self):
# """ Return random session key """
# hashstr = '%s%s' % (random.random(), self.time_module.time())
# return hashlib.md5(hashstr).hexdigest()
#
# def is_alive(self):
# """ Check if session is still alive """
# return self.expiry_date > self.time_module.time()
#
# def promote(self):
# """ Mark object as alive, so it won't be collected during next
# run of the garbage collector.
# """
# if self.expiry is not None:
# self.promoted = self.time_module.time() + self.expiry
#
# def on_delete(self, forced):
# """ Triggered when object was expired or deleted. """
# pass
#
# def __cmp__(self, other):
# return cmp(self.expiry_date, other.expiry_date)
#
# def __repr__(self):
# return '%f %s %d' % (getattr(self, 'expiry_date', -1),
# self.session_id,
# self.promoted or 0)
#
# Path: sockjs/cyclone/conn.py
# class ConnectionInfo(object):
# """ Connection information object.
#
# Will be passed to the C{connectionMade} handler of your connection class.
#
# Has few properties:
#
# @cvar ip: Caller IP address
#
# @cvar cookies: Collection of cookies
#
# @cvar arguments: Collection of the query string arguments
#
# @cvar headers: a selection of the request's headers
#
# @cvar path: uri's path of the request
# """
#
# _exposed_headers = set( ('origin', 'referer', 'x-client-ip',
# 'x-forwarded-for', 'x-cluster-client-ip',
# 'user-agent')
# )
#
# def __init__(self, ip, cookies, arguments, headers, path):
# self.ip = ip
# self.cookies = cookies
# self.arguments = arguments
# self.path = path
# self._expose_headers(headers)
#
# def _expose_headers(self, headers):
# self.headers = {}
# for header_name, header_value in headers.iteritems():
# if header_name.lower() in self._exposed_headers:
# self.headers[header_name] = header_value
#
# def get_header(self, name):
# """ Return a single header by name
# """
# return self.headers.get(name)
#
# def get_argument(self, name):
# """ Return single argument by name """
# val = self.arguments.get(name)
# if val:
# return val[0]
# return None
#
# def get_cookie(self, name):
# """ Return single cookie by its name """
# return self.cookies.get(name)
, which may include functions, classes, or code. Output only the next line. | def test_get_argument_returns_None_on_not_found(self): |
Given the code snippet: <|code_start|>
def test_get_argument(self):
c = ConnectionInfo(None, None, dict(arg=('myarg', '')), {}, None)
self.assertEquals(c.get_argument('arg'), 'myarg')
def test_get_argument_returns_None_on_not_found(self):
c = ConnectionInfo(None, None, dict(), {}, None)
self.assertTrue(c.get_argument('arg') is None)
def test_dont_expose_unknown_headers(self):
c = ConnectionInfo(None, None, {}, {'StrangeHeader': '42'}, None)
self.assertTrue(c.get_header('StrangeHeader') is None)
def test_expose_whitelisted_headers(self):
headers = dict((h, '42') for h in ConnectionInfo._exposed_headers)
c = ConnectionInfo(None, None, {}, headers, None)
for h in headers.keys():
self.assertTrue(c.get_header(h) is not None)
class TimeMock(object):
def __init__(self, returned_time):
self.returned_time = returned_time
def set(self, time):
self.returned_time = time
def time(self):
return self.returned_time
<|code_end|>
, generate the next line using the imports in this file:
from twisted.trial import unittest
from sockjs.cyclone.session import SessionMixin
from sockjs.cyclone.conn import ConnectionInfo
and context (functions, classes, or occasionally code) from other files:
# Path: sockjs/cyclone/session.py
# class SessionMixin(object):
# """ Represents one session object stored in the session container.
# Derive from this object to store additional data.
# """
#
# def __init__(self, session_id=None, expiry=None, time_module=time):
# """ Constructor.
#
# @param session_id: Optional session id. If not provided, will generate
# new session id.
#
# @param expiry: Expiration time in seconds. If not provided, will never
# expire.
#
# @param time_module: only used for unit testing. A provider for a time()
# function
# """
# self.time_module = time_module
#
# self.session_id = session_id or self._random_key()
# self.promoted = None
# self.expiry = expiry
#
# if self.expiry is not None:
# self.expiry_date = self.time_module.time() + self.expiry
#
# def _random_key(self):
# """ Return random session key """
# hashstr = '%s%s' % (random.random(), self.time_module.time())
# return hashlib.md5(hashstr).hexdigest()
#
# def is_alive(self):
# """ Check if session is still alive """
# return self.expiry_date > self.time_module.time()
#
# def promote(self):
# """ Mark object as alive, so it won't be collected during next
# run of the garbage collector.
# """
# if self.expiry is not None:
# self.promoted = self.time_module.time() + self.expiry
#
# def on_delete(self, forced):
# """ Triggered when object was expired or deleted. """
# pass
#
# def __cmp__(self, other):
# return cmp(self.expiry_date, other.expiry_date)
#
# def __repr__(self):
# return '%f %s %d' % (getattr(self, 'expiry_date', -1),
# self.session_id,
# self.promoted or 0)
#
# Path: sockjs/cyclone/conn.py
# class ConnectionInfo(object):
# """ Connection information object.
#
# Will be passed to the C{connectionMade} handler of your connection class.
#
# Has few properties:
#
# @cvar ip: Caller IP address
#
# @cvar cookies: Collection of cookies
#
# @cvar arguments: Collection of the query string arguments
#
# @cvar headers: a selection of the request's headers
#
# @cvar path: uri's path of the request
# """
#
# _exposed_headers = set( ('origin', 'referer', 'x-client-ip',
# 'x-forwarded-for', 'x-cluster-client-ip',
# 'user-agent')
# )
#
# def __init__(self, ip, cookies, arguments, headers, path):
# self.ip = ip
# self.cookies = cookies
# self.arguments = arguments
# self.path = path
# self._expose_headers(headers)
#
# def _expose_headers(self, headers):
# self.headers = {}
# for header_name, header_value in headers.iteritems():
# if header_name.lower() in self._exposed_headers:
# self.headers[header_name] = header_value
#
# def get_header(self, name):
# """ Return a single header by name
# """
# return self.headers.get(name)
#
# def get_argument(self, name):
# """ Return single argument by name """
# val = self.arguments.get(name)
# if val:
# return val[0]
# return None
#
# def get_cookie(self, name):
# """ Return single cookie by its name """
# return self.cookies.get(name)
. Output only the next line. | class SessionMixinTest(unittest.TestCase): |
Predict the next line after this snippet: <|code_start|>
class SockJSConnection(object):
def __init__(self, session):
""" Connection constructor.
@param session: Associated session
"""
self.session = session
# Public API
def connectionMade(self, request):
""" Default connectionMade() handler.
Override when you need to do some initialization or request validation.
If you return False, connection will be rejected.
You can also throw cyclone HTTPError to close connection.
@param request: C{ConnectionInfo} object which contains caller IP
address, query string parameters and cookies associated
with this request (if any).
@type request: C{ConnectionInfo}
"""
pass
def messageReceived(self, message):
""" Default messageReceived handler. Must be overridden in your
application """
raise NotImplementedError()
<|code_end|>
using the current file's imports:
from twisted.python import log
from sockjs.cyclone.transports import base
from sockjs.cyclone.session import MultiplexChannelSession
and any relevant context from other files:
# Path: sockjs/cyclone/transports/base.py
# class BaseTransportMixin(object):
# class MultiplexTransport(BaseTransportMixin):
# def get_conn_info(self):
# def session_closed(self):
# def __init__(self, conn_info):
# def get_conn_info(self):
#
# Path: sockjs/cyclone/session.py
# class MultiplexChannelSession(BaseSession):
# def __init__(self, conn, server, base, name):
# super(MultiplexChannelSession, self).__init__(conn, server)
#
# self.base = base
# self.name = name
#
# def send_message(self, msg, stats=True):
# if not self.base.is_closed:
# msg = 'msg,%s,%s' % (self.name, msg)
# self.base.session.send_message(msg, stats)
#
# def messageReceived(self, msg):
# self.conn.messageReceived(msg)
#
# def close(self, code=3000, message='Go away!'):
# self.base.sendMessage('uns,%s' % self.name)
# self._close(code, message)
#
# # Non-API version of the close, without sending the close message
# def _close(self, code=3000, message='Go away!'):
# super(MultiplexChannelSession, self).close(code, message)
. Output only the next line. | def connectionLost(self): |
Predict the next line for this snippet: <|code_start|>
def M(metric_name):
"""Makes a full metric name from a short metric name.
This is just intended to help keep the lines shorter in test
cases.
"""
return "django_http_%s" % metric_name
def T(metric_name):
"""Makes a full metric name from a short metric name like M(metric_name)
This method adds a '_total' postfix for metrics."""
return "%s_total" % M(metric_name)
@override_settings(
<|code_end|>
with the help of current file imports:
from django.test import SimpleTestCase, override_settings
from testapp.views import ObjectionException
from django_prometheus.testutils import PrometheusTestCaseMixin
and context from other files:
# Path: django_prometheus/testutils.py
# class PrometheusTestCaseMixin:
# """A collection of utilities that make it easier to write test cases
# that interact with metrics.
# """
#
# def saveRegistry(self, registry=REGISTRY):
# """Freezes a registry. This lets a user test changes to a metric
# instead of testing the absolute value. A typical use case looks like:
#
# registry = self.saveRegistry()
# doStuff()
# self.assertMetricDiff(registry, 1, 'stuff_done_total')
# """
# return copy.deepcopy(list(registry.collect()))
#
# def getMetricFromFrozenRegistry(self, metric_name, frozen_registry, **labels):
# """Gets a single metric from a frozen registry."""
# for metric in frozen_registry:
# for sample in metric.samples:
# if sample[0] == metric_name and sample[1] == labels:
# return sample[2]
#
# def getMetric(self, metric_name, registry=REGISTRY, **labels):
# """Gets a single metric."""
# return self.getMetricFromFrozenRegistry(
# metric_name, registry.collect(), **labels
# )
#
# def getMetricVectorFromFrozenRegistry(self, metric_name, frozen_registry):
# """Like getMetricVector, but from a frozen registry."""
# output = []
# for metric in frozen_registry:
# for sample in metric.samples:
# if sample[0] == metric_name:
# output.append((sample[1], sample[2]))
# return output
#
# def getMetricVector(self, metric_name, registry=REGISTRY):
# """Returns the values for all labels of a given metric.
#
# The result is returned as a list of (labels, value) tuples,
# where `labels` is a dict.
#
# This is quite a hack since it relies on the internal
# representation of the prometheus_client, and it should
# probably be provided as a function there instead.
# """
# return self.getMetricVectorFromFrozenRegistry(metric_name, registry.collect())
#
# def formatLabels(self, labels):
# """Format a set of labels to Prometheus representation.
#
# In:
# {'method': 'GET', 'port': '80'}
#
# Out:
# '{method="GET",port="80"}'
# """
# return "{%s}" % ",".join([f'{k}="{v}"' for k, v in labels.items()])
#
# def formatVector(self, vector):
# """Formats a list of (labels, value) where labels is a dict into a
# human-readable representation.
# """
# return "\n".join(
# [
# "{} = {}".format(self.formatLabels(labels), value)
# for labels, value in vector
# ]
# )
#
# def assertMetricEquals(
# self, expected_value, metric_name, registry=REGISTRY, **labels
# ):
# """Asserts that metric_name{**labels} == expected_value."""
# value = self.getMetric(metric_name, registry=registry, **labels)
# self.assertEqual(
# expected_value,
# value,
# METRIC_EQUALS_ERR_EXPLANATION
# % (
# metric_name,
# self.formatLabels(labels),
# value,
# expected_value,
# metric_name,
# self.formatVector(self.getMetricVector(metric_name)),
# ),
# )
#
# def assertMetricDiff(
# self, frozen_registry, expected_diff, metric_name, registry=REGISTRY, **labels
# ):
# """Asserts that metric_name{**labels} changed by expected_diff between
# the frozen registry and now. A frozen registry can be obtained
# by calling saveRegistry, typically at the beginning of a test
# case.
# """
# saved_value = self.getMetricFromFrozenRegistry(
# metric_name, frozen_registry, **labels
# )
# current_value = self.getMetric(metric_name, registry=registry, **labels)
# assert current_value is not None, METRIC_DIFF_ERR_NONE_EXPLANATION % (
# metric_name,
# self.formatLabels(labels),
# saved_value,
# current_value,
# )
# diff = current_value - (saved_value or 0.0)
# self.assertEqual(
# expected_diff,
# diff,
# METRIC_DIFF_ERR_EXPLANATION
# % (
# metric_name,
# self.formatLabels(labels),
# diff,
# expected_diff,
# saved_value,
# current_value,
# ),
# )
#
# def assertMetricCompare(
# self, frozen_registry, predicate, metric_name, registry=REGISTRY, **labels
# ):
# """Asserts that metric_name{**labels} changed according to a provided
# predicate function between the frozen registry and now. A
# frozen registry can be obtained by calling saveRegistry,
# typically at the beginning of a test case.
# """
# saved_value = self.getMetricFromFrozenRegistry(
# metric_name, frozen_registry, **labels
# )
# current_value = self.getMetric(metric_name, registry=registry, **labels)
# assert current_value is not None, METRIC_DIFF_ERR_NONE_EXPLANATION % (
# metric_name,
# self.formatLabels(labels),
# saved_value,
# current_value,
# )
# assert (
# predicate(saved_value, current_value) is True
# ), METRIC_COMPARE_ERR_EXPLANATION % (
# metric_name,
# self.formatLabels(labels),
# saved_value,
# current_value,
# )
, which may contain function names, class names, or code. Output only the next line. | PROMETHEUS_LATENCY_BUCKETS=(0.05, 1.0, 2.0, 4.0, 5.0, 10.0, float("inf")) |
Given the following code snippet before the placeholder: <|code_start|>
class DjangoPrometheusConfig(AppConfig):
name = django_prometheus.__name__
verbose_name = "Django-Prometheus"
<|code_end|>
, predict the next line using imports from the current file:
from django.apps import AppConfig
from django.conf import settings
from django_prometheus.exports import SetupPrometheusExportsFromConfig
from django_prometheus.migrations import ExportMigrations
import django_prometheus
and context including class names, function names, and sometimes code from other files:
# Path: django_prometheus/exports.py
# def SetupPrometheusExportsFromConfig():
# """Exports metrics so Prometheus can collect them."""
# port = getattr(settings, "PROMETHEUS_METRICS_EXPORT_PORT", None)
# port_range = getattr(settings, "PROMETHEUS_METRICS_EXPORT_PORT_RANGE", None)
# addr = getattr(settings, "PROMETHEUS_METRICS_EXPORT_ADDRESS", "")
# if port_range:
# SetupPrometheusEndpointOnPortRange(port_range, addr)
# elif port:
# SetupPrometheusEndpointOnPort(port, addr)
#
# Path: django_prometheus/migrations.py
# def ExportMigrations():
# """Exports counts of unapplied migrations.
#
# This is meant to be called during app startup, ideally by
# django_prometheus.apps.AppConfig.
# """
#
# # Import MigrationExecutor lazily. MigrationExecutor checks at
# # import time that the apps are ready, and they are not when
# # django_prometheus is imported. ExportMigrations() should be
# # called in AppConfig.ready(), which signals that all apps are
# # ready.
# from django.db.migrations.executor import MigrationExecutor
#
# if "default" in connections and (
# isinstance(connections["default"], DatabaseWrapper)
# ):
# # This is the case where DATABASES = {} in the configuration,
# # i.e. the user is not using any databases. Django "helpfully"
# # adds a dummy database and then throws when you try to
# # actually use it. So we don't do anything, because trying to
# # export stats would crash the app on startup.
# return
# for alias in connections.databases:
# executor = MigrationExecutor(connections[alias])
# ExportMigrationsForDatabase(alias, executor)
. Output only the next line. | def ready(self): |
Predict the next line after this snippet: <|code_start|>
class DatabaseWrapper(DatabaseWrapperMixin, base.DatabaseWrapper):
def get_connection_params(self):
conn_params = super().get_connection_params()
conn_params["cursor_factory"] = ExportingCursorWrapper(
<|code_end|>
using the current file's imports:
import psycopg2.extensions
from django.contrib.gis.db.backends.postgis import base
from django_prometheus.db.common import DatabaseWrapperMixin, ExportingCursorWrapper
and any relevant context from other files:
# Path: django_prometheus/db/common.py
# class DatabaseWrapperMixin:
# """Extends the DatabaseWrapper to count connections and cursors."""
#
# def get_new_connection(self, *args, **kwargs):
# connections_total.labels(self.alias, self.vendor).inc()
# try:
# return super().get_new_connection(*args, **kwargs)
# except Exception:
# connection_errors_total.labels(self.alias, self.vendor).inc()
# raise
#
# def create_cursor(self, name=None):
# return self.connection.cursor(
# factory=ExportingCursorWrapper(self.CURSOR_CLASS, self.alias, self.vendor)
# )
#
# def ExportingCursorWrapper(cursor_class, alias, vendor):
# """Returns a CursorWrapper class that knows its database's alias and
# vendor name.
# """
#
# labels = {"alias": alias, "vendor": vendor}
#
# class CursorWrapper(cursor_class):
# """Extends the base CursorWrapper to count events."""
#
# def execute(self, *args, **kwargs):
# execute_total.labels(alias, vendor).inc()
# with query_duration_seconds.labels(**labels).time(), (
# ExceptionCounterByType(errors_total, extra_labels=labels)
# ):
# return super().execute(*args, **kwargs)
#
# def executemany(self, query, param_list, *args, **kwargs):
# execute_total.labels(alias, vendor).inc(len(param_list))
# execute_many_total.labels(alias, vendor).inc(len(param_list))
# with query_duration_seconds.labels(**labels).time(), (
# ExceptionCounterByType(errors_total, extra_labels=labels)
# ):
# return super().executemany(query, param_list, *args, **kwargs)
#
# return CursorWrapper
. Output only the next line. | psycopg2.extensions.cursor, "postgis", self.vendor |
Predict the next line after this snippet: <|code_start|>
class DatabaseWrapper(DatabaseWrapperMixin, base.DatabaseWrapper):
def get_connection_params(self):
conn_params = super().get_connection_params()
conn_params["cursor_factory"] = ExportingCursorWrapper(
psycopg2.extensions.cursor, "postgis", self.vendor
)
<|code_end|>
using the current file's imports:
import psycopg2.extensions
from django.contrib.gis.db.backends.postgis import base
from django_prometheus.db.common import DatabaseWrapperMixin, ExportingCursorWrapper
and any relevant context from other files:
# Path: django_prometheus/db/common.py
# class DatabaseWrapperMixin:
# """Extends the DatabaseWrapper to count connections and cursors."""
#
# def get_new_connection(self, *args, **kwargs):
# connections_total.labels(self.alias, self.vendor).inc()
# try:
# return super().get_new_connection(*args, **kwargs)
# except Exception:
# connection_errors_total.labels(self.alias, self.vendor).inc()
# raise
#
# def create_cursor(self, name=None):
# return self.connection.cursor(
# factory=ExportingCursorWrapper(self.CURSOR_CLASS, self.alias, self.vendor)
# )
#
# def ExportingCursorWrapper(cursor_class, alias, vendor):
# """Returns a CursorWrapper class that knows its database's alias and
# vendor name.
# """
#
# labels = {"alias": alias, "vendor": vendor}
#
# class CursorWrapper(cursor_class):
# """Extends the base CursorWrapper to count events."""
#
# def execute(self, *args, **kwargs):
# execute_total.labels(alias, vendor).inc()
# with query_duration_seconds.labels(**labels).time(), (
# ExceptionCounterByType(errors_total, extra_labels=labels)
# ):
# return super().execute(*args, **kwargs)
#
# def executemany(self, query, param_list, *args, **kwargs):
# execute_total.labels(alias, vendor).inc(len(param_list))
# execute_many_total.labels(alias, vendor).inc(len(param_list))
# with query_duration_seconds.labels(**labels).time(), (
# ExceptionCounterByType(errors_total, extra_labels=labels)
# ):
# return super().executemany(query, param_list, *args, **kwargs)
#
# return CursorWrapper
. Output only the next line. | return conn_params |
Here is a snippet: <|code_start|> story = story.merge(meta=meta, flavors=flavors)
self.assert_formatted_equals(expected, story)
def test_edge_meta(self, story):
"""
Tests story formatting with some edge cases.
"""
flavors: Set[Flavor] = {
MetaPurity.DIRTY,
}
meta: Dict[str, Any] = {
'title': None,
'author': {},
'status': {},
'words': 0,
'likes': 0,
'dislikes': 0,
'chapters': (),
}
expected = """
Title: None
Author: None
Status: {}
Words: 0
Likes: 0
Dislikes: 0
Approval: 0%
Chapters: 0
<|code_end|>
. Write the next line using the current file imports:
from textwrap import dedent
from typing import Any, Dict, Set
from fimfarchive.flavors import Flavor, MetaPurity, UpdateStatus
from fimfarchive.commands.update import StoryFormatter
and context from other files:
# Path: fimfarchive/flavors.py
# class Flavor(Enum):
# """
# Base class for flavors.
# """
#
# def __new__(cls, *args):
# """
# Automatically assigns an enum value.
# """
# value = len(cls.__members__) + 1
# obj = object.__new__(cls)
# obj._value_ = value
# return obj
#
# def __repr__(self):
# """
# Custom representation for instances.
# """
# return "<flavor '{}.{}'>".format(
# type(self).__name__,
# getattr(self, 'name', None),
# )
#
# class MetaPurity(Flavor):
# """
# Indicates if story meta has been sanitized.
# """
# CLEAN = ()
# DIRTY = ()
#
# class UpdateStatus(Flavor):
# """
# Indicates if and how a story has changed.
# """
# CREATED = ()
# REVIVED = ()
# UPDATED = ()
# DELETED = ()
#
# Path: fimfarchive/commands/update.py
# class StoryFormatter(Iterable[str]):
# """
# Generates a text representation of story meta.
# """
# attrs = (
# 'title',
# 'author',
# 'status',
# 'words',
# 'likes',
# 'dislikes',
# 'approval',
# 'chapters',
# 'action',
# )
#
# paths = {
# 'author': jmes('author.name'),
# 'status': jmes('completion_status || status'),
# 'words': jmes('num_words || words'),
# 'likes': jmes('num_likes || likes'),
# 'dislikes': jmes('num_dislikes || dislikes'),
# }
#
# def __init__(self, story: Story) -> None:
# """
# Constructor.
#
# Args:
# story: Instance to represent.
# """
# self.story = story
#
# def __getattr__(self, key: str) -> Any:
# """
# Returns a value from story meta, or None.
# """
# meta = self.story.meta
# path = self.paths.get(key)
#
# if path:
# return path.search(meta)
# else:
# return meta.get(key)
#
# def __iter__(self) -> Iterator[str]:
# """
# Yields the text representation line by line.
# """
# for attr in self.attrs:
# label = attr.capitalize()
# value = getattr(self, attr)
# yield f"{label}: {value}"
#
# def __str__(self) -> str:
# """
# Returns the entire text representation.
# """
# return '\n'.join(self)
#
# @property
# def approval(self) -> Optional[str]:
# """
# Returns the likes to dislikes ratio, or None.
# """
# likes = self.likes
# dislikes = self.dislikes
#
# try:
# ratio = likes / (likes + dislikes)
# except TypeError:
# return None
# except ZeroDivisionError:
# return f"{0:.0%}"
# else:
# return f"{ratio:.0%}"
#
# @property
# def chapters(self) -> Optional[int]:
# """
# Returns the number of chapters, or None.
# """
# meta = self.story.meta
# chapters = meta.get('chapters')
#
# if chapters is None:
# return None
#
# return len(chapters)
#
# @property
# def action(self) -> Optional[str]:
# """
# Returns the `UpdateStatus` name, or None.
# """
# for flavor in self.story.flavors:
# if isinstance(flavor, UpdateStatus):
# return flavor.name.capitalize()
#
# return None
, which may include functions, classes, or code. Output only the next line. | Action: None |
Next line prediction: <|code_start|> def test_old_meta(self, story):
"""
Tests story formatting with old-style meta.
"""
flavors: Set[Flavor] = {
UpdateStatus.CREATED,
}
meta: Dict[str, Any] = {
'title': 'A',
'author': {
'name': 'B'
},
'status': 'C',
'words': 4,
'likes': 3,
'dislikes': 2,
'chapters': [
1
],
}
expected = """
Title: A
Author: B
Status: C
Words: 4
Likes: 3
Dislikes: 2
Approval: 60%
<|code_end|>
. Use current file imports:
(from textwrap import dedent
from typing import Any, Dict, Set
from fimfarchive.flavors import Flavor, MetaPurity, UpdateStatus
from fimfarchive.commands.update import StoryFormatter)
and context including class names, function names, or small code snippets from other files:
# Path: fimfarchive/flavors.py
# class Flavor(Enum):
# """
# Base class for flavors.
# """
#
# def __new__(cls, *args):
# """
# Automatically assigns an enum value.
# """
# value = len(cls.__members__) + 1
# obj = object.__new__(cls)
# obj._value_ = value
# return obj
#
# def __repr__(self):
# """
# Custom representation for instances.
# """
# return "<flavor '{}.{}'>".format(
# type(self).__name__,
# getattr(self, 'name', None),
# )
#
# class MetaPurity(Flavor):
# """
# Indicates if story meta has been sanitized.
# """
# CLEAN = ()
# DIRTY = ()
#
# class UpdateStatus(Flavor):
# """
# Indicates if and how a story has changed.
# """
# CREATED = ()
# REVIVED = ()
# UPDATED = ()
# DELETED = ()
#
# Path: fimfarchive/commands/update.py
# class StoryFormatter(Iterable[str]):
# """
# Generates a text representation of story meta.
# """
# attrs = (
# 'title',
# 'author',
# 'status',
# 'words',
# 'likes',
# 'dislikes',
# 'approval',
# 'chapters',
# 'action',
# )
#
# paths = {
# 'author': jmes('author.name'),
# 'status': jmes('completion_status || status'),
# 'words': jmes('num_words || words'),
# 'likes': jmes('num_likes || likes'),
# 'dislikes': jmes('num_dislikes || dislikes'),
# }
#
# def __init__(self, story: Story) -> None:
# """
# Constructor.
#
# Args:
# story: Instance to represent.
# """
# self.story = story
#
# def __getattr__(self, key: str) -> Any:
# """
# Returns a value from story meta, or None.
# """
# meta = self.story.meta
# path = self.paths.get(key)
#
# if path:
# return path.search(meta)
# else:
# return meta.get(key)
#
# def __iter__(self) -> Iterator[str]:
# """
# Yields the text representation line by line.
# """
# for attr in self.attrs:
# label = attr.capitalize()
# value = getattr(self, attr)
# yield f"{label}: {value}"
#
# def __str__(self) -> str:
# """
# Returns the entire text representation.
# """
# return '\n'.join(self)
#
# @property
# def approval(self) -> Optional[str]:
# """
# Returns the likes to dislikes ratio, or None.
# """
# likes = self.likes
# dislikes = self.dislikes
#
# try:
# ratio = likes / (likes + dislikes)
# except TypeError:
# return None
# except ZeroDivisionError:
# return f"{0:.0%}"
# else:
# return f"{ratio:.0%}"
#
# @property
# def chapters(self) -> Optional[int]:
# """
# Returns the number of chapters, or None.
# """
# meta = self.story.meta
# chapters = meta.get('chapters')
#
# if chapters is None:
# return None
#
# return len(chapters)
#
# @property
# def action(self) -> Optional[str]:
# """
# Returns the `UpdateStatus` name, or None.
# """
# for flavor in self.story.flavors:
# if isinstance(flavor, UpdateStatus):
# return flavor.name.capitalize()
#
# return None
. Output only the next line. | Chapters: 1 |
Given the following code snippet before the placeholder: <|code_start|> def test_new_meta(self, story):
"""
Tests story formatting with new-style meta.
"""
flavors: Set[Flavor] = {
UpdateStatus.CREATED,
}
meta: Dict[str, Any] = {
'title': 'A',
'author': {
'name': 'B'
},
'status': 'visible',
'completion_status': 'C',
'num_words': 4,
'num_likes': 3,
'num_dislikes': 2,
'chapters': [
1
],
}
expected = """
Title: A
Author: B
Status: C
Words: 4
Likes: 3
Dislikes: 2
<|code_end|>
, predict the next line using imports from the current file:
from textwrap import dedent
from typing import Any, Dict, Set
from fimfarchive.flavors import Flavor, MetaPurity, UpdateStatus
from fimfarchive.commands.update import StoryFormatter
and context including class names, function names, and sometimes code from other files:
# Path: fimfarchive/flavors.py
# class Flavor(Enum):
# """
# Base class for flavors.
# """
#
# def __new__(cls, *args):
# """
# Automatically assigns an enum value.
# """
# value = len(cls.__members__) + 1
# obj = object.__new__(cls)
# obj._value_ = value
# return obj
#
# def __repr__(self):
# """
# Custom representation for instances.
# """
# return "<flavor '{}.{}'>".format(
# type(self).__name__,
# getattr(self, 'name', None),
# )
#
# class MetaPurity(Flavor):
# """
# Indicates if story meta has been sanitized.
# """
# CLEAN = ()
# DIRTY = ()
#
# class UpdateStatus(Flavor):
# """
# Indicates if and how a story has changed.
# """
# CREATED = ()
# REVIVED = ()
# UPDATED = ()
# DELETED = ()
#
# Path: fimfarchive/commands/update.py
# class StoryFormatter(Iterable[str]):
# """
# Generates a text representation of story meta.
# """
# attrs = (
# 'title',
# 'author',
# 'status',
# 'words',
# 'likes',
# 'dislikes',
# 'approval',
# 'chapters',
# 'action',
# )
#
# paths = {
# 'author': jmes('author.name'),
# 'status': jmes('completion_status || status'),
# 'words': jmes('num_words || words'),
# 'likes': jmes('num_likes || likes'),
# 'dislikes': jmes('num_dislikes || dislikes'),
# }
#
# def __init__(self, story: Story) -> None:
# """
# Constructor.
#
# Args:
# story: Instance to represent.
# """
# self.story = story
#
# def __getattr__(self, key: str) -> Any:
# """
# Returns a value from story meta, or None.
# """
# meta = self.story.meta
# path = self.paths.get(key)
#
# if path:
# return path.search(meta)
# else:
# return meta.get(key)
#
# def __iter__(self) -> Iterator[str]:
# """
# Yields the text representation line by line.
# """
# for attr in self.attrs:
# label = attr.capitalize()
# value = getattr(self, attr)
# yield f"{label}: {value}"
#
# def __str__(self) -> str:
# """
# Returns the entire text representation.
# """
# return '\n'.join(self)
#
# @property
# def approval(self) -> Optional[str]:
# """
# Returns the likes to dislikes ratio, or None.
# """
# likes = self.likes
# dislikes = self.dislikes
#
# try:
# ratio = likes / (likes + dislikes)
# except TypeError:
# return None
# except ZeroDivisionError:
# return f"{0:.0%}"
# else:
# return f"{ratio:.0%}"
#
# @property
# def chapters(self) -> Optional[int]:
# """
# Returns the number of chapters, or None.
# """
# meta = self.story.meta
# chapters = meta.get('chapters')
#
# if chapters is None:
# return None
#
# return len(chapters)
#
# @property
# def action(self) -> Optional[str]:
# """
# Returns the `UpdateStatus` name, or None.
# """
# for flavor in self.story.flavors:
# if isinstance(flavor, UpdateStatus):
# return flavor.name.capitalize()
#
# return None
. Output only the next line. | Approval: 60% |
Next line prediction: <|code_start|>#
class TestStoryFormatter():
"""
StoryFormatter tests.
"""
def assert_formatted_equals(self, expected, story):
"""
Asserts that the formatted story matches the expected text.
"""
formatted = str(StoryFormatter(story))
dedented = dedent(expected).strip()
assert dedented == formatted
def test_empty_meta(self, story):
"""
Tests story formatting with empty meta.
"""
flavors: Set[Flavor] = set()
meta: Dict[str, Any] = dict()
expected = """
Title: None
Author: None
<|code_end|>
. Use current file imports:
(from textwrap import dedent
from typing import Any, Dict, Set
from fimfarchive.flavors import Flavor, MetaPurity, UpdateStatus
from fimfarchive.commands.update import StoryFormatter)
and context including class names, function names, or small code snippets from other files:
# Path: fimfarchive/flavors.py
# class Flavor(Enum):
# """
# Base class for flavors.
# """
#
# def __new__(cls, *args):
# """
# Automatically assigns an enum value.
# """
# value = len(cls.__members__) + 1
# obj = object.__new__(cls)
# obj._value_ = value
# return obj
#
# def __repr__(self):
# """
# Custom representation for instances.
# """
# return "<flavor '{}.{}'>".format(
# type(self).__name__,
# getattr(self, 'name', None),
# )
#
# class MetaPurity(Flavor):
# """
# Indicates if story meta has been sanitized.
# """
# CLEAN = ()
# DIRTY = ()
#
# class UpdateStatus(Flavor):
# """
# Indicates if and how a story has changed.
# """
# CREATED = ()
# REVIVED = ()
# UPDATED = ()
# DELETED = ()
#
# Path: fimfarchive/commands/update.py
# class StoryFormatter(Iterable[str]):
# """
# Generates a text representation of story meta.
# """
# attrs = (
# 'title',
# 'author',
# 'status',
# 'words',
# 'likes',
# 'dislikes',
# 'approval',
# 'chapters',
# 'action',
# )
#
# paths = {
# 'author': jmes('author.name'),
# 'status': jmes('completion_status || status'),
# 'words': jmes('num_words || words'),
# 'likes': jmes('num_likes || likes'),
# 'dislikes': jmes('num_dislikes || dislikes'),
# }
#
# def __init__(self, story: Story) -> None:
# """
# Constructor.
#
# Args:
# story: Instance to represent.
# """
# self.story = story
#
# def __getattr__(self, key: str) -> Any:
# """
# Returns a value from story meta, or None.
# """
# meta = self.story.meta
# path = self.paths.get(key)
#
# if path:
# return path.search(meta)
# else:
# return meta.get(key)
#
# def __iter__(self) -> Iterator[str]:
# """
# Yields the text representation line by line.
# """
# for attr in self.attrs:
# label = attr.capitalize()
# value = getattr(self, attr)
# yield f"{label}: {value}"
#
# def __str__(self) -> str:
# """
# Returns the entire text representation.
# """
# return '\n'.join(self)
#
# @property
# def approval(self) -> Optional[str]:
# """
# Returns the likes to dislikes ratio, or None.
# """
# likes = self.likes
# dislikes = self.dislikes
#
# try:
# ratio = likes / (likes + dislikes)
# except TypeError:
# return None
# except ZeroDivisionError:
# return f"{0:.0%}"
# else:
# return f"{ratio:.0%}"
#
# @property
# def chapters(self) -> Optional[int]:
# """
# Returns the number of chapters, or None.
# """
# meta = self.story.meta
# chapters = meta.get('chapters')
#
# if chapters is None:
# return None
#
# return len(chapters)
#
# @property
# def action(self) -> Optional[str]:
# """
# Returns the `UpdateStatus` name, or None.
# """
# for flavor in self.story.flavors:
# if isinstance(flavor, UpdateStatus):
# return flavor.name.capitalize()
#
# return None
. Output only the next line. | Status: None |
Given the code snippet: <|code_start|>
self.assertTrue(pq.elements[0] == 6)
self.assertTrue(pq.elements[1] == 5)
self.assertTrue(pq.elements[2] == 4)
for i in xrange(3, len(pq.elements)):
self.assertTrue(pq.elements[i] is None)
def test_insert3(self):
pq = PriorityQueue()
pq.add_element(5)
pq.add_element(4)
pq.add_element(6)
self.assertTrue(pq.elements[0] == 6)
self.assertTrue(pq.elements[1] == 4)
self.assertTrue(pq.elements[2] == 5)
for i in xrange(3, len(pq.elements)):
self.assertTrue(pq.elements[i] is None)
def test_insert4(self):
pq = PriorityQueue()
pq.add_element(5)
pq.add_element(4)
pq.add_element(6)
pq.add_element(6)
pq.add_element(3)
pq.add_element(7)
self.assertTrue(pq.elements[0] == 7)
self.assertTrue(pq.elements[1] == 6)
<|code_end|>
, generate the next line using the imports in this file:
from unittest.case import TestCase
from data_structures.priority_queue import PriorityQueue
and context (functions, classes, or occasionally code) from other files:
# Path: data_structures/priority_queue.py
# class PriorityQueue:
#
# def __init__(self):
# self.elements = [None] * 100
# self.element_count = 0
#
# def add_element(self, element):
# self.elements[self.element_count] = element
# self.element_count += 1
# self.push_up(self.element_count - 1)
#
# def push_up(self, index):
# current_index = index
# parent = (current_index - 1) / 2
#
# while parent >= 0:
# if self.elements[parent] >= self.elements[current_index]:
# break
#
# temp = self.elements[current_index]
# self.elements[current_index] = self.elements[parent]
# self.elements[parent] = temp
#
# current_index = parent
# parent = (current_index - 1) / 2
#
# def push_down(self, index):
# current_index = index
# child_index = 2 * current_index + 1
#
# while child_index < self.element_count:
# max_child = child_index
# if child_index + 1 < self.element_count:
# if self.elements[child_index+1] > self.elements[child_index]:
# max_child = child_index + 1
#
# if self.elements[current_index] >= self.elements[max_child]:
# break
#
# temp = self.elements[max_child]
# self.elements[max_child] = self.elements[current_index]
# self.elements[current_index] = temp
#
# current_index = max_child
# child_index = 2 * current_index + 1
#
# def pop(self):
# if self.element_count == 0:
# return None
#
# self.element_count -= 1
# return_element = self.elements[0]
# self.elements[0] = None
#
# if self.element_count > 0:
# self.elements[0] = self.elements[self.element_count]
# self.elements[self.element_count] = None
# self.push_down(0)
#
# return return_element
#
# def batch_increment(self, validation_metod, update_method):
# for i in xrange(self.element_count):
# if validation_metod(self.elements[i]):
# update_method(self.elements[i])
# self.push_up(i)
#
# def batch_decrement(self, validation_method, update_method):
# for i in xrange(self.element_count - 1, -1, -1):
# if validation_method(self.elements[i]):
# update_method(self.elements[i])
# self.push_down(i)
#
# def __repr__(self):
# result = ''
# for i in xrange(self.element_count):
# result += str(self.elements[i]) + '\n'
#
# return result
. Output only the next line. | self.assertTrue(pq.elements[2] == 6) |
Predict the next line after this snippet: <|code_start|> self.assertTrue(self.algorithm.isConnected(1, 2))
def test_multiple_connect(self):
self.algorithm.connect(1, 2)
self.algorithm.connect(3, 4)
self.assertTrue(not self.algorithm.isConnected(2, 3))
self.algorithm.connect(1, 4)
self.assertTrue(self.algorithm.isConnected(2, 3))
self.assertTrue(self.algorithm.isConnected(2, 4))
self.assertTrue(not self.algorithm.isConnected(2, 9))
class QuickFindTests(UnionFindTests, TestCase):
def setUp(self):
self.algorithm = QuickFind(100)
class QuickUnionTests(UnionFindTests, TestCase):
def setUp(self):
self.algorithm = QuickUnion(100)
class WeightedQuickUnionTests(UnionFindTests, TestCase):
def setUp(self):
self.algorithm = WeightedQuickUnion(100)
<|code_end|>
using the current file's imports:
from unittest import TestCase
from unionfind.quickfind import QuickFind
from unionfind.quickunion import QuickUnion
from unionfind.weightedquickunion import WeightedQuickUnion
from unionfind.wquwithpathcompression import WQUWithPathCompression
and any relevant context from other files:
# Path: unionfind/quickfind.py
# class QuickFind(UnionFind):
#
# def __init__(self, n):
# UnionFind.__init__(self, n)
#
# def parent(self, index):
# return self.arr[index]
#
# def connect(self, item1, item2):
# pid1 = self.arr[item1]
# pid2 = self.arr[item2]
#
# for i in xrange(self.n):
# if self.arr[i] == pid2:
# self.arr[i] = pid1
#
# Path: unionfind/quickunion.py
# class QuickUnion(UnionFind):
#
# def __init__(self, n):
# UnionFind.__init__(self, n)
#
# def connect(self, item1, item2):
# pid1 = self.parent(item1)
# pid2 = self.parent(item2)
# self.arr[pid2] = pid1
#
# def parent(self, index):
# current_item = index
# while self.arr[current_item] != current_item:
# current_item = self.arr[current_item]
#
# return current_item
#
# Path: unionfind/weightedquickunion.py
# class WeightedQuickUnion(QuickUnion):
#
# def __init__(self, n):
# QuickUnion.__init__(self, n)
# self.item_counts = [1] * n
#
# def connect(self, item1, item2):
# pid1 = self.parent(item1)
# pid2 = self.parent(item2)
# if self.item_counts[pid1] > self.item_counts[pid2]:
# self.arr[pid2] = pid1
# self.item_counts[pid1] += self.item_counts[pid2]
# else:
# self.arr[pid1] = pid2
# self.item_counts[pid2] += self.item_counts[pid1]
#
# Path: unionfind/wquwithpathcompression.py
# class WQUWithPathCompression(WeightedQuickUnion):
#
# def __init__(self, n):
# WeightedQuickUnion.__init__(self, n)
#
# def parent(self, index):
# current_item = index
# while self.arr[current_item] != current_item:
# current_item = self.arr[current_item]
#
# update_index = index
# while self.arr[update_index] != current_item:
# parent_index = self.arr[update_index]
# self.arr[update_index] = current_item
# update_index = parent_index
#
# return current_item
. Output only the next line. | class WQUWithPathCompressionTests(UnionFindTests, TestCase): |
Given the following code snippet before the placeholder: <|code_start|>__author__ = 'orhan'
class UnionFindTests():
def test_initial(self):
self.assertEqual(self.algorithm.parent(1), 1)
def test_simple_connect(self):
<|code_end|>
, predict the next line using imports from the current file:
from unittest import TestCase
from unionfind.quickfind import QuickFind
from unionfind.quickunion import QuickUnion
from unionfind.weightedquickunion import WeightedQuickUnion
from unionfind.wquwithpathcompression import WQUWithPathCompression
and context including class names, function names, and sometimes code from other files:
# Path: unionfind/quickfind.py
# class QuickFind(UnionFind):
#
# def __init__(self, n):
# UnionFind.__init__(self, n)
#
# def parent(self, index):
# return self.arr[index]
#
# def connect(self, item1, item2):
# pid1 = self.arr[item1]
# pid2 = self.arr[item2]
#
# for i in xrange(self.n):
# if self.arr[i] == pid2:
# self.arr[i] = pid1
#
# Path: unionfind/quickunion.py
# class QuickUnion(UnionFind):
#
# def __init__(self, n):
# UnionFind.__init__(self, n)
#
# def connect(self, item1, item2):
# pid1 = self.parent(item1)
# pid2 = self.parent(item2)
# self.arr[pid2] = pid1
#
# def parent(self, index):
# current_item = index
# while self.arr[current_item] != current_item:
# current_item = self.arr[current_item]
#
# return current_item
#
# Path: unionfind/weightedquickunion.py
# class WeightedQuickUnion(QuickUnion):
#
# def __init__(self, n):
# QuickUnion.__init__(self, n)
# self.item_counts = [1] * n
#
# def connect(self, item1, item2):
# pid1 = self.parent(item1)
# pid2 = self.parent(item2)
# if self.item_counts[pid1] > self.item_counts[pid2]:
# self.arr[pid2] = pid1
# self.item_counts[pid1] += self.item_counts[pid2]
# else:
# self.arr[pid1] = pid2
# self.item_counts[pid2] += self.item_counts[pid1]
#
# Path: unionfind/wquwithpathcompression.py
# class WQUWithPathCompression(WeightedQuickUnion):
#
# def __init__(self, n):
# WeightedQuickUnion.__init__(self, n)
#
# def parent(self, index):
# current_item = index
# while self.arr[current_item] != current_item:
# current_item = self.arr[current_item]
#
# update_index = index
# while self.arr[update_index] != current_item:
# parent_index = self.arr[update_index]
# self.arr[update_index] = current_item
# update_index = parent_index
#
# return current_item
. Output only the next line. | self.algorithm.connect(1, 2) |
Given the following code snippet before the placeholder: <|code_start|>__author__ = 'orhan'
class UnionFindTests():
def test_initial(self):
self.assertEqual(self.algorithm.parent(1), 1)
def test_simple_connect(self):
self.algorithm.connect(1, 2)
self.assertTrue(self.algorithm.isConnected(1, 2))
def test_multiple_connect(self):
self.algorithm.connect(1, 2)
self.algorithm.connect(3, 4)
self.assertTrue(not self.algorithm.isConnected(2, 3))
self.algorithm.connect(1, 4)
self.assertTrue(self.algorithm.isConnected(2, 3))
self.assertTrue(self.algorithm.isConnected(2, 4))
self.assertTrue(not self.algorithm.isConnected(2, 9))
class QuickFindTests(UnionFindTests, TestCase):
<|code_end|>
, predict the next line using imports from the current file:
from unittest import TestCase
from unionfind.quickfind import QuickFind
from unionfind.quickunion import QuickUnion
from unionfind.weightedquickunion import WeightedQuickUnion
from unionfind.wquwithpathcompression import WQUWithPathCompression
and context including class names, function names, and sometimes code from other files:
# Path: unionfind/quickfind.py
# class QuickFind(UnionFind):
#
# def __init__(self, n):
# UnionFind.__init__(self, n)
#
# def parent(self, index):
# return self.arr[index]
#
# def connect(self, item1, item2):
# pid1 = self.arr[item1]
# pid2 = self.arr[item2]
#
# for i in xrange(self.n):
# if self.arr[i] == pid2:
# self.arr[i] = pid1
#
# Path: unionfind/quickunion.py
# class QuickUnion(UnionFind):
#
# def __init__(self, n):
# UnionFind.__init__(self, n)
#
# def connect(self, item1, item2):
# pid1 = self.parent(item1)
# pid2 = self.parent(item2)
# self.arr[pid2] = pid1
#
# def parent(self, index):
# current_item = index
# while self.arr[current_item] != current_item:
# current_item = self.arr[current_item]
#
# return current_item
#
# Path: unionfind/weightedquickunion.py
# class WeightedQuickUnion(QuickUnion):
#
# def __init__(self, n):
# QuickUnion.__init__(self, n)
# self.item_counts = [1] * n
#
# def connect(self, item1, item2):
# pid1 = self.parent(item1)
# pid2 = self.parent(item2)
# if self.item_counts[pid1] > self.item_counts[pid2]:
# self.arr[pid2] = pid1
# self.item_counts[pid1] += self.item_counts[pid2]
# else:
# self.arr[pid1] = pid2
# self.item_counts[pid2] += self.item_counts[pid1]
#
# Path: unionfind/wquwithpathcompression.py
# class WQUWithPathCompression(WeightedQuickUnion):
#
# def __init__(self, n):
# WeightedQuickUnion.__init__(self, n)
#
# def parent(self, index):
# current_item = index
# while self.arr[current_item] != current_item:
# current_item = self.arr[current_item]
#
# update_index = index
# while self.arr[update_index] != current_item:
# parent_index = self.arr[update_index]
# self.arr[update_index] = current_item
# update_index = parent_index
#
# return current_item
. Output only the next line. | def setUp(self): |
Given the following code snippet before the placeholder: <|code_start|>__author__ = 'orhan'
class GeometryTests(TestCase):
epsilon = 1e-6
def test_point(self):
p1 = Point(1.0, 1.0)
p2 = Point(0.0, 0.0)
self.assertTrue(p1.angle_x(p2) - 45.0 <= self.epsilon)
def test_point2(self):
p1 = Point(1.0, 1.0)
p2 = Point(0.0, 0.0)
self.assertTrue(p2.angle_x(p1) - 135.0 <= self.epsilon)
def test_point3(self):
p1 = Point(1.0, 1.0)
p2 = Point(1.0, 1.0)
self.assertTrue(p2.angle_x(p1) - 0.0 <= self.epsilon)
<|code_end|>
, predict the next line using imports from the current file:
from unittest import TestCase
from common.geometry import Point
from sys import float_info
and context including class names, function names, and sometimes code from other files:
# Path: common/geometry.py
# class Point:
# def __init__(self, x, y=0.0, z=0.0):
# self.x = x
# self.y = y
# self.z = z
#
# def angle_x(self, p2):
# dy = self.y - p2.y
# dx = self.x - p2.x
# h = sqrt(dy ** 2 + dx ** 2)
# if h == 0:
# return 0
#
# return degrees(asin(dx / h))
#
# def __cmp__(self, other):
# return (self.x - other.x) or (self.y - other.y) or (self.z - other.z)
#
# def __eq__(self, other):
# return self.__cmp__(other) == 0.0
#
# def __ne__(self, other):
# return self.__cmp__(other) != 0.0
. Output only the next line. | def test_point4(self): |
Predict the next line after this snippet: <|code_start|>
class LinkedList:
def __init__(self):
self.__head = None
self.__tail = None
self.__count = 0
def add(self, value):
if self.__head is None:
self.__head = LinkedNode(value)
self.__tail = self.__head
else:
new_node = LinkedNode(value)
self.__tail.set_next(new_node)
self.__tail = new_node
self.__count += 1
def remove(self, value):
parent = None
node = self.__head
while node is not None and node.value != value:
parent = node
<|code_end|>
using the current file's imports:
from common.data_structures import LinkedNode
and any relevant context from other files:
# Path: common/data_structures.py
# class LinkedNode:
# def __init__(self, value):
# self.value = value
# self.next = None
#
# def set_next(self, next_node):
# self.next = next_node
#
# def get_next(self):
# return self.next
. Output only the next line. | node = node.get_next() |
Given the code snippet: <|code_start|>__author__ = 'orhan'
class GeometryTests(TestCase):
def test_1(self):
gs = GrahamScan()
gs.add_point(Point(0.0, 0.0))
gs.add_point(Point(1.0, 0.0))
gs.add_point(Point(1.0, 1.0))
gs.add_point(Point(0.0, 1.0))
res = gs.calculate()
self.assertTrue(len(res) == 4)
<|code_end|>
, generate the next line using the imports in this file:
from unittest.case import TestCase
from convexhull.grahamscan import GrahamScan
from common.geometry import Point
and context (functions, classes, or occasionally code) from other files:
# Path: convexhull/grahamscan.py
# class GrahamScan(ConvexHullBase):
#
# def calculate(self):
# self.bottom_right = self.get_bottom_right_point()
# sorted_list = [point for point in sorted(self.points, cmp=self.__compare_with_x_angle) if point != self.bottom_right]
#
# result_list = list()
# result_list.append(self.bottom_right)
# result_list.append(sorted_list[0])
#
# for i in xrange(1, len(sorted_list)):
# point = sorted_list[i]
# ind = len(result_list) - 2
#
# while self.__cross_product(result_list[ind], result_list[ind+1], point) < 0:
# result_list.pop()
# ind -= 1
#
# result_list.append(point)
#
# return result_list
#
# def __cross_product(self, p1, p2, p3):
# return (p2.x - p1.x)*(p3.y - p1.y) - (p2.y - p1.y)*(p3.x - p1.x)
#
# def __compare_with_x_angle(self, p1, p2):
# a1 = self.bottom_right.angle_x(p1)
# a2 = self.bottom_right.angle_x(p2)
# if a1 > a2:
# return 1
# if a1 == a2:
# return 0
# return -1
#
# def get_bottom_right_point(self):
# bottom_point = self.points[0]
# for point in self.points:
# if (point.y < bottom_point.y) or (point.y == bottom_point.y and point.x > bottom_point.x):
# bottom_point = point
#
# return bottom_point
#
# Path: common/geometry.py
# class Point:
# def __init__(self, x, y=0.0, z=0.0):
# self.x = x
# self.y = y
# self.z = z
#
# def angle_x(self, p2):
# dy = self.y - p2.y
# dx = self.x - p2.x
# h = sqrt(dy ** 2 + dx ** 2)
# if h == 0:
# return 0
#
# return degrees(asin(dx / h))
#
# def __cmp__(self, other):
# return (self.x - other.x) or (self.y - other.y) or (self.z - other.z)
#
# def __eq__(self, other):
# return self.__cmp__(other) == 0.0
#
# def __ne__(self, other):
# return self.__cmp__(other) != 0.0
. Output only the next line. | def test_2(self): |
Given the code snippet: <|code_start|>__author__ = 'orhan'
class GeometryTests(TestCase):
def test_1(self):
gs = GrahamScan()
gs.add_point(Point(0.0, 0.0))
gs.add_point(Point(1.0, 0.0))
gs.add_point(Point(1.0, 1.0))
gs.add_point(Point(0.0, 1.0))
res = gs.calculate()
self.assertTrue(len(res) == 4)
<|code_end|>
, generate the next line using the imports in this file:
from unittest.case import TestCase
from convexhull.grahamscan import GrahamScan
from common.geometry import Point
and context (functions, classes, or occasionally code) from other files:
# Path: convexhull/grahamscan.py
# class GrahamScan(ConvexHullBase):
#
# def calculate(self):
# self.bottom_right = self.get_bottom_right_point()
# sorted_list = [point for point in sorted(self.points, cmp=self.__compare_with_x_angle) if point != self.bottom_right]
#
# result_list = list()
# result_list.append(self.bottom_right)
# result_list.append(sorted_list[0])
#
# for i in xrange(1, len(sorted_list)):
# point = sorted_list[i]
# ind = len(result_list) - 2
#
# while self.__cross_product(result_list[ind], result_list[ind+1], point) < 0:
# result_list.pop()
# ind -= 1
#
# result_list.append(point)
#
# return result_list
#
# def __cross_product(self, p1, p2, p3):
# return (p2.x - p1.x)*(p3.y - p1.y) - (p2.y - p1.y)*(p3.x - p1.x)
#
# def __compare_with_x_angle(self, p1, p2):
# a1 = self.bottom_right.angle_x(p1)
# a2 = self.bottom_right.angle_x(p2)
# if a1 > a2:
# return 1
# if a1 == a2:
# return 0
# return -1
#
# def get_bottom_right_point(self):
# bottom_point = self.points[0]
# for point in self.points:
# if (point.y < bottom_point.y) or (point.y == bottom_point.y and point.x > bottom_point.x):
# bottom_point = point
#
# return bottom_point
#
# Path: common/geometry.py
# class Point:
# def __init__(self, x, y=0.0, z=0.0):
# self.x = x
# self.y = y
# self.z = z
#
# def angle_x(self, p2):
# dy = self.y - p2.y
# dx = self.x - p2.x
# h = sqrt(dy ** 2 + dx ** 2)
# if h == 0:
# return 0
#
# return degrees(asin(dx / h))
#
# def __cmp__(self, other):
# return (self.x - other.x) or (self.y - other.y) or (self.z - other.z)
#
# def __eq__(self, other):
# return self.__cmp__(other) == 0.0
#
# def __ne__(self, other):
# return self.__cmp__(other) != 0.0
. Output only the next line. | def test_2(self): |
Continue the code snippet: <|code_start|>__author__ = 'orhan'
class GrahamScan(ConvexHullBase):
def calculate(self):
self.bottom_right = self.get_bottom_right_point()
sorted_list = [point for point in sorted(self.points, cmp=self.__compare_with_x_angle) if point != self.bottom_right]
result_list = list()
result_list.append(self.bottom_right)
<|code_end|>
. Use current file imports:
from convexhull.base import ConvexHullBase
and context (classes, functions, or code) from other files:
# Path: convexhull/base.py
# class ConvexHullBase(object):
#
# def __init__(self):
# self.points = list()
#
# def add_point(self, p):
# self.points.append(p)
#
# def calculate(self):
# raise Exception('Not implemented!')
. Output only the next line. | result_list.append(sorted_list[0]) |
Here is a snippet: <|code_start|> node3.add_child(node5)
return node
def test_tree1(self):
node = UninformedSearchTest.prepare_tree1()
result = self.algorithm(node, '5')
self.assertTrue(result.value == '5')
def test_tree2(self):
node = UninformedSearchTest.prepare_tree1()
result = self.algorithm(node, '7')
self.assertTrue(result is None)
def test_tree3(self):
node = UninformedSearchTest.prepare_single_node_tree()
result = self.algorithm(node, '1')
self.assertTrue(result.value == '1')
def test_tree4(self):
node = UninformedSearchTest.prepare_single_node_tree()
result = self.algorithm(node, '2')
self.assertTrue(result is None)
def test_tree_with_comparator1(self):
node = UninformedSearchTest.prepare_tree1()
result = self.algorithm(node, 5, comparator=lambda x, y: int(x) == y)
self.assertTrue(result.value == '5')
def test_graph1(self):
<|code_end|>
. Write the next line using the current file imports:
from unittest import TestCase
from common.data_structures import Node
from search.uninformed_search import bfs, dfs, iterative_deepening_search
and context from other files:
# Path: common/data_structures.py
# class Node(object):
#
# def __init__(self):
# self.children = list()
#
# def add_child(self, child):
# self.children.append(child)
#
# def get_child(self, index):
# return self.children[index]
#
# def __iter__(self):
# return iter(self.children)
#
# def __eq__(self, other):
# return self.value == other.value
#
# Path: search/uninformed_search.py
# def bfs(node, target, comparator=lambda x, y: x == y):
# queue = [node]
# visited_nodes = []
#
# while len(queue) != 0:
# current_node = queue.pop(0)
# if current_node not in visited_nodes:
# if comparator(current_node.value, target):
# return current_node
# queue.extend(current_node)
# visited_nodes.append(current_node)
#
# return None
#
# def dfs(node, target, comparator=lambda x, y: x == y):
# queue = [node]
# visited_nodes = []
#
# while len(queue) != 0:
# current_node = queue.pop()
# if current_node not in visited_nodes:
# if comparator(current_node.value, target):
# return current_node
# queue.extend(current_node)
# visited_nodes.append(current_node)
#
# return None
#
# def iterative_deepening_search(node, target, comparator=lambda x, y: x == y):
# level = 0
# found_level = 0
#
# while level == found_level:
# level += 1
# result, found_level = dls(node, target, level, comparator)
# if result is not None:
# return result
#
#
# return None
, which may include functions, classes, or code. Output only the next line. | node = UninformedSearchTest.prepare_graph1() |
Using the snippet: <|code_start|> node21.value = '3'
node.add_child(node21)
node3 = Node()
node3.value = '4'
node2.add_child(node3)
node4 = Node()
node4.value = '5'
node3.add_child(node4)
node21.add_child(node4)
node5 = Node()
node5.value = '6'
node3.add_child(node5)
return node
def test_tree1(self):
node = UninformedSearchTest.prepare_tree1()
result = self.algorithm(node, '5')
self.assertTrue(result.value == '5')
def test_tree2(self):
node = UninformedSearchTest.prepare_tree1()
result = self.algorithm(node, '7')
self.assertTrue(result is None)
def test_tree3(self):
node = UninformedSearchTest.prepare_single_node_tree()
<|code_end|>
, determine the next line of code. You have imports:
from unittest import TestCase
from common.data_structures import Node
from search.uninformed_search import bfs, dfs, iterative_deepening_search
and context (class names, function names, or code) available:
# Path: common/data_structures.py
# class Node(object):
#
# def __init__(self):
# self.children = list()
#
# def add_child(self, child):
# self.children.append(child)
#
# def get_child(self, index):
# return self.children[index]
#
# def __iter__(self):
# return iter(self.children)
#
# def __eq__(self, other):
# return self.value == other.value
#
# Path: search/uninformed_search.py
# def bfs(node, target, comparator=lambda x, y: x == y):
# queue = [node]
# visited_nodes = []
#
# while len(queue) != 0:
# current_node = queue.pop(0)
# if current_node not in visited_nodes:
# if comparator(current_node.value, target):
# return current_node
# queue.extend(current_node)
# visited_nodes.append(current_node)
#
# return None
#
# def dfs(node, target, comparator=lambda x, y: x == y):
# queue = [node]
# visited_nodes = []
#
# while len(queue) != 0:
# current_node = queue.pop()
# if current_node not in visited_nodes:
# if comparator(current_node.value, target):
# return current_node
# queue.extend(current_node)
# visited_nodes.append(current_node)
#
# return None
#
# def iterative_deepening_search(node, target, comparator=lambda x, y: x == y):
# level = 0
# found_level = 0
#
# while level == found_level:
# level += 1
# result, found_level = dls(node, target, level, comparator)
# if result is not None:
# return result
#
#
# return None
. Output only the next line. | result = self.algorithm(node, '1') |
Given snippet: <|code_start|> self.assertTrue(result.value == '5')
def test_tree2(self):
node = UninformedSearchTest.prepare_tree1()
result = self.algorithm(node, '7')
self.assertTrue(result is None)
def test_tree3(self):
node = UninformedSearchTest.prepare_single_node_tree()
result = self.algorithm(node, '1')
self.assertTrue(result.value == '1')
def test_tree4(self):
node = UninformedSearchTest.prepare_single_node_tree()
result = self.algorithm(node, '2')
self.assertTrue(result is None)
def test_tree_with_comparator1(self):
node = UninformedSearchTest.prepare_tree1()
result = self.algorithm(node, 5, comparator=lambda x, y: int(x) == y)
self.assertTrue(result.value == '5')
def test_graph1(self):
node = UninformedSearchTest.prepare_graph1()
result = self.algorithm(node, '1')
self.assertTrue(result.value == '1')
def test_graph2(self):
node = UninformedSearchTest.prepare_graph1()
result = self.algorithm(node, '10')
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from unittest import TestCase
from common.data_structures import Node
from search.uninformed_search import bfs, dfs, iterative_deepening_search
and context:
# Path: common/data_structures.py
# class Node(object):
#
# def __init__(self):
# self.children = list()
#
# def add_child(self, child):
# self.children.append(child)
#
# def get_child(self, index):
# return self.children[index]
#
# def __iter__(self):
# return iter(self.children)
#
# def __eq__(self, other):
# return self.value == other.value
#
# Path: search/uninformed_search.py
# def bfs(node, target, comparator=lambda x, y: x == y):
# queue = [node]
# visited_nodes = []
#
# while len(queue) != 0:
# current_node = queue.pop(0)
# if current_node not in visited_nodes:
# if comparator(current_node.value, target):
# return current_node
# queue.extend(current_node)
# visited_nodes.append(current_node)
#
# return None
#
# def dfs(node, target, comparator=lambda x, y: x == y):
# queue = [node]
# visited_nodes = []
#
# while len(queue) != 0:
# current_node = queue.pop()
# if current_node not in visited_nodes:
# if comparator(current_node.value, target):
# return current_node
# queue.extend(current_node)
# visited_nodes.append(current_node)
#
# return None
#
# def iterative_deepening_search(node, target, comparator=lambda x, y: x == y):
# level = 0
# found_level = 0
#
# while level == found_level:
# level += 1
# result, found_level = dls(node, target, level, comparator)
# if result is not None:
# return result
#
#
# return None
which might include code, classes, or functions. Output only the next line. | self.assertTrue(result is None) |
Here is a snippet: <|code_start|>
node2 = Node()
node2.value = '2'
node.add_child(node2)
node21 = Node()
node21.value = '3'
node.add_child(node21)
node3 = Node()
node3.value = '4'
node2.add_child(node3)
node4 = Node()
node4.value = '5'
node3.add_child(node4)
node21.add_child(node4)
node5 = Node()
node5.value = '6'
node3.add_child(node5)
return node
def test_tree1(self):
node = UninformedSearchTest.prepare_tree1()
result = self.algorithm(node, '5')
self.assertTrue(result.value == '5')
def test_tree2(self):
node = UninformedSearchTest.prepare_tree1()
<|code_end|>
. Write the next line using the current file imports:
from unittest import TestCase
from common.data_structures import Node
from search.uninformed_search import bfs, dfs, iterative_deepening_search
and context from other files:
# Path: common/data_structures.py
# class Node(object):
#
# def __init__(self):
# self.children = list()
#
# def add_child(self, child):
# self.children.append(child)
#
# def get_child(self, index):
# return self.children[index]
#
# def __iter__(self):
# return iter(self.children)
#
# def __eq__(self, other):
# return self.value == other.value
#
# Path: search/uninformed_search.py
# def bfs(node, target, comparator=lambda x, y: x == y):
# queue = [node]
# visited_nodes = []
#
# while len(queue) != 0:
# current_node = queue.pop(0)
# if current_node not in visited_nodes:
# if comparator(current_node.value, target):
# return current_node
# queue.extend(current_node)
# visited_nodes.append(current_node)
#
# return None
#
# def dfs(node, target, comparator=lambda x, y: x == y):
# queue = [node]
# visited_nodes = []
#
# while len(queue) != 0:
# current_node = queue.pop()
# if current_node not in visited_nodes:
# if comparator(current_node.value, target):
# return current_node
# queue.extend(current_node)
# visited_nodes.append(current_node)
#
# return None
#
# def iterative_deepening_search(node, target, comparator=lambda x, y: x == y):
# level = 0
# found_level = 0
#
# while level == found_level:
# level += 1
# result, found_level = dls(node, target, level, comparator)
# if result is not None:
# return result
#
#
# return None
, which may include functions, classes, or code. Output only the next line. | result = self.algorithm(node, '7') |
Given the following code snippet before the placeholder: <|code_start|> array = self.generate_array()
ind = binary_search(array, 12)
self.assertTrue(ind == 2)
def test_exists2(self):
array = self.generate_array()
ind = binary_search(array, 1)
self.assertTrue(ind == 0)
def test_exists3(self):
array = self.generate_array()
ind = binary_search(array, 57)
self.assertTrue(ind == 6)
def test_not_exist1(self):
array = self.generate_array()
ind = binary_search(array, 3)
self.assertTrue(ind == 2)
def test_not_exist2(self):
array = self.generate_array()
ind = binary_search(array, 0)
self.assertTrue(ind == 0)
def test_not_exist3(self):
<|code_end|>
, predict the next line using imports from the current file:
from unittest.case import TestCase
from search.binary_search import binary_search
and context including class names, function names, and sometimes code from other files:
# Path: search/binary_search.py
# def binary_search(array, target_value):
# left = 0
# right = len(array) - 1
#
# while left <= right:
# mid = (left + right) / 2
# if array[mid] == target_value:
# return mid
#
# if array[mid] > target_value:
# right = mid - 1
# elif array[mid] < target_value:
# left = mid + 1
#
# return right + 1
. Output only the next line. | array = self.generate_array() |
Given snippet: <|code_start|> print r
self.assertTrue(r == [1, 3, 4, 6, 7, 8, 10, 13, 14])
def test_pre_order(self):
b = self.prepare_tree1()
r = b.pre_order()
print r
self.assertTrue(r == [8, 3, 1, 6, 4, 7, 10, 14, 13])
def test_post_order(self):
b = self.prepare_tree1()
r = b.post_order()
print r
self.assertTrue(r == [1, 4, 7, 6, 3, 13, 14, 10, 8])
def test_delete_leaf(self):
b = self.prepare_tree1()
b.delete(13)
r = b.pre_order()
print r
self.assertTrue(r == [8, 3, 1, 6, 4, 7, 10, 14])
def test_delete_one_child(self):
b = self.prepare_tree1()
b.delete(14)
r = b.pre_order()
print r
self.assertTrue(r == [8, 3, 1, 6, 4, 7, 10, 13])
def test_delete_one_child_2(self):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from unittest.case import TestCase
from data_structures.binary_tree import BinaryTree
and context:
# Path: data_structures/binary_tree.py
# class BinaryTree:
#
# class BinaryTreeNode:
# def __init__(self, value):
# self.value = value
# self.right = None
# self.left = None
#
# def __init__(self):
# self.root = None
#
# def insert(self, value):
# if self.root is None:
# self.root = BinaryTree.BinaryTreeNode(value)
# else:
# self.__insert(self.root, value)
#
# def __insert(self, local_root, value):
# if local_root.value != value:
# if local_root.value > value:
# if local_root.left is None:
# local_root.left = BinaryTree.BinaryTreeNode(value)
# else:
# self.__insert(local_root.left, value)
# else:
# if local_root.right is None:
# local_root.right = BinaryTree.BinaryTreeNode(value)
# else:
# self.__insert(local_root.right, value)
#
# def contains(self, value):
# return self.__contains(self.root, value)
#
# def __contains(self, local_root, value):
# if local_root is None:
# return False
#
# if local_root.value == value:
# return True
#
# if local_root.value > value:
# return self.__contains(local_root.left, value)
#
# return self.__contains(local_root.right, value)
#
# def pre_order(self):
# result = list()
# self.__pre_order(self.root, result)
# return result
#
# def __pre_order(self, local_root, result):
# if local_root is not None:
# result.append(local_root.value)
# self.__pre_order(local_root.left, result)
# self.__pre_order(local_root.right, result)
#
# def in_order(self):
# result = list()
# self.__in_order(self.root, result)
# return result
#
# def __in_order(self, local_root, result):
# if local_root is not None:
# self.__in_order(local_root.left, result)
# result.append(local_root.value)
# self.__in_order(local_root.right, result)
#
# def post_order(self):
# result = list()
# self.__post_order(self.root, result)
# return result
#
# def __post_order(self, local_root, result):
# if local_root is not None:
# self.__post_order(local_root.left, result)
# self.__post_order(local_root.right, result)
# result.append(local_root.value)
#
# def delete(self, value):
# self.__delete(None, self.root, value)
#
# def __delete(self, parent_node, local_root, value):
# if local_root is None:
# return None
#
# if local_root.value < value:
# return self.__delete(local_root, local_root.right, value)
# elif local_root.value > value:
# return self.__delete(local_root, local_root.left, value)
# else:
# if local_root.right is not None and local_root.left is not None:
# max_left_child = self.__find_max(local_root.left)
# new_value = max_left_child.value
# self.delete(new_value)
# local_root.value = new_value
# elif local_root.right is not None:
# self.__set_child_of_parent(parent_node, local_root.right, value)
# elif local_root.left is not None:
# self.__set_child_of_parent(parent_node, local_root.left, value)
# else:
# self.__set_child_of_parent(parent_node, None, value)
#
# def __find_max(self, local_root):
# while local_root.right is not None:
# local_root = local_root.right
# return local_root
#
# def __set_child_of_parent(self, parent, child, value):
# if parent is None:
# self.root = child
# elif parent.value > value:
# parent.left = child
# else:
# parent.right = child
which might include code, classes, or functions. Output only the next line. | b = self.prepare_tree1() |
Continue the code snippet: <|code_start|>
class NaiveSearchTests(TestCase):
def get_strings(self):
return "abcdabcdabcdabcdabcdabcdabcdabcd", "bcd"
def test_search1(self):
text, pattern = self.get_strings()
ind = naive_search(text, pattern)
self.assertTrue(ind == 1)
def test_search2(self):
text, pattern = self.get_strings()
ind = naive_search(text, pattern, 2)
self.assertTrue(ind == 5)
def test_search3(self):
text, pattern = self.get_strings()
ind = naive_search(text, pattern, len(text) - 1)
<|code_end|>
. Use current file imports:
from unittest.case import TestCase
from string_algorithms.search.naive_search import naive_search
and context (classes, functions, or code) from other files:
# Path: string_algorithms/search/naive_search.py
# def naive_search(text, pattern, start_index=0):
# for i in xrange(start_index, len(text) - len(pattern) + 1):
# found = True
# for j in xrange(len(pattern)):
# if text[i + j] != pattern[j]:
# found = False
# break
#
# if found:
# return i
#
# return -1
. Output only the next line. | self.assertTrue(ind == -1) |
Continue the code snippet: <|code_start|>
class KmpTests(TestCase):
def get_strings(self):
return "abcdabcdabcdabcdabcdabcdabcdabcd", "bcd"
def test_search1(self):
text, pattern = self.get_strings()
ind = kmp(text, pattern)
self.assertTrue(ind == 1)
def test_search2(self):
text, pattern = self.get_strings()
ind = kmp(text, pattern, 2)
<|code_end|>
. Use current file imports:
from unittest.case import TestCase
from string_algorithms.search.knuth_morris_pratt import kmp
and context (classes, functions, or code) from other files:
# Path: string_algorithms/search/knuth_morris_pratt.py
# def kmp(text, pattern, start_index=0):
# failure_array = construct_failure_array(pattern)
# j = 0
# m = len(pattern)
# i = start_index
# while True:
# if i >= len(text):
# break
#
# if text[i] == pattern[j]:
# j += 1
# i += 1
# if j == m:
# return i - m
# elif j > 0:
# j = failure_array[j]
# else:
# i += 1
#
# return -1
. Output only the next line. | self.assertTrue(ind == 5) |
Continue the code snippet: <|code_start|>__author__ = 'orhan'
class WeightedQuickUnion(QuickUnion):
def __init__(self, n):
QuickUnion.__init__(self, n)
self.item_counts = [1] * n
def connect(self, item1, item2):
pid1 = self.parent(item1)
pid2 = self.parent(item2)
if self.item_counts[pid1] > self.item_counts[pid2]:
self.arr[pid2] = pid1
<|code_end|>
. Use current file imports:
from unionfind.quickunion import QuickUnion
and context (classes, functions, or code) from other files:
# Path: unionfind/quickunion.py
# class QuickUnion(UnionFind):
#
# def __init__(self, n):
# UnionFind.__init__(self, n)
#
# def connect(self, item1, item2):
# pid1 = self.parent(item1)
# pid2 = self.parent(item2)
# self.arr[pid2] = pid1
#
# def parent(self, index):
# current_item = index
# while self.arr[current_item] != current_item:
# current_item = self.arr[current_item]
#
# return current_item
. Output only the next line. | self.item_counts[pid1] += self.item_counts[pid2] |
Given the following code snippet before the placeholder: <|code_start|>__author__ = 'orhan'
class WQUWithPathCompression(WeightedQuickUnion):
def __init__(self, n):
WeightedQuickUnion.__init__(self, n)
def parent(self, index):
current_item = index
while self.arr[current_item] != current_item:
current_item = self.arr[current_item]
update_index = index
while self.arr[update_index] != current_item:
parent_index = self.arr[update_index]
self.arr[update_index] = current_item
<|code_end|>
, predict the next line using imports from the current file:
from unionfind.weightedquickunion import WeightedQuickUnion
and context including class names, function names, and sometimes code from other files:
# Path: unionfind/weightedquickunion.py
# class WeightedQuickUnion(QuickUnion):
#
# def __init__(self, n):
# QuickUnion.__init__(self, n)
# self.item_counts = [1] * n
#
# def connect(self, item1, item2):
# pid1 = self.parent(item1)
# pid2 = self.parent(item2)
# if self.item_counts[pid1] > self.item_counts[pid2]:
# self.arr[pid2] = pid1
# self.item_counts[pid1] += self.item_counts[pid2]
# else:
# self.arr[pid1] = pid2
# self.item_counts[pid2] += self.item_counts[pid1]
. Output only the next line. | update_index = parent_index |
Predict the next line for this snippet: <|code_start|>
class DepthLimitedSearchTest(TestCase):
@staticmethod
def prepare_tree1():
node = Node()
node.value = '1'
node2 = Node()
node2.value = '2'
node.add_child(node2)
node2 = Node()
node2.value = '3'
node.add_child(node2)
node3 = Node()
node3.value = '4'
node2.add_child(node3)
node3 = Node()
node3.value = '5'
node2.add_child(node3)
return node
@staticmethod
def prepare_single_node_tree():
node = Node()
<|code_end|>
with the help of current file imports:
from unittest.case import TestCase
from common.data_structures import Node
from search.uninformed_search import dls
and context from other files:
# Path: common/data_structures.py
# class Node(object):
#
# def __init__(self):
# self.children = list()
#
# def add_child(self, child):
# self.children.append(child)
#
# def get_child(self, index):
# return self.children[index]
#
# def __iter__(self):
# return iter(self.children)
#
# def __eq__(self, other):
# return self.value == other.value
#
# Path: search/uninformed_search.py
# def dls(node, target, limit, comparator=lambda x, y: x == y):
# queue = [(node, 0)]
# visited_nodes = []
# max_level = 0
#
# while len(queue) != 0:
# current_node, current_node_level = queue.pop()
# max_level = max(max_level, current_node_level)
#
# if current_node_level <= limit and current_node not in visited_nodes:
# if comparator(current_node.value, target):
# return current_node, current_node_level
#
# if current_node_level < limit:
# queue.extend([(child, current_node_level + 1) for child in current_node])
#
# visited_nodes.append(current_node)
#
# return None, max_level
, which may contain function names, class names, or code. Output only the next line. | node.value = '1' |
Given the code snippet: <|code_start|>
class DepthLimitedSearchTest(TestCase):
@staticmethod
def prepare_tree1():
node = Node()
<|code_end|>
, generate the next line using the imports in this file:
from unittest.case import TestCase
from common.data_structures import Node
from search.uninformed_search import dls
and context (functions, classes, or occasionally code) from other files:
# Path: common/data_structures.py
# class Node(object):
#
# def __init__(self):
# self.children = list()
#
# def add_child(self, child):
# self.children.append(child)
#
# def get_child(self, index):
# return self.children[index]
#
# def __iter__(self):
# return iter(self.children)
#
# def __eq__(self, other):
# return self.value == other.value
#
# Path: search/uninformed_search.py
# def dls(node, target, limit, comparator=lambda x, y: x == y):
# queue = [(node, 0)]
# visited_nodes = []
# max_level = 0
#
# while len(queue) != 0:
# current_node, current_node_level = queue.pop()
# max_level = max(max_level, current_node_level)
#
# if current_node_level <= limit and current_node not in visited_nodes:
# if comparator(current_node.value, target):
# return current_node, current_node_level
#
# if current_node_level < limit:
# queue.extend([(child, current_node_level + 1) for child in current_node])
#
# visited_nodes.append(current_node)
#
# return None, max_level
. Output only the next line. | node.value = '1' |
Here is a snippet: <|code_start|> def test_chebyshev2(self):
v1 = [0, 1, 1, 2]
v2 = [0, 1, 5, 5]
self.assertTrue(chebyshev(v1, v2) == 4.0)
def test_chebyshev3(self):
v1 = [0, 1, 1, 2]
v2 = [0, 1, 1]
try:
chebyshev(v1, v2)
self.assertTrue(False)
except AssertionError as ae:
self.assertTrue(True)
def test_manhattan1(self):
v1 = [0, 1, 1, 2]
v2 = [0, 1, 1, 2]
self.assertTrue(manhattan(v1, v2) == 0.0)
def test_manhattan2(self):
v1 = [0, 1, 1, 2]
v2 = [-1, 3, 4, 4]
self.assertTrue(manhattan(v1, v2) == 8.0)
def test_manhattan3(self):
v1 = [0, 1, 1, 2]
<|code_end|>
. Write the next line using the current file imports:
from unittest import TestCase
from common.heuristic import euclidean, chebyshev, manhattan
and context from other files:
# Path: common/heuristic.py
# def euclidean(vec1, vec2):
# assert len(vec1) == len(vec2)
#
# return math.sqrt(sum([(x1-x2)*(x1-x2) for x1, x2 in zip(vec1, vec2)]))
#
# def chebyshev(vec1, vec2):
# assert len(vec1) == len(vec2)
#
# return max([math.fabs(x1 - x2) for x1, x2 in zip(vec1, vec2)])
#
# def manhattan(vec1, vec2):
# assert len(vec1) == len(vec2)
#
# return sum([math.fabs(x1 - x2) for x1, x2 in zip(vec1, vec2)])
, which may include functions, classes, or code. Output only the next line. | v2 = [0, 1, 1] |
Predict the next line after this snippet: <|code_start|>
class HeuristicTest(TestCase):
def test_euclidean1(self):
v1 = [0, 1, 1, 2]
v2 = [0, 1, 1, 2]
self.assertTrue(euclidean(v1, v2) == 0.0)
def test_euclidean2(self):
v1 = [0, 1, 1, 2]
v2 = [0, 1, 5, 5]
self.assertTrue(euclidean(v1, v2) == 5.0)
def test_euclidean3(self):
v1 = [0, 1, 1, 2]
v2 = [0, 1, 1]
try:
euclidean(v1, v2)
self.assertTrue(False)
except AssertionError as ae:
self.assertTrue(True)
<|code_end|>
using the current file's imports:
from unittest import TestCase
from common.heuristic import euclidean, chebyshev, manhattan
and any relevant context from other files:
# Path: common/heuristic.py
# def euclidean(vec1, vec2):
# assert len(vec1) == len(vec2)
#
# return math.sqrt(sum([(x1-x2)*(x1-x2) for x1, x2 in zip(vec1, vec2)]))
#
# def chebyshev(vec1, vec2):
# assert len(vec1) == len(vec2)
#
# return max([math.fabs(x1 - x2) for x1, x2 in zip(vec1, vec2)])
#
# def manhattan(vec1, vec2):
# assert len(vec1) == len(vec2)
#
# return sum([math.fabs(x1 - x2) for x1, x2 in zip(vec1, vec2)])
. Output only the next line. | def test_chebyshev1(self): |
Here is a snippet: <|code_start|>
class HeuristicTest(TestCase):
def test_euclidean1(self):
v1 = [0, 1, 1, 2]
<|code_end|>
. Write the next line using the current file imports:
from unittest import TestCase
from common.heuristic import euclidean, chebyshev, manhattan
and context from other files:
# Path: common/heuristic.py
# def euclidean(vec1, vec2):
# assert len(vec1) == len(vec2)
#
# return math.sqrt(sum([(x1-x2)*(x1-x2) for x1, x2 in zip(vec1, vec2)]))
#
# def chebyshev(vec1, vec2):
# assert len(vec1) == len(vec2)
#
# return max([math.fabs(x1 - x2) for x1, x2 in zip(vec1, vec2)])
#
# def manhattan(vec1, vec2):
# assert len(vec1) == len(vec2)
#
# return sum([math.fabs(x1 - x2) for x1, x2 in zip(vec1, vec2)])
, which may include functions, classes, or code. Output only the next line. | v2 = [0, 1, 1, 2] |
Here is a snippet: <|code_start|>__author__ = 'orhan'
class QuickUnion(UnionFind):
def __init__(self, n):
UnionFind.__init__(self, n)
def connect(self, item1, item2):
pid1 = self.parent(item1)
pid2 = self.parent(item2)
self.arr[pid2] = pid1
def parent(self, index):
<|code_end|>
. Write the next line using the current file imports:
from unionfind.base import UnionFind
and context from other files:
# Path: unionfind/base.py
# class UnionFind(object):
#
# def __init__(self, n):
# self.n = n
# self.__initArray()
#
# def __initArray(self):
# self.arr = [i for i in xrange(self.n)]
#
# def connect(self, item1, item2):
# raise Exception("Not implemented")
#
# def parent(self, index):
# raise Exception("Not implemented")
#
# def isConnected(self, item1, item2):
# return self.parent(item1) == self.parent(item2)
, which may include functions, classes, or code. Output only the next line. | current_item = index |
Next line prediction: <|code_start|>
FALSE_STR_PATTREN = '^(0|false|False)$'
def get_public_functions(module):
"""Get public functions in a module. Return a dictionary of function names
to objects."""
return {
o[0]: o[1] for o in getmembers(module, isfunction)
if not o[0].startswith('_')
}
def str_to_bool(s):
if re.match(FALSE_STR_PATTREN, s):
return False
return True
def to_list(value, sep=','):
if isinstance(value, list):
return value
elif isinstance(value, (txt_type, bin_type)):
return value.split(',')
else:
<|code_end|>
. Use current file imports:
(import re
from inspect import getmembers, isfunction
from momo.utils import txt_type, bin_type)
and context including class names, function names, or small code snippets from other files:
# Path: momo/utils.py
# MIN_PAGE_LINES = 50
# PY3 = sys.version_info[0] == 3
# def eval_path(path):
# def smart_print(*args, **kwargs):
# def utf8_decode(s):
# def utf8_encode(s):
# def run_cmd(cmd_str=None, cmd=None, cmd_args=None, stdout=sys.stdout,
# stderr=sys.stderr, stdin=None):
# def open_default(path):
# def mkdir_p(path):
# def page_lines(lines):
. Output only the next line. | return [value] |
Continue the code snippet: <|code_start|>
FALSE_STR_PATTREN = '^(0|false|False)$'
def get_public_functions(module):
"""Get public functions in a module. Return a dictionary of function names
to objects."""
return {
o[0]: o[1] for o in getmembers(module, isfunction)
if not o[0].startswith('_')
}
<|code_end|>
. Use current file imports:
import re
from inspect import getmembers, isfunction
from momo.utils import txt_type, bin_type
and context (classes, functions, or code) from other files:
# Path: momo/utils.py
# MIN_PAGE_LINES = 50
# PY3 = sys.version_info[0] == 3
# def eval_path(path):
# def smart_print(*args, **kwargs):
# def utf8_decode(s):
# def utf8_encode(s):
# def run_cmd(cmd_str=None, cmd=None, cmd_args=None, stdout=sys.stdout,
# stderr=sys.stderr, stdin=None):
# def open_default(path):
# def mkdir_p(path):
# def page_lines(lines):
. Output only the next line. | def str_to_bool(s): |
Using the snippet: <|code_start|>
def add_line(f, line=None):
if line is None:
f.write('\n')
else:
f.write(utf8_encode(line) + '\n')
@pytest.mark.usefixtures('testdir')
class TestSettings:
@pytest.mark.usefixtures('settings_file')
def test_settings_file(self, settings_file):
# explicit pass arguments
settings_dir = os.path.dirname(settings_file)
settings = Settings(settings_dir=settings_dir,
settings_file=settings_file)
assert settings.settings_dir == settings_dir
assert settings.settings_file == settings_file
# set environment variables
os.environ[ENV_SETTINGS_DIR] = settings_dir
os.environ[ENV_SETTINGS_FILE] = settings_file
settings = Settings(settings_dir=settings_dir,
settings_file=settings_file)
assert settings.settings_dir == settings_dir
assert settings.settings_file == settings_file
# add test settings
with open(settings_file, 'w') as f:
<|code_end|>
, determine the next line of code. You have imports:
import os
import pytest
from momo.utils import utf8_encode
from momo.settings import Settings, ENV_SETTINGS_DIR, ENV_SETTINGS_FILE
and context (class names, function names, or code) available:
# Path: momo/utils.py
# def utf8_encode(s):
# res = s
# if isinstance(res, six.text_type):
# res = s.encode('utf-8')
# return res
#
# Path: momo/settings.py
# class Settings(object):
# """
# The Settings class.
#
# :param backend: the backend type
#
# """
#
# # default settings
# _defaults = {
# 'backend': 'yaml',
# 'lazy_bucket': True,
# 'plugins': {},
# 'action': 'default'
# }
#
# def __init__(self, settings_dir=None, settings_file=None):
# self._backend = self._defaults['backend']
# self._buckets = None
# self._settings = None
# self._cbn = 'default' # current bucket name
# self.settings_dir = settings_dir or self._get_settings_dir()
# self.settings_file = settings_file or self._get_settings_file()
#
# def _get_settings_dir(self):
# return os.environ.get(ENV_SETTINGS_DIR) or DEFAULT_SETTINGS_DIR
#
# def _get_settings_file(self):
# return os.environ.get(ENV_SETTINGS_FILE) or DEFAULT_SETTINGS_FILE
#
# def load(self):
# if os.path.exists(self.settings_file):
# with open(self.settings_file) as f:
# self._settings = yaml.load(f.read())
# return True
# return False
#
# def _get_default_bucket_path(self):
# path = os.environ.get(ENV_DEFAULT_BUCKET)
# if path is not None:
# return path
# filetypes = BUCKET_FILE_TYPES[self._backend]
# # for dev
# for ft in filetypes:
# path = os.path.join(PROJECT_PATH, 'momo' + ft)
# if os.path.exists(path):
# return path
# for ft in filetypes:
# path = os.path.join(eval_path('~'), '.momo' + ft)
# if os.path.exists(path):
# return path
# self._create_default_bucket_path()
# return DEFULT_BUCKET_PATH
#
# def _create_default_bucket_path(self):
# self._create_empty_bucket(DEFULT_BUCKET_PATH)
#
# def _create_empty_bucket(self, path):
# dirname = os.path.dirname(path)
# mkdir_p(dirname)
# if not os.path.exists(path):
# with open(path, 'w') as f:
# f.write('%s: true' % PLACEHOLDER)
#
# @property
# def buckets(self):
# """
# Get all buckets as a dictionary of names to paths.
#
# :return: a dictionary of buckets.
#
# """
# if self._settings is not None:
# if 'buckets' in self._settings:
# self._buckets = {
# name: eval_path(path)
# for name, path in self._settings['buckets'].items()
# }
# if self._buckets is None:
# name = 'default'
# path = self._get_default_bucket_path()
# self._buckets = {
# name: eval_path(path),
# }
# return self._buckets
#
# def to_bucket(self, name, path):
# BucketDocument = getattr(self.backend, 'BucketDocument')
# document = BucketDocument(name, path)
# return Bucket(document, self)
#
# @property
# def bucket(self):
# """
# Load the bucket (named self.cbn) from path.
# """
# name = self.cbn
# if name not in self.buckets:
# raise SettingsError('bucket "%s" does not exist' % name)
# path = self.buckets[name]
# if not os.path.exists(path):
# self._create_empty_bucket(path)
# return self.to_bucket(name, path)
#
# @property
# def backend(self):
# return getattr(backends, self._backend)
#
# @property
# def cbn(self):
# """
# Get the current bucket name.
# """
# return self._cbn
#
# @cbn.setter
# def cbn(self, name):
# """Set the current bucket name."""
# self._cbn = name
#
# def __getattr__(self, name):
# res = None
# if self._settings is not None:
# res = self._settings.get(name)
# if res is None:
# res = self._defaults.get(name)
# if res is None:
# raise SettingsError('"%s" setting is not found' % name)
# return res
#
# ENV_SETTINGS_DIR = 'MOMO_SETTINGS_DIR'
#
# ENV_SETTINGS_FILE = 'MOMO_SETTINGS_FILE'
. Output only the next line. | add_line(f, 'test_key: test_value') |
Given the code snippet: <|code_start|>
def add_line(f, line=None):
if line is None:
f.write('\n')
else:
f.write(utf8_encode(line) + '\n')
@pytest.mark.usefixtures('testdir')
class TestSettings:
@pytest.mark.usefixtures('settings_file')
def test_settings_file(self, settings_file):
# explicit pass arguments
settings_dir = os.path.dirname(settings_file)
settings = Settings(settings_dir=settings_dir,
settings_file=settings_file)
assert settings.settings_dir == settings_dir
assert settings.settings_file == settings_file
# set environment variables
os.environ[ENV_SETTINGS_DIR] = settings_dir
os.environ[ENV_SETTINGS_FILE] = settings_file
settings = Settings(settings_dir=settings_dir,
settings_file=settings_file)
assert settings.settings_dir == settings_dir
assert settings.settings_file == settings_file
# add test settings
with open(settings_file, 'w') as f:
<|code_end|>
, generate the next line using the imports in this file:
import os
import pytest
from momo.utils import utf8_encode
from momo.settings import Settings, ENV_SETTINGS_DIR, ENV_SETTINGS_FILE
and context (functions, classes, or occasionally code) from other files:
# Path: momo/utils.py
# def utf8_encode(s):
# res = s
# if isinstance(res, six.text_type):
# res = s.encode('utf-8')
# return res
#
# Path: momo/settings.py
# class Settings(object):
# """
# The Settings class.
#
# :param backend: the backend type
#
# """
#
# # default settings
# _defaults = {
# 'backend': 'yaml',
# 'lazy_bucket': True,
# 'plugins': {},
# 'action': 'default'
# }
#
# def __init__(self, settings_dir=None, settings_file=None):
# self._backend = self._defaults['backend']
# self._buckets = None
# self._settings = None
# self._cbn = 'default' # current bucket name
# self.settings_dir = settings_dir or self._get_settings_dir()
# self.settings_file = settings_file or self._get_settings_file()
#
# def _get_settings_dir(self):
# return os.environ.get(ENV_SETTINGS_DIR) or DEFAULT_SETTINGS_DIR
#
# def _get_settings_file(self):
# return os.environ.get(ENV_SETTINGS_FILE) or DEFAULT_SETTINGS_FILE
#
# def load(self):
# if os.path.exists(self.settings_file):
# with open(self.settings_file) as f:
# self._settings = yaml.load(f.read())
# return True
# return False
#
# def _get_default_bucket_path(self):
# path = os.environ.get(ENV_DEFAULT_BUCKET)
# if path is not None:
# return path
# filetypes = BUCKET_FILE_TYPES[self._backend]
# # for dev
# for ft in filetypes:
# path = os.path.join(PROJECT_PATH, 'momo' + ft)
# if os.path.exists(path):
# return path
# for ft in filetypes:
# path = os.path.join(eval_path('~'), '.momo' + ft)
# if os.path.exists(path):
# return path
# self._create_default_bucket_path()
# return DEFULT_BUCKET_PATH
#
# def _create_default_bucket_path(self):
# self._create_empty_bucket(DEFULT_BUCKET_PATH)
#
# def _create_empty_bucket(self, path):
# dirname = os.path.dirname(path)
# mkdir_p(dirname)
# if not os.path.exists(path):
# with open(path, 'w') as f:
# f.write('%s: true' % PLACEHOLDER)
#
# @property
# def buckets(self):
# """
# Get all buckets as a dictionary of names to paths.
#
# :return: a dictionary of buckets.
#
# """
# if self._settings is not None:
# if 'buckets' in self._settings:
# self._buckets = {
# name: eval_path(path)
# for name, path in self._settings['buckets'].items()
# }
# if self._buckets is None:
# name = 'default'
# path = self._get_default_bucket_path()
# self._buckets = {
# name: eval_path(path),
# }
# return self._buckets
#
# def to_bucket(self, name, path):
# BucketDocument = getattr(self.backend, 'BucketDocument')
# document = BucketDocument(name, path)
# return Bucket(document, self)
#
# @property
# def bucket(self):
# """
# Load the bucket (named self.cbn) from path.
# """
# name = self.cbn
# if name not in self.buckets:
# raise SettingsError('bucket "%s" does not exist' % name)
# path = self.buckets[name]
# if not os.path.exists(path):
# self._create_empty_bucket(path)
# return self.to_bucket(name, path)
#
# @property
# def backend(self):
# return getattr(backends, self._backend)
#
# @property
# def cbn(self):
# """
# Get the current bucket name.
# """
# return self._cbn
#
# @cbn.setter
# def cbn(self, name):
# """Set the current bucket name."""
# self._cbn = name
#
# def __getattr__(self, name):
# res = None
# if self._settings is not None:
# res = self._settings.get(name)
# if res is None:
# res = self._defaults.get(name)
# if res is None:
# raise SettingsError('"%s" setting is not found' % name)
# return res
#
# ENV_SETTINGS_DIR = 'MOMO_SETTINGS_DIR'
#
# ENV_SETTINGS_FILE = 'MOMO_SETTINGS_FILE'
. Output only the next line. | add_line(f, 'test_key: test_value') |
Based on the snippet: <|code_start|>
def add_line(f, line=None):
if line is None:
f.write('\n')
else:
f.write(utf8_encode(line) + '\n')
@pytest.mark.usefixtures('testdir')
class TestSettings:
@pytest.mark.usefixtures('settings_file')
def test_settings_file(self, settings_file):
# explicit pass arguments
settings_dir = os.path.dirname(settings_file)
settings = Settings(settings_dir=settings_dir,
settings_file=settings_file)
assert settings.settings_dir == settings_dir
assert settings.settings_file == settings_file
# set environment variables
os.environ[ENV_SETTINGS_DIR] = settings_dir
os.environ[ENV_SETTINGS_FILE] = settings_file
settings = Settings(settings_dir=settings_dir,
settings_file=settings_file)
assert settings.settings_dir == settings_dir
assert settings.settings_file == settings_file
# add test settings
with open(settings_file, 'w') as f:
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import pytest
from momo.utils import utf8_encode
from momo.settings import Settings, ENV_SETTINGS_DIR, ENV_SETTINGS_FILE
and context (classes, functions, sometimes code) from other files:
# Path: momo/utils.py
# def utf8_encode(s):
# res = s
# if isinstance(res, six.text_type):
# res = s.encode('utf-8')
# return res
#
# Path: momo/settings.py
# class Settings(object):
# """
# The Settings class.
#
# :param backend: the backend type
#
# """
#
# # default settings
# _defaults = {
# 'backend': 'yaml',
# 'lazy_bucket': True,
# 'plugins': {},
# 'action': 'default'
# }
#
# def __init__(self, settings_dir=None, settings_file=None):
# self._backend = self._defaults['backend']
# self._buckets = None
# self._settings = None
# self._cbn = 'default' # current bucket name
# self.settings_dir = settings_dir or self._get_settings_dir()
# self.settings_file = settings_file or self._get_settings_file()
#
# def _get_settings_dir(self):
# return os.environ.get(ENV_SETTINGS_DIR) or DEFAULT_SETTINGS_DIR
#
# def _get_settings_file(self):
# return os.environ.get(ENV_SETTINGS_FILE) or DEFAULT_SETTINGS_FILE
#
# def load(self):
# if os.path.exists(self.settings_file):
# with open(self.settings_file) as f:
# self._settings = yaml.load(f.read())
# return True
# return False
#
# def _get_default_bucket_path(self):
# path = os.environ.get(ENV_DEFAULT_BUCKET)
# if path is not None:
# return path
# filetypes = BUCKET_FILE_TYPES[self._backend]
# # for dev
# for ft in filetypes:
# path = os.path.join(PROJECT_PATH, 'momo' + ft)
# if os.path.exists(path):
# return path
# for ft in filetypes:
# path = os.path.join(eval_path('~'), '.momo' + ft)
# if os.path.exists(path):
# return path
# self._create_default_bucket_path()
# return DEFULT_BUCKET_PATH
#
# def _create_default_bucket_path(self):
# self._create_empty_bucket(DEFULT_BUCKET_PATH)
#
# def _create_empty_bucket(self, path):
# dirname = os.path.dirname(path)
# mkdir_p(dirname)
# if not os.path.exists(path):
# with open(path, 'w') as f:
# f.write('%s: true' % PLACEHOLDER)
#
# @property
# def buckets(self):
# """
# Get all buckets as a dictionary of names to paths.
#
# :return: a dictionary of buckets.
#
# """
# if self._settings is not None:
# if 'buckets' in self._settings:
# self._buckets = {
# name: eval_path(path)
# for name, path in self._settings['buckets'].items()
# }
# if self._buckets is None:
# name = 'default'
# path = self._get_default_bucket_path()
# self._buckets = {
# name: eval_path(path),
# }
# return self._buckets
#
# def to_bucket(self, name, path):
# BucketDocument = getattr(self.backend, 'BucketDocument')
# document = BucketDocument(name, path)
# return Bucket(document, self)
#
# @property
# def bucket(self):
# """
# Load the bucket (named self.cbn) from path.
# """
# name = self.cbn
# if name not in self.buckets:
# raise SettingsError('bucket "%s" does not exist' % name)
# path = self.buckets[name]
# if not os.path.exists(path):
# self._create_empty_bucket(path)
# return self.to_bucket(name, path)
#
# @property
# def backend(self):
# return getattr(backends, self._backend)
#
# @property
# def cbn(self):
# """
# Get the current bucket name.
# """
# return self._cbn
#
# @cbn.setter
# def cbn(self, name):
# """Set the current bucket name."""
# self._cbn = name
#
# def __getattr__(self, name):
# res = None
# if self._settings is not None:
# res = self._settings.get(name)
# if res is None:
# res = self._defaults.get(name)
# if res is None:
# raise SettingsError('"%s" setting is not found' % name)
# return res
#
# ENV_SETTINGS_DIR = 'MOMO_SETTINGS_DIR'
#
# ENV_SETTINGS_FILE = 'MOMO_SETTINGS_FILE'
. Output only the next line. | add_line(f, 'test_key: test_value') |
Continue the code snippet: <|code_start|>
def add_line(f, line=None):
if line is None:
f.write('\n')
else:
f.write(utf8_encode(line) + '\n')
@pytest.mark.usefixtures('testdir')
class TestSettings:
@pytest.mark.usefixtures('settings_file')
<|code_end|>
. Use current file imports:
import os
import pytest
from momo.utils import utf8_encode
from momo.settings import Settings, ENV_SETTINGS_DIR, ENV_SETTINGS_FILE
and context (classes, functions, or code) from other files:
# Path: momo/utils.py
# def utf8_encode(s):
# res = s
# if isinstance(res, six.text_type):
# res = s.encode('utf-8')
# return res
#
# Path: momo/settings.py
# class Settings(object):
# """
# The Settings class.
#
# :param backend: the backend type
#
# """
#
# # default settings
# _defaults = {
# 'backend': 'yaml',
# 'lazy_bucket': True,
# 'plugins': {},
# 'action': 'default'
# }
#
# def __init__(self, settings_dir=None, settings_file=None):
# self._backend = self._defaults['backend']
# self._buckets = None
# self._settings = None
# self._cbn = 'default' # current bucket name
# self.settings_dir = settings_dir or self._get_settings_dir()
# self.settings_file = settings_file or self._get_settings_file()
#
# def _get_settings_dir(self):
# return os.environ.get(ENV_SETTINGS_DIR) or DEFAULT_SETTINGS_DIR
#
# def _get_settings_file(self):
# return os.environ.get(ENV_SETTINGS_FILE) or DEFAULT_SETTINGS_FILE
#
# def load(self):
# if os.path.exists(self.settings_file):
# with open(self.settings_file) as f:
# self._settings = yaml.load(f.read())
# return True
# return False
#
# def _get_default_bucket_path(self):
# path = os.environ.get(ENV_DEFAULT_BUCKET)
# if path is not None:
# return path
# filetypes = BUCKET_FILE_TYPES[self._backend]
# # for dev
# for ft in filetypes:
# path = os.path.join(PROJECT_PATH, 'momo' + ft)
# if os.path.exists(path):
# return path
# for ft in filetypes:
# path = os.path.join(eval_path('~'), '.momo' + ft)
# if os.path.exists(path):
# return path
# self._create_default_bucket_path()
# return DEFULT_BUCKET_PATH
#
# def _create_default_bucket_path(self):
# self._create_empty_bucket(DEFULT_BUCKET_PATH)
#
# def _create_empty_bucket(self, path):
# dirname = os.path.dirname(path)
# mkdir_p(dirname)
# if not os.path.exists(path):
# with open(path, 'w') as f:
# f.write('%s: true' % PLACEHOLDER)
#
# @property
# def buckets(self):
# """
# Get all buckets as a dictionary of names to paths.
#
# :return: a dictionary of buckets.
#
# """
# if self._settings is not None:
# if 'buckets' in self._settings:
# self._buckets = {
# name: eval_path(path)
# for name, path in self._settings['buckets'].items()
# }
# if self._buckets is None:
# name = 'default'
# path = self._get_default_bucket_path()
# self._buckets = {
# name: eval_path(path),
# }
# return self._buckets
#
# def to_bucket(self, name, path):
# BucketDocument = getattr(self.backend, 'BucketDocument')
# document = BucketDocument(name, path)
# return Bucket(document, self)
#
# @property
# def bucket(self):
# """
# Load the bucket (named self.cbn) from path.
# """
# name = self.cbn
# if name not in self.buckets:
# raise SettingsError('bucket "%s" does not exist' % name)
# path = self.buckets[name]
# if not os.path.exists(path):
# self._create_empty_bucket(path)
# return self.to_bucket(name, path)
#
# @property
# def backend(self):
# return getattr(backends, self._backend)
#
# @property
# def cbn(self):
# """
# Get the current bucket name.
# """
# return self._cbn
#
# @cbn.setter
# def cbn(self, name):
# """Set the current bucket name."""
# self._cbn = name
#
# def __getattr__(self, name):
# res = None
# if self._settings is not None:
# res = self._settings.get(name)
# if res is None:
# res = self._defaults.get(name)
# if res is None:
# raise SettingsError('"%s" setting is not found' % name)
# return res
#
# ENV_SETTINGS_DIR = 'MOMO_SETTINGS_DIR'
#
# ENV_SETTINGS_FILE = 'MOMO_SETTINGS_FILE'
. Output only the next line. | def test_settings_file(self, settings_file): |
Predict the next line for this snippet: <|code_start|>
BASE_CONFIG_NAME = '__base__'
class Mkdocs(Plugin):
mkdocs_configs = {
'theme': 'readthedocs',
}
momo_configs = {
'momo_root_name': 'Home',
'momo_page_level': 1,
'momo_attr_table': True,
'momo_attr_css': True,
'momo_docs_dir': None,
'momo_docs_pathname': 'docs',
'momo_control_attr': False, # whether rendering control attriutes
}
def setup(self):
self.root = self.settings.bucket.root
bucket_name = self.settings.bucket.name
base_configs = self.settings.plugins.get(
'mkdocs', {}).get(BASE_CONFIG_NAME, {})
<|code_end|>
with the help of current file imports:
import os
import shutil
import yaml
import glob
from momo.utils import run_cmd, mkdir_p, utf8_encode, txt_type, eval_path
from momo.plugins.base import Plugin
and context from other files:
# Path: momo/utils.py
# MIN_PAGE_LINES = 50
# PY3 = sys.version_info[0] == 3
# def eval_path(path):
# def smart_print(*args, **kwargs):
# def utf8_decode(s):
# def utf8_encode(s):
# def run_cmd(cmd_str=None, cmd=None, cmd_args=None, stdout=sys.stdout,
# stderr=sys.stderr, stdin=None):
# def open_default(path):
# def mkdir_p(path):
# def page_lines(lines):
#
# Path: momo/plugins/base.py
# class Plugin(object):
# def __init__(self):
# self.settings = settings
#
# def setup(self):
# """Initializae the plugin"""
# raise NotImplementedError
#
# def run(self, extra_args=None):
# """Run the plugin
#
# :param extra_args: a list of command-line arguments to pass to the
# underlying plugin.
# """
# raise NotImplementedError
, which may contain function names, class names, or code. Output only the next line. | configs = self.settings.plugins.get( |
Predict the next line after this snippet: <|code_start|>
self.mkdocs_root_dir = os.path.join(self.settings.settings_dir,
'mkdocs')
self.mkdocs_dir = os.path.join(self.mkdocs_root_dir,
bucket_name)
self.docs_dir = os.path.join(self.mkdocs_dir, 'docs')
self.site_dir = os.path.join(self.mkdocs_dir, 'site')
if os.path.exists(self.docs_dir):
shutil.rmtree(self.docs_dir)
mkdir_p(self.docs_dir)
mkdir_p(self.site_dir)
assets = glob.glob(os.path.join(self.mkdocs_dir, '*'))
for asset in assets:
filename = os.path.basename(asset)
if filename not in set(['docs', 'site', 'mkdocs.yml']):
os.symlink(asset, os.path.join(self.docs_dir, filename))
self.root.name = self.momo_configs['momo_root_name']
def _get_pages(self, root, level=0):
if level == self.momo_configs['momo_page_level']:
filename = self._make_page(root)
return filename
else:
pages = [
{'Index': self._make_index_page(root, level + 1)}
]
pages += [
{elem.name: self._get_pages(elem, level + 1)}
for elem in root.node_svals
<|code_end|>
using the current file's imports:
import os
import shutil
import yaml
import glob
from momo.utils import run_cmd, mkdir_p, utf8_encode, txt_type, eval_path
from momo.plugins.base import Plugin
and any relevant context from other files:
# Path: momo/utils.py
# MIN_PAGE_LINES = 50
# PY3 = sys.version_info[0] == 3
# def eval_path(path):
# def smart_print(*args, **kwargs):
# def utf8_decode(s):
# def utf8_encode(s):
# def run_cmd(cmd_str=None, cmd=None, cmd_args=None, stdout=sys.stdout,
# stderr=sys.stderr, stdin=None):
# def open_default(path):
# def mkdir_p(path):
# def page_lines(lines):
#
# Path: momo/plugins/base.py
# class Plugin(object):
# def __init__(self):
# self.settings = settings
#
# def setup(self):
# """Initializae the plugin"""
# raise NotImplementedError
#
# def run(self, extra_args=None):
# """Run the plugin
#
# :param extra_args: a list of command-line arguments to pass to the
# underlying plugin.
# """
# raise NotImplementedError
. Output only the next line. | ] |
Given snippet: <|code_start|>
BASE_CONFIG_NAME = '__base__'
class Mkdocs(Plugin):
mkdocs_configs = {
'theme': 'readthedocs',
}
momo_configs = {
'momo_root_name': 'Home',
'momo_page_level': 1,
'momo_attr_table': True,
'momo_attr_css': True,
'momo_docs_dir': None,
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import shutil
import yaml
import glob
from momo.utils import run_cmd, mkdir_p, utf8_encode, txt_type, eval_path
from momo.plugins.base import Plugin
and context:
# Path: momo/utils.py
# MIN_PAGE_LINES = 50
# PY3 = sys.version_info[0] == 3
# def eval_path(path):
# def smart_print(*args, **kwargs):
# def utf8_decode(s):
# def utf8_encode(s):
# def run_cmd(cmd_str=None, cmd=None, cmd_args=None, stdout=sys.stdout,
# stderr=sys.stderr, stdin=None):
# def open_default(path):
# def mkdir_p(path):
# def page_lines(lines):
#
# Path: momo/plugins/base.py
# class Plugin(object):
# def __init__(self):
# self.settings = settings
#
# def setup(self):
# """Initializae the plugin"""
# raise NotImplementedError
#
# def run(self, extra_args=None):
# """Run the plugin
#
# :param extra_args: a list of command-line arguments to pass to the
# underlying plugin.
# """
# raise NotImplementedError
which might include code, classes, or functions. Output only the next line. | 'momo_docs_pathname': 'docs', |
Based on the snippet: <|code_start|>
BASE_CONFIG_NAME = '__base__'
class Mkdocs(Plugin):
mkdocs_configs = {
'theme': 'readthedocs',
}
momo_configs = {
'momo_root_name': 'Home',
'momo_page_level': 1,
'momo_attr_table': True,
'momo_attr_css': True,
'momo_docs_dir': None,
'momo_docs_pathname': 'docs',
'momo_control_attr': False, # whether rendering control attriutes
}
def setup(self):
self.root = self.settings.bucket.root
bucket_name = self.settings.bucket.name
base_configs = self.settings.plugins.get(
'mkdocs', {}).get(BASE_CONFIG_NAME, {})
configs = self.settings.plugins.get(
'mkdocs', {}).get(bucket_name, {})
for k in base_configs:
if k not in configs:
configs[k] = base_configs[k]
# mkdocs site_name defaults to bucket name
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import shutil
import yaml
import glob
from momo.utils import run_cmd, mkdir_p, utf8_encode, txt_type, eval_path
from momo.plugins.base import Plugin
and context (classes, functions, sometimes code) from other files:
# Path: momo/utils.py
# MIN_PAGE_LINES = 50
# PY3 = sys.version_info[0] == 3
# def eval_path(path):
# def smart_print(*args, **kwargs):
# def utf8_decode(s):
# def utf8_encode(s):
# def run_cmd(cmd_str=None, cmd=None, cmd_args=None, stdout=sys.stdout,
# stderr=sys.stderr, stdin=None):
# def open_default(path):
# def mkdir_p(path):
# def page_lines(lines):
#
# Path: momo/plugins/base.py
# class Plugin(object):
# def __init__(self):
# self.settings = settings
#
# def setup(self):
# """Initializae the plugin"""
# raise NotImplementedError
#
# def run(self, extra_args=None):
# """Run the plugin
#
# :param extra_args: a list of command-line arguments to pass to the
# underlying plugin.
# """
# raise NotImplementedError
. Output only the next line. | self.mkdocs_configs['site_name'] = bucket_name |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.