Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Predict the next line for this snippet: <|code_start|>
class Fieldset:
def __init__(self, name, index):
self.name = name
<|code_end|>
with the help of current file imports:
from decimal import Decimal as D
from django import forms
from django.utils.text import force_text
from django.utils.translation import ugettext_lazy as _
from core import models
and context from other files:
# Path: core/models.py
# def _get_file_path(instance, filename):
# def age(self):
# def __str__(self):
# def __str__(self):
# def __str__(self):
# def __str__(self):
# def __str__(self):
# def __str__(self):
# def documentation_correct(self):
# def __str__(self):
# class Person(models.Model):
# class Meta:
# class Recipient(models.Model):
# class Meta:
# class Volunteer(models.Model):
# class Meta:
# class Custodian(models.Model):
# class Meta:
# class Project(models.Model):
# class Meta:
# class Group(models.Model):
# class Meta:
# class Event(models.Model):
# class Meta:
# class Enrolment(models.Model):
# class Meta:
# class Membership(models.Model):
# class Meta:
# class Member(models.Model):
# class Meta:
# CATEGORIES = [
# ('child', _('Infantil')),
# ('juvenile', _('Juvenil')),
# ]
# COURSES = [
# ('4EI', _('4 Educacion Infantil')),
# ('5EI', _('5 Educacion Infantil')),
# ('6EI', _('6 Educacion Infantil')),
# ('1EP', _('1 Educacion Primaria')),
# ('2EP', _('2 Educacion Primaria')),
# ('3EP', _('3 Educacion Primaria')),
# ('4EP', _('4 Educacion Primaria')),
# ('5EP', _('5 Educacion Primaria')),
# ('6EP', _('6 Educacion Primaria')),
# ('1ESO', _('1 Educación Secundaria Obligatoria')),
# ('2ESO', _('2 Educación Secundaria Obligatoria')),
# ('3ESO', _('3 Educación Secundaria Obligatoria')),
# ('4ESO', _('4 Educación Secundaria Obligatoria')),
# ('1BACH', _('1 Bachillerato')),
# ('2BACH', _('2 Bachillerato')),
# ('FP', _('Formación Profesional')),
# ('CARRERA', _('Carrera Universitaria')),
# ]
# CATEGORIES = [
# ('father', _('Padre')),
# ('mother', _('Madre')),
# ('legal', _('Tutor')),
# ]
# CATEGORY = [
# ('child', _('Infantil')),
# ('juvenile', _('Juvenil')),
# ('volunteer', _('Voluntario')),
# ('contributor', _('Colaborador')),
# ('family', _('Familiar')),
# ]
, which may contain function names, class names, or code. Output only the next line. | self.index = index |
Given the following code snippet before the placeholder: <|code_start|> # 'Voluntarios',
# Option(_('Voluntarios'), 'volunteer-list', menu=self),
# Option(_('Detalle voluntario'), None, menu=self),
# ),
# Menu(
# 'Socios',
# Option(_('Membresías'), 'membership-list', menu=self),
# Option(_('Socios'), 'member-list', menu=self),
# Option(_('Detalle socio'), None, menu=self),
# ),
# “””
# Menu(
# 'Grupos',
# Option(_('Grupos'), 'group-list', menu=self),
# Option(_('Detalle grupo'), None, menu=self),
# ),
# Menu(
# 'Proyectos',
# Option(_('Proyectos'), 'project-list', menu=self),
# Option(_('Detalle proyecto'), None, menu=self),
# ),
Menu(
'Actividades',
Option(_('Actividades'), 'event-list', menu=self),
Option(_('Detalle actividad'), None, menu=self),
),
Menu(
'Otros',
Option(_('Nuevo socio individual'), 'basicformnewperson', menu=self),
Option(_('Nueva familia'), 'basicformnewfamily', menu=self),
<|code_end|>
, predict the next line using imports from the current file:
from collections import OrderedDict as odict
from django.contrib import messages
from django.contrib.auth.mixins import LoginRequiredMixin
from django.contrib.auth.views import LoginView, LogoutView
from django.contrib.messages.views import SuccessMessageMixin
from django.core.urlresolvers import reverse_lazy
from django.db.models import ProtectedError
from django.http import HttpResponseRedirect, JsonResponse
from django.shortcuts import redirect, render, reverse
from django.utils.text import slugify
from django.utils.translation import ugettext as _
from django.utils.translation import ugettext_lazy
from django.views import generic
from django_filters.views import FilterView
from core import models
from . import filters, forms
and context including class names, function names, and sometimes code from other files:
# Path: core/models.py
# def _get_file_path(instance, filename):
# def age(self):
# def __str__(self):
# def __str__(self):
# def __str__(self):
# def __str__(self):
# def __str__(self):
# def __str__(self):
# def documentation_correct(self):
# def __str__(self):
# class Person(models.Model):
# class Meta:
# class Recipient(models.Model):
# class Meta:
# class Volunteer(models.Model):
# class Meta:
# class Custodian(models.Model):
# class Meta:
# class Project(models.Model):
# class Meta:
# class Group(models.Model):
# class Meta:
# class Event(models.Model):
# class Meta:
# class Enrolment(models.Model):
# class Meta:
# class Membership(models.Model):
# class Meta:
# class Member(models.Model):
# class Meta:
# CATEGORIES = [
# ('child', _('Infantil')),
# ('juvenile', _('Juvenil')),
# ]
# COURSES = [
# ('4EI', _('4 Educacion Infantil')),
# ('5EI', _('5 Educacion Infantil')),
# ('6EI', _('6 Educacion Infantil')),
# ('1EP', _('1 Educacion Primaria')),
# ('2EP', _('2 Educacion Primaria')),
# ('3EP', _('3 Educacion Primaria')),
# ('4EP', _('4 Educacion Primaria')),
# ('5EP', _('5 Educacion Primaria')),
# ('6EP', _('6 Educacion Primaria')),
# ('1ESO', _('1 Educación Secundaria Obligatoria')),
# ('2ESO', _('2 Educación Secundaria Obligatoria')),
# ('3ESO', _('3 Educación Secundaria Obligatoria')),
# ('4ESO', _('4 Educación Secundaria Obligatoria')),
# ('1BACH', _('1 Bachillerato')),
# ('2BACH', _('2 Bachillerato')),
# ('FP', _('Formación Profesional')),
# ('CARRERA', _('Carrera Universitaria')),
# ]
# CATEGORIES = [
# ('father', _('Padre')),
# ('mother', _('Madre')),
# ('legal', _('Tutor')),
# ]
# CATEGORY = [
# ('child', _('Infantil')),
# ('juvenile', _('Juvenil')),
# ('volunteer', _('Voluntario')),
# ('contributor', _('Colaborador')),
# ('family', _('Familiar')),
# ]
. Output only the next line. | ), |
Given snippet: <|code_start|>
class PersonFilter(django_filters.FilterSet):
q = django_filters.CharFilter(
label=_('Nombre'),
name='name',
method='custom_filter',
widget=forms.TextInput(attrs={'placeholder': _('Nombre')}),
)
def custom_filter(self, queryset, name, value):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django import forms
from django.db import models
from django.db.models import Q
from django.db.models import Value as V
from django.db.models.functions import Concat
from django.utils.translation import ugettext_lazy as _
from core.models import Event, Group, Project
import django_filters
and context:
# Path: core/models.py
# class Event(models.Model):
#
# class Meta:
# verbose_name = _('Actividad')
#
# event_name = models.TextField(
# verbose_name=_('Nombre actividad'))
# event_start = models.DateField(
# verbose_name=_('Fecha inicio'))
# event_end = models.DateField(
# verbose_name=_('Fecha fin'))
# comment = models.TextField(
# verbose_name=_('Observaciones'), blank=True, default='')
#
# class Group(models.Model):
#
# class Meta:
# verbose_name = _('Grupo')
#
# group_name = models.TextField(verbose_name=_('Nombre grupo'))
# project = models.ForeignKey(
# Project, on_delete=models.CASCADE, default=None, null=True, verbose_name=_('Proyecto'))
#
# def __str__(self):
# return '{}'.format(self.id)
#
# class Project(models.Model):
#
# class Meta:
# verbose_name = _('Proyecto')
#
# project_name = models.TextField(
# verbose_name=_('Nombre proyecto'))
# date_start = models.DateField(
# verbose_name=_('Fecha inicio'))
# date_end = models.DateField(
# verbose_name=('Fecha fin'))
# comment = models.TextField(
# verbose_name=_('Observaciones'), blank=True, default='')
#
# def __str__(self):
# return '{}'.format(self.project_name)
which might include code, classes, or functions. Output only the next line. | return queryset.annotate( |
Predict the next line after this snippet: <|code_start|>
class GroupFilter(django_filters.FilterSet):
q = django_filters.CharFilter(name='group_name', method='custom_filter')
class Meta:
model = Group
fields = []
def custom_filter(self, queryset, name, value):
return queryset.filter(Q(group_name__icontains=value))
class ProjectFilter(django_filters.FilterSet):
q = django_filters.CharFilter(name='project_name', method='custom_filter')
class Meta:
model = Project
fields = []
def custom_filter(self, queryset, name, value):
return queryset.filter(Q(project_name__icontains=value))
class EventFilter(django_filters.FilterSet):
q = django_filters.CharFilter(name='event_name', method='custom_filter')
<|code_end|>
using the current file's imports:
from django import forms
from django.db import models
from django.db.models import Q
from django.db.models import Value as V
from django.db.models.functions import Concat
from django.utils.translation import ugettext_lazy as _
from core.models import Event, Group, Project
import django_filters
and any relevant context from other files:
# Path: core/models.py
# class Event(models.Model):
#
# class Meta:
# verbose_name = _('Actividad')
#
# event_name = models.TextField(
# verbose_name=_('Nombre actividad'))
# event_start = models.DateField(
# verbose_name=_('Fecha inicio'))
# event_end = models.DateField(
# verbose_name=_('Fecha fin'))
# comment = models.TextField(
# verbose_name=_('Observaciones'), blank=True, default='')
#
# class Group(models.Model):
#
# class Meta:
# verbose_name = _('Grupo')
#
# group_name = models.TextField(verbose_name=_('Nombre grupo'))
# project = models.ForeignKey(
# Project, on_delete=models.CASCADE, default=None, null=True, verbose_name=_('Proyecto'))
#
# def __str__(self):
# return '{}'.format(self.id)
#
# class Project(models.Model):
#
# class Meta:
# verbose_name = _('Proyecto')
#
# project_name = models.TextField(
# verbose_name=_('Nombre proyecto'))
# date_start = models.DateField(
# verbose_name=_('Fecha inicio'))
# date_end = models.DateField(
# verbose_name=('Fecha fin'))
# comment = models.TextField(
# verbose_name=_('Observaciones'), blank=True, default='')
#
# def __str__(self):
# return '{}'.format(self.project_name)
. Output only the next line. | class Meta: |
Here is a snippet: <|code_start|>#!/usr/bin/env python
class HelloRoot(object):
def index(self):
return "Hello World!"
def page(self, page):
return page
class HelloApp(App):
def initialize(self):
ctl = HelloRoot()
route = self.route()
route.mapper.explicit = False
<|code_end|>
. Write the next line using the current file imports:
from solo.web.server import WebServer
from solo.web.app import App
and context from other files:
# Path: solo/web/server.py
# class WebServer(object):
#
# """Adapter for a gevent.wsgi.WSGIServer."""
#
# def __init__(self, *args, **kwargs):
# self.args = args
# self.kwargs = kwargs
# self.ready = False
#
# def start(self):
# """Start the GeventWSGIServer."""
# # We have to instantiate the server class here because its __init__
# from gevent.wsgi import WSGIServer
#
# self.ready = True
# LOGGER.debug('Starting Gevent WSGI Server...')
# self.httpd = WSGIServer(*self.args, **self.kwargs)
# self.httpd.serve_forever()
#
# def stop(self):
# """Stop the HTTP server."""
# LOGGER.debug('Stoping Gevent WSGI Server...')
# self.ready = False
# self.httpd.stop()
#
# Path: solo/web/app.py
# class App(object):
#
#
# hookpoints = ['on_start_resource', 'before_handler',
# 'on_end_resource', 'on_end_request',
# 'before_error_response', 'after_error_response']
#
#
# def __init__(self, name='Lilac', encoding='utf8', debug=False, dispatcher=None):
# self.dispatcher = dispatcher or RoutesDispatcher()
# self.name = name
# self.error_pages = {}
# self.encoding = encoding
# self.debug = debug
# self.hooks = HookMap()
# self.error_response = self._error_response
# self.initialize()
#
# def initialize(self):
# pass
#
# def route(self):
# return self.dispatcher
#
# def attach(self, point, callback, failsafe=None, priority=None, **kwargs):
# if point not in self.hookpoints:
# return
# self.hooks.attach(point, callback, failsafe, priority, **kwargs)
#
# def asset(self, name, path, asset_path, default_filename=None, block_size=None):
# """Set servering Static directory"""
# from solo.web.asset import AssetController
# path = '' if path == '/' else path
# ctl = AssetController(asset_path, default_filename, block_size)
# self.dispatcher.connect(name, path + "/{path:.*?}", controller=ctl, action='asset', conditions=dict(method=["HEAD", "GET"]))
#
#
# def error_page(self, code, callback):
# if type(code) is not int:
# raise TypeError("code:%d is not int type" %(code))
# self.error_pages[str(code)] = callback
#
# def __call__(self, environ, start_response):
# try:
# try:
# request = Request(environ)
# response = Response()
# serving.load(request, response)
# if request.charset is None:
# request.charset = self.encoding
#
# self.hooks.run('on_start_resource')
#
# path_info = environ['PATH_INFO']
# action, handler = self.dispatcher.match(request, path_info)
# body = None
# self.hooks.run('before_handler')
#
# if handler:
# body = handler()
# if type(body) is str:
# response.body = body
# elif body:
# response.text = body
# self.hooks.run('on_end_resource')
# return response(environ, start_response)
# else:
# raise exc.HTTPNotFound('Path %s Not Found' % (path_info))
#
# except exc.HTTPRedirection as e:
# serving.response.location = e.location
# serving.response.status = e.status
# response = serving.response
# self.hooks.run('on_end_resource')
# except exc.HTTPException as e:
# response = serving.response = self.handle_error_page(request, response, e)
# except Exception as e:
# LOGGER.error(e)
# self.error_response(request, response, e)
# return response(environ, start_response)
# finally:
# try:
# self.hooks.run('on_end_request')
# finally:
# serving.clear()
#
#
# def handle_error_page(self, request, response, exception):
# """Handle the last unanticipated exception. (Core)"""
# try:
# self.hooks.run("before_error_response")
# response.status = exception.status
# #response.status = exception.status
# handler = self.error_pages.get(str(exception.code), None)
# if handler:
# body = handler()
# if type(body) is str:
# response.body = body
# elif text:
# response.text = body
# return response
# else:
# return exception
# finally:
# self.hooks.run("after_error_response")
#
# def _error_response(self, request, response, exception):
# """Handle the unknow exception and also throw 5xx status and message to frontend"""
# cls, e, tb = exc_info()
#
# LOGGER.exception('Unhandled Error: %s', e)
#
# response.status_code = 500
# response.content_type = 'text/html; charset=UTF-8'
#
# if request.method != 'HEAD':
# response.unicode_body = u"""<html>
# <head><title>Internal Server Error </title></head>
# <body><p>An error occurred: <b>%s</b></p></body>
# </html>
# """ % (str(e))
, which may include functions, classes, or code. Output only the next line. | route.connect('index', '/', controller=ctl, action='index') |
Given snippet: <|code_start|>#!/usr/bin/env python
class HelloRoot(object):
def index(self):
return "Hello World!"
def page(self, page):
return page
class HelloApp(App):
def initialize(self):
ctl = HelloRoot()
route = self.route()
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from solo.web.server import WebServer
from solo.web.app import App
and context:
# Path: solo/web/server.py
# class WebServer(object):
#
# """Adapter for a gevent.wsgi.WSGIServer."""
#
# def __init__(self, *args, **kwargs):
# self.args = args
# self.kwargs = kwargs
# self.ready = False
#
# def start(self):
# """Start the GeventWSGIServer."""
# # We have to instantiate the server class here because its __init__
# from gevent.wsgi import WSGIServer
#
# self.ready = True
# LOGGER.debug('Starting Gevent WSGI Server...')
# self.httpd = WSGIServer(*self.args, **self.kwargs)
# self.httpd.serve_forever()
#
# def stop(self):
# """Stop the HTTP server."""
# LOGGER.debug('Stoping Gevent WSGI Server...')
# self.ready = False
# self.httpd.stop()
#
# Path: solo/web/app.py
# class App(object):
#
#
# hookpoints = ['on_start_resource', 'before_handler',
# 'on_end_resource', 'on_end_request',
# 'before_error_response', 'after_error_response']
#
#
# def __init__(self, name='Lilac', encoding='utf8', debug=False, dispatcher=None):
# self.dispatcher = dispatcher or RoutesDispatcher()
# self.name = name
# self.error_pages = {}
# self.encoding = encoding
# self.debug = debug
# self.hooks = HookMap()
# self.error_response = self._error_response
# self.initialize()
#
# def initialize(self):
# pass
#
# def route(self):
# return self.dispatcher
#
# def attach(self, point, callback, failsafe=None, priority=None, **kwargs):
# if point not in self.hookpoints:
# return
# self.hooks.attach(point, callback, failsafe, priority, **kwargs)
#
# def asset(self, name, path, asset_path, default_filename=None, block_size=None):
# """Set servering Static directory"""
# from solo.web.asset import AssetController
# path = '' if path == '/' else path
# ctl = AssetController(asset_path, default_filename, block_size)
# self.dispatcher.connect(name, path + "/{path:.*?}", controller=ctl, action='asset', conditions=dict(method=["HEAD", "GET"]))
#
#
# def error_page(self, code, callback):
# if type(code) is not int:
# raise TypeError("code:%d is not int type" %(code))
# self.error_pages[str(code)] = callback
#
# def __call__(self, environ, start_response):
# try:
# try:
# request = Request(environ)
# response = Response()
# serving.load(request, response)
# if request.charset is None:
# request.charset = self.encoding
#
# self.hooks.run('on_start_resource')
#
# path_info = environ['PATH_INFO']
# action, handler = self.dispatcher.match(request, path_info)
# body = None
# self.hooks.run('before_handler')
#
# if handler:
# body = handler()
# if type(body) is str:
# response.body = body
# elif body:
# response.text = body
# self.hooks.run('on_end_resource')
# return response(environ, start_response)
# else:
# raise exc.HTTPNotFound('Path %s Not Found' % (path_info))
#
# except exc.HTTPRedirection as e:
# serving.response.location = e.location
# serving.response.status = e.status
# response = serving.response
# self.hooks.run('on_end_resource')
# except exc.HTTPException as e:
# response = serving.response = self.handle_error_page(request, response, e)
# except Exception as e:
# LOGGER.error(e)
# self.error_response(request, response, e)
# return response(environ, start_response)
# finally:
# try:
# self.hooks.run('on_end_request')
# finally:
# serving.clear()
#
#
# def handle_error_page(self, request, response, exception):
# """Handle the last unanticipated exception. (Core)"""
# try:
# self.hooks.run("before_error_response")
# response.status = exception.status
# #response.status = exception.status
# handler = self.error_pages.get(str(exception.code), None)
# if handler:
# body = handler()
# if type(body) is str:
# response.body = body
# elif text:
# response.text = body
# return response
# else:
# return exception
# finally:
# self.hooks.run("after_error_response")
#
# def _error_response(self, request, response, exception):
# """Handle the unknow exception and also throw 5xx status and message to frontend"""
# cls, e, tb = exc_info()
#
# LOGGER.exception('Unhandled Error: %s', e)
#
# response.status_code = 500
# response.content_type = 'text/html; charset=UTF-8'
#
# if request.method != 'HEAD':
# response.unicode_body = u"""<html>
# <head><title>Internal Server Error </title></head>
# <body><p>An error occurred: <b>%s</b></p></body>
# </html>
# """ % (str(e))
which might include code, classes, or functions. Output only the next line. | route.mapper.explicit = False |
Predict the next line after this snippet: <|code_start|> '</div>'
js_code = '''if(!window.webflash){webflash=(function(){var j=document;var k=j.cookie;var f=null;var e=false;\
var g=null;var c=/msie|MSIE/.test(navigator.userAgent);var a=function(m){return j.createTextNode(m.message)};\
var l=function(n,m){};var b=function(o,m){var n=m;if(typeof(o)=="string"){n=window[o]}\
else{if(o){n=o}}return n};var h=function(){var p=k.indexOf(f+"=");if(p<0){return null}\
var o=p+f.length+1;var m=k.indexOf(";",o);if(m==-1){m=k.length}var n=k.substring(o,m);\
j.cookie=f+"=; expires=Fri, 02-Jan-1970 00:00:00 GMT; path=/";return webflash.lj(unescape(n))};\
var i=function(){if(e){return}e=true;var p=h();if(p!==null){var m=j.getElementById(g);\
var n=j.createElement("div");if(p.status){n.setAttribute(c?"className":"class",p.status)}\
var o=a(p);n.appendChild(o);m.style.display="block";if(p.delay){setTimeout(function(){m.style.display="none"},p.delay)}\
m.appendChild(n);l(p,m)}};var d=function(){if(!c){var m="DOMContentLoaded";\
j.addEventListener(m,function(){j.removeEventListener(m,arguments.callee,false);i()},false);\
window.addEventListener("load",i,false)}else{if(c){var m="onreadystatechange";\
j.attachEvent(m,function(){j.detachEvent(m,arguments.callee);i()});\
if(j.documentElement.doScroll&&!frameElement){(function(){if(e){return}try{j.documentElement.doScroll("left")}\
catch(n){setTimeout(arguments.callee,0);return}i()})()}window.attachEvent("load",i)}}};\
return function(m){f=m.name||"webflash";g=m.id||"webflash";l=b(m.on_display,l);a=b(m.create_node,a);\
return{payload:h,render:d}}})();webflash.lj=function(s){var r;eval("r="+s);return r}};'''
def __init__(self, cookie_name="webflash", default_status="ok"):
self.default_status = default_status
self.cookie_name = cookie_name
def __call__(self, message, status=None, **extra_payload):
# Force the message to be unicode so lazystrings, etc... are coerced
message = unicode_text(message)
payload = self.prepare_payload(message = message,
status = status or self.default_status,
<|code_end|>
using the current file's imports:
import sys
import logging
from urllib.parse import unquote as url_unquote
from urllib.parse import quote as url_quote
from urllib import unquote as url_unquote
from urllib import quote as url_quote
from solo.util import json_decode,json_encode
from solo.web.ctx import response, request
from markupsafe import escape_silent as escape
and any relevant context from other files:
# Path: solo/util.py
# def as_json(o):
# def json_encode(value, ensure_ascii=True, default=as_json):
#
# Path: solo/web/ctx.py
# LOGGER = logging.getLogger('solo.web')
# class GreenletServing(object):
# class _ThreadLocalProxy(object):
# def __init__(self):
# def load(self, request, response):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def clear(self):
# def __init__(self, attrname):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def __delattr__(self, name):
# def _get_dict(self):
# def __getitem__(self, key):
# def __setitem__(self, key, value):
# def __delitem__(self, key):
# def __contains__(self, key):
# def __len__(self):
# def __nonzero__(self):
. Output only the next line. | **extra_payload) |
Based on the snippet: <|code_start|> response.set_cookie(self.cookie_name, payload)
if len(response.headers['Set-Cookie']) > 4096:
raise ValueError('Flash value is too long (cookie would be >4k)')
def prepare_payload(self, **data):
return url_quote(json_encode(data))
def js_call(self, container_id):
return 'webflash(%(options)s).render();' % {'options': json_encode({'id': container_id,
'name': self.cookie_name})}
def render(self, container_id, use_js=True):
if use_js:
return self._render_js_version(container_id)
else:
return self._render_static_version(container_id)
def _render_static_version(self, container_id):
payload = self.pop_payload()
if not payload:
return ''
payload['message'] = escape(payload.get('message',''))
payload['container_id'] = container_id
return self.static_template % payload
def _render_js_version(self, container_id):
return self.template % {'container_id': container_id,
'js_code': self.js_code,
'js_call': self.js_call(container_id)}
<|code_end|>
, predict the immediate next line with the help of imports:
import sys
import logging
from urllib.parse import unquote as url_unquote
from urllib.parse import quote as url_quote
from urllib import unquote as url_unquote
from urllib import quote as url_quote
from solo.util import json_decode,json_encode
from solo.web.ctx import response, request
from markupsafe import escape_silent as escape
and context (classes, functions, sometimes code) from other files:
# Path: solo/util.py
# def as_json(o):
# def json_encode(value, ensure_ascii=True, default=as_json):
#
# Path: solo/web/ctx.py
# LOGGER = logging.getLogger('solo.web')
# class GreenletServing(object):
# class _ThreadLocalProxy(object):
# def __init__(self):
# def load(self, request, response):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def clear(self):
# def __init__(self, attrname):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def __delattr__(self, name):
# def _get_dict(self):
# def __getitem__(self, key):
# def __setitem__(self, key, value):
# def __delitem__(self, key):
# def __contains__(self, key):
# def __len__(self):
# def __nonzero__(self):
. Output only the next line. | def pop_payload(self): |
Given the code snippet: <|code_start|> '</div>'
js_code = '''if(!window.webflash){webflash=(function(){var j=document;var k=j.cookie;var f=null;var e=false;\
var g=null;var c=/msie|MSIE/.test(navigator.userAgent);var a=function(m){return j.createTextNode(m.message)};\
var l=function(n,m){};var b=function(o,m){var n=m;if(typeof(o)=="string"){n=window[o]}\
else{if(o){n=o}}return n};var h=function(){var p=k.indexOf(f+"=");if(p<0){return null}\
var o=p+f.length+1;var m=k.indexOf(";",o);if(m==-1){m=k.length}var n=k.substring(o,m);\
j.cookie=f+"=; expires=Fri, 02-Jan-1970 00:00:00 GMT; path=/";return webflash.lj(unescape(n))};\
var i=function(){if(e){return}e=true;var p=h();if(p!==null){var m=j.getElementById(g);\
var n=j.createElement("div");if(p.status){n.setAttribute(c?"className":"class",p.status)}\
var o=a(p);n.appendChild(o);m.style.display="block";if(p.delay){setTimeout(function(){m.style.display="none"},p.delay)}\
m.appendChild(n);l(p,m)}};var d=function(){if(!c){var m="DOMContentLoaded";\
j.addEventListener(m,function(){j.removeEventListener(m,arguments.callee,false);i()},false);\
window.addEventListener("load",i,false)}else{if(c){var m="onreadystatechange";\
j.attachEvent(m,function(){j.detachEvent(m,arguments.callee);i()});\
if(j.documentElement.doScroll&&!frameElement){(function(){if(e){return}try{j.documentElement.doScroll("left")}\
catch(n){setTimeout(arguments.callee,0);return}i()})()}window.attachEvent("load",i)}}};\
return function(m){f=m.name||"webflash";g=m.id||"webflash";l=b(m.on_display,l);a=b(m.create_node,a);\
return{payload:h,render:d}}})();webflash.lj=function(s){var r;eval("r="+s);return r}};'''
def __init__(self, cookie_name="webflash", default_status="ok"):
self.default_status = default_status
self.cookie_name = cookie_name
def __call__(self, message, status=None, **extra_payload):
# Force the message to be unicode so lazystrings, etc... are coerced
message = unicode_text(message)
payload = self.prepare_payload(message = message,
status = status or self.default_status,
<|code_end|>
, generate the next line using the imports in this file:
import sys
import logging
from urllib.parse import unquote as url_unquote
from urllib.parse import quote as url_quote
from urllib import unquote as url_unquote
from urllib import quote as url_quote
from solo.util import json_decode,json_encode
from solo.web.ctx import response, request
from markupsafe import escape_silent as escape
and context (functions, classes, or occasionally code) from other files:
# Path: solo/util.py
# def as_json(o):
# def json_encode(value, ensure_ascii=True, default=as_json):
#
# Path: solo/web/ctx.py
# LOGGER = logging.getLogger('solo.web')
# class GreenletServing(object):
# class _ThreadLocalProxy(object):
# def __init__(self):
# def load(self, request, response):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def clear(self):
# def __init__(self, attrname):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def __delattr__(self, name):
# def _get_dict(self):
# def __getitem__(self, key):
# def __setitem__(self, key, value):
# def __delitem__(self, key):
# def __contains__(self, key):
# def __len__(self):
# def __nonzero__(self):
. Output only the next line. | **extra_payload) |
Next line prediction: <|code_start|>
def __init__(self, cookie_name="webflash", default_status="ok"):
self.default_status = default_status
self.cookie_name = cookie_name
def __call__(self, message, status=None, **extra_payload):
# Force the message to be unicode so lazystrings, etc... are coerced
message = unicode_text(message)
payload = self.prepare_payload(message = message,
status = status or self.default_status,
**extra_payload)
if request is not None:
# Save the payload in environ too in case JavaScript is not being
# used and the message is being displayed in the same request.
request.environ['webflash.payload'] = payload
response.set_cookie(self.cookie_name, payload)
if len(response.headers['Set-Cookie']) > 4096:
raise ValueError('Flash value is too long (cookie would be >4k)')
def prepare_payload(self, **data):
return url_quote(json_encode(data))
def js_call(self, container_id):
return 'webflash(%(options)s).render();' % {'options': json_encode({'id': container_id,
'name': self.cookie_name})}
def render(self, container_id, use_js=True):
<|code_end|>
. Use current file imports:
(import sys
import logging
from urllib.parse import unquote as url_unquote
from urllib.parse import quote as url_quote
from urllib import unquote as url_unquote
from urllib import quote as url_quote
from solo.util import json_decode,json_encode
from solo.web.ctx import response, request
from markupsafe import escape_silent as escape)
and context including class names, function names, or small code snippets from other files:
# Path: solo/util.py
# def as_json(o):
# def json_encode(value, ensure_ascii=True, default=as_json):
#
# Path: solo/web/ctx.py
# LOGGER = logging.getLogger('solo.web')
# class GreenletServing(object):
# class _ThreadLocalProxy(object):
# def __init__(self):
# def load(self, request, response):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def clear(self):
# def __init__(self, attrname):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def __delattr__(self, name):
# def _get_dict(self):
# def __getitem__(self, key):
# def __setitem__(self, key, value):
# def __delitem__(self, key):
# def __contains__(self, key):
# def __len__(self):
# def __nonzero__(self):
. Output only the next line. | if use_js: |
Predict the next line after this snippet: <|code_start|>
class AssetApp(App):
def initialize(self):
root = os.path.join(os.path.dirname(__file__), "static")
<|code_end|>
using the current file's imports:
from solo.web.app import App
from solo.web.server import WebServer
import os.path
and any relevant context from other files:
# Path: solo/web/app.py
# class App(object):
#
#
# hookpoints = ['on_start_resource', 'before_handler',
# 'on_end_resource', 'on_end_request',
# 'before_error_response', 'after_error_response']
#
#
# def __init__(self, name='Lilac', encoding='utf8', debug=False, dispatcher=None):
# self.dispatcher = dispatcher or RoutesDispatcher()
# self.name = name
# self.error_pages = {}
# self.encoding = encoding
# self.debug = debug
# self.hooks = HookMap()
# self.error_response = self._error_response
# self.initialize()
#
# def initialize(self):
# pass
#
# def route(self):
# return self.dispatcher
#
# def attach(self, point, callback, failsafe=None, priority=None, **kwargs):
# if point not in self.hookpoints:
# return
# self.hooks.attach(point, callback, failsafe, priority, **kwargs)
#
# def asset(self, name, path, asset_path, default_filename=None, block_size=None):
# """Set servering Static directory"""
# from solo.web.asset import AssetController
# path = '' if path == '/' else path
# ctl = AssetController(asset_path, default_filename, block_size)
# self.dispatcher.connect(name, path + "/{path:.*?}", controller=ctl, action='asset', conditions=dict(method=["HEAD", "GET"]))
#
#
# def error_page(self, code, callback):
# if type(code) is not int:
# raise TypeError("code:%d is not int type" %(code))
# self.error_pages[str(code)] = callback
#
# def __call__(self, environ, start_response):
# try:
# try:
# request = Request(environ)
# response = Response()
# serving.load(request, response)
# if request.charset is None:
# request.charset = self.encoding
#
# self.hooks.run('on_start_resource')
#
# path_info = environ['PATH_INFO']
# action, handler = self.dispatcher.match(request, path_info)
# body = None
# self.hooks.run('before_handler')
#
# if handler:
# body = handler()
# if type(body) is str:
# response.body = body
# elif body:
# response.text = body
# self.hooks.run('on_end_resource')
# return response(environ, start_response)
# else:
# raise exc.HTTPNotFound('Path %s Not Found' % (path_info))
#
# except exc.HTTPRedirection as e:
# serving.response.location = e.location
# serving.response.status = e.status
# response = serving.response
# self.hooks.run('on_end_resource')
# except exc.HTTPException as e:
# response = serving.response = self.handle_error_page(request, response, e)
# except Exception as e:
# LOGGER.error(e)
# self.error_response(request, response, e)
# return response(environ, start_response)
# finally:
# try:
# self.hooks.run('on_end_request')
# finally:
# serving.clear()
#
#
# def handle_error_page(self, request, response, exception):
# """Handle the last unanticipated exception. (Core)"""
# try:
# self.hooks.run("before_error_response")
# response.status = exception.status
# #response.status = exception.status
# handler = self.error_pages.get(str(exception.code), None)
# if handler:
# body = handler()
# if type(body) is str:
# response.body = body
# elif text:
# response.text = body
# return response
# else:
# return exception
# finally:
# self.hooks.run("after_error_response")
#
# def _error_response(self, request, response, exception):
# """Handle the unknow exception and also throw 5xx status and message to frontend"""
# cls, e, tb = exc_info()
#
# LOGGER.exception('Unhandled Error: %s', e)
#
# response.status_code = 500
# response.content_type = 'text/html; charset=UTF-8'
#
# if request.method != 'HEAD':
# response.unicode_body = u"""<html>
# <head><title>Internal Server Error </title></head>
# <body><p>An error occurred: <b>%s</b></p></body>
# </html>
# """ % (str(e))
#
# Path: solo/web/server.py
# class WebServer(object):
#
# """Adapter for a gevent.wsgi.WSGIServer."""
#
# def __init__(self, *args, **kwargs):
# self.args = args
# self.kwargs = kwargs
# self.ready = False
#
# def start(self):
# """Start the GeventWSGIServer."""
# # We have to instantiate the server class here because its __init__
# from gevent.wsgi import WSGIServer
#
# self.ready = True
# LOGGER.debug('Starting Gevent WSGI Server...')
# self.httpd = WSGIServer(*self.args, **self.kwargs)
# self.httpd.serve_forever()
#
# def stop(self):
# """Stop the HTTP server."""
# LOGGER.debug('Stoping Gevent WSGI Server...')
# self.ready = False
# self.httpd.stop()
. Output only the next line. | self.asset('static' ,'/', root, default_filename='index.html') |
Using the snippet: <|code_start|>#!/usr/bin/env python
class HelloRoot(object):
def index(self):
return "Hello World!"
class HelloApp(App):
def initialize(self):
ctl = HelloRoot()
route = self.route()
route.mapper.explicit = False
<|code_end|>
, determine the next line of code. You have imports:
from solo.web.app import App
from gevent.wsgi import WSGIServer
and context (class names, function names, or code) available:
# Path: solo/web/app.py
# class App(object):
#
#
# hookpoints = ['on_start_resource', 'before_handler',
# 'on_end_resource', 'on_end_request',
# 'before_error_response', 'after_error_response']
#
#
# def __init__(self, name='Lilac', encoding='utf8', debug=False, dispatcher=None):
# self.dispatcher = dispatcher or RoutesDispatcher()
# self.name = name
# self.error_pages = {}
# self.encoding = encoding
# self.debug = debug
# self.hooks = HookMap()
# self.error_response = self._error_response
# self.initialize()
#
# def initialize(self):
# pass
#
# def route(self):
# return self.dispatcher
#
# def attach(self, point, callback, failsafe=None, priority=None, **kwargs):
# if point not in self.hookpoints:
# return
# self.hooks.attach(point, callback, failsafe, priority, **kwargs)
#
# def asset(self, name, path, asset_path, default_filename=None, block_size=None):
# """Set servering Static directory"""
# from solo.web.asset import AssetController
# path = '' if path == '/' else path
# ctl = AssetController(asset_path, default_filename, block_size)
# self.dispatcher.connect(name, path + "/{path:.*?}", controller=ctl, action='asset', conditions=dict(method=["HEAD", "GET"]))
#
#
# def error_page(self, code, callback):
# if type(code) is not int:
# raise TypeError("code:%d is not int type" %(code))
# self.error_pages[str(code)] = callback
#
# def __call__(self, environ, start_response):
# try:
# try:
# request = Request(environ)
# response = Response()
# serving.load(request, response)
# if request.charset is None:
# request.charset = self.encoding
#
# self.hooks.run('on_start_resource')
#
# path_info = environ['PATH_INFO']
# action, handler = self.dispatcher.match(request, path_info)
# body = None
# self.hooks.run('before_handler')
#
# if handler:
# body = handler()
# if type(body) is str:
# response.body = body
# elif body:
# response.text = body
# self.hooks.run('on_end_resource')
# return response(environ, start_response)
# else:
# raise exc.HTTPNotFound('Path %s Not Found' % (path_info))
#
# except exc.HTTPRedirection as e:
# serving.response.location = e.location
# serving.response.status = e.status
# response = serving.response
# self.hooks.run('on_end_resource')
# except exc.HTTPException as e:
# response = serving.response = self.handle_error_page(request, response, e)
# except Exception as e:
# LOGGER.error(e)
# self.error_response(request, response, e)
# return response(environ, start_response)
# finally:
# try:
# self.hooks.run('on_end_request')
# finally:
# serving.clear()
#
#
# def handle_error_page(self, request, response, exception):
# """Handle the last unanticipated exception. (Core)"""
# try:
# self.hooks.run("before_error_response")
# response.status = exception.status
# #response.status = exception.status
# handler = self.error_pages.get(str(exception.code), None)
# if handler:
# body = handler()
# if type(body) is str:
# response.body = body
# elif text:
# response.text = body
# return response
# else:
# return exception
# finally:
# self.hooks.run("after_error_response")
#
# def _error_response(self, request, response, exception):
# """Handle the unknow exception and also throw 5xx status and message to frontend"""
# cls, e, tb = exc_info()
#
# LOGGER.exception('Unhandled Error: %s', e)
#
# response.status_code = 500
# response.content_type = 'text/html; charset=UTF-8'
#
# if request.method != 'HEAD':
# response.unicode_body = u"""<html>
# <head><title>Internal Server Error </title></head>
# <body><p>An error occurred: <b>%s</b></p></body>
# </html>
# """ % (str(e))
. Output only the next line. | route.connect('index', '/', controller=ctl, action='index') |
Continue the code snippet: <|code_start|>#!/usr/bin/env python
# Copyright (C) 2015 Thomas Huang
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
LOGGER = logging.getLogger('solo.web')
class App(object):
hookpoints = ['on_start_resource', 'before_handler',
'on_end_resource', 'on_end_request',
<|code_end|>
. Use current file imports:
from webob import exc
from webob import Request, Response
from sys import exc_info
from solo.web.ctx import serving
from solo.web.hook import HookMap
from solo.web.dispatcher import RoutesDispatcher
from solo.web.asset import AssetController
import logging
and context (classes, functions, or code) from other files:
# Path: solo/web/ctx.py
# LOGGER = logging.getLogger('solo.web')
# class GreenletServing(object):
# class _ThreadLocalProxy(object):
# def __init__(self):
# def load(self, request, response):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def clear(self):
# def __init__(self, attrname):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def __delattr__(self, name):
# def _get_dict(self):
# def __getitem__(self, key):
# def __setitem__(self, key, value):
# def __delitem__(self, key):
# def __contains__(self, key):
# def __len__(self):
# def __nonzero__(self):
#
# Path: solo/web/hook.py
# class HookMap(dict):
#
# """A map of call points to lists of callbacks (Hook objects)."""
#
# def __new__(cls, points=None):
# d = dict.__new__(cls)
# for p in points or []:
# d[p] = []
# return d
#
# def __init__(self, *a, **kw):
# pass
#
# def attach(self, point, callback, failsafe=None, priority=None, **kwargs):
# """Append a new Hook made from the supplied arguments."""
# if point not in self:
# self[point] = []
# self[point].append(Hook(callback, failsafe, priority, **kwargs))
# self[point].sort()
#
# def run(self, point):
# """Execute all registered Hooks (callbacks) for the given point."""
# exc = None
# hooks = self.get(point, [])
# for hook in hooks:
# # Some hooks are guaranteed to run even if others at
# # the same hookpoint fail. We will still log the failure,
# # but proceed on to the next hook. The only way
# # to stop all processing from one of these hooks is
# # to raise SystemExit and stop the whole server.
# if exc is None or hook.failsafe:
# try:
# hook()
# except (KeyboardInterrupt, SystemExit):
# raise
# except (exc.HTTPRedirection, exc.HTTPException):
# exc = exc_info()[1]
# except:
# exc = exc_info()[1]
# LOGGER.exception("Hook Error: %s", exc)
# if exc:
# raise exc
#
# def __copy__(self):
# newmap = self.__class__()
# # We can't just use 'update' because we want copies of the
# # mutable values (each is a list) as well.
# for k, v in self.items():
# newmap[k] = v[:]
# return newmap
# copy = __copy__
#
# def __repr__(self):
# cls = self.__class__
# return "%s.%s(points=%r)" % (
# cls.__module__,
# cls.__name__,
# self.keys()
# )
#
# Path: solo/web/dispatcher.py
# class RoutesDispatcher(object):
#
# """A Routes based dispatcher for CherryPy."""
#
# def __init__(self, **mapper_options):
# """Routes dispatcher"""
# self.controllers = {}
# self.mapper = routes.Mapper(**mapper_options)
# self.mapper.controller_scan = self.controllers.keys
#
#
# def connect(self, name, route, controller, **kwargs):
# self.controllers[name] = controller
# self.mapper.connect(name, route, controller=name, **kwargs)
#
#
# def match(self, request, path_info):
# """Find the right page handler."""
#
# result = self.mapper.match(path_info, {'REQUEST_METHOD' : request.method})
#
# if not result:
# # action, handler
# return None, None
#
# request.route = result
# params = result.copy()
# params.pop('controller', None)
# params.pop('action', None)
#
# handler = None
# controller = result.get('controller')
# controller = self.controllers.get(controller, controller)
# if controller:
# if isinstance(controller, classtype):
# controller = controller()
#
# action = result.get('action')
# if action is not None:
# handler = getattr(controller, action, None)
# else:
# handler = controller
#
# if request.method == 'GET':
# reqparams = request.GET.mixed()
# elif request.method != 'HEAD':
# reqparams = request.POST.mixed()
# else:
# reqparams = {}
#
# reqparams.update(params)
# handler = PageHandler(handler, **reqparams)
#
# return action, handler
. Output only the next line. | 'before_error_response', 'after_error_response'] |
Next line prediction: <|code_start|>#!/usr/bin/env python
# Copyright (C) 2015 Thomas Huang
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
LOGGER = logging.getLogger('solo.web')
class App(object):
hookpoints = ['on_start_resource', 'before_handler',
<|code_end|>
. Use current file imports:
(from webob import exc
from webob import Request, Response
from sys import exc_info
from solo.web.ctx import serving
from solo.web.hook import HookMap
from solo.web.dispatcher import RoutesDispatcher
from solo.web.asset import AssetController
import logging)
and context including class names, function names, or small code snippets from other files:
# Path: solo/web/ctx.py
# LOGGER = logging.getLogger('solo.web')
# class GreenletServing(object):
# class _ThreadLocalProxy(object):
# def __init__(self):
# def load(self, request, response):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def clear(self):
# def __init__(self, attrname):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def __delattr__(self, name):
# def _get_dict(self):
# def __getitem__(self, key):
# def __setitem__(self, key, value):
# def __delitem__(self, key):
# def __contains__(self, key):
# def __len__(self):
# def __nonzero__(self):
#
# Path: solo/web/hook.py
# class HookMap(dict):
#
# """A map of call points to lists of callbacks (Hook objects)."""
#
# def __new__(cls, points=None):
# d = dict.__new__(cls)
# for p in points or []:
# d[p] = []
# return d
#
# def __init__(self, *a, **kw):
# pass
#
# def attach(self, point, callback, failsafe=None, priority=None, **kwargs):
# """Append a new Hook made from the supplied arguments."""
# if point not in self:
# self[point] = []
# self[point].append(Hook(callback, failsafe, priority, **kwargs))
# self[point].sort()
#
# def run(self, point):
# """Execute all registered Hooks (callbacks) for the given point."""
# exc = None
# hooks = self.get(point, [])
# for hook in hooks:
# # Some hooks are guaranteed to run even if others at
# # the same hookpoint fail. We will still log the failure,
# # but proceed on to the next hook. The only way
# # to stop all processing from one of these hooks is
# # to raise SystemExit and stop the whole server.
# if exc is None or hook.failsafe:
# try:
# hook()
# except (KeyboardInterrupt, SystemExit):
# raise
# except (exc.HTTPRedirection, exc.HTTPException):
# exc = exc_info()[1]
# except:
# exc = exc_info()[1]
# LOGGER.exception("Hook Error: %s", exc)
# if exc:
# raise exc
#
# def __copy__(self):
# newmap = self.__class__()
# # We can't just use 'update' because we want copies of the
# # mutable values (each is a list) as well.
# for k, v in self.items():
# newmap[k] = v[:]
# return newmap
# copy = __copy__
#
# def __repr__(self):
# cls = self.__class__
# return "%s.%s(points=%r)" % (
# cls.__module__,
# cls.__name__,
# self.keys()
# )
#
# Path: solo/web/dispatcher.py
# class RoutesDispatcher(object):
#
# """A Routes based dispatcher for CherryPy."""
#
# def __init__(self, **mapper_options):
# """Routes dispatcher"""
# self.controllers = {}
# self.mapper = routes.Mapper(**mapper_options)
# self.mapper.controller_scan = self.controllers.keys
#
#
# def connect(self, name, route, controller, **kwargs):
# self.controllers[name] = controller
# self.mapper.connect(name, route, controller=name, **kwargs)
#
#
# def match(self, request, path_info):
# """Find the right page handler."""
#
# result = self.mapper.match(path_info, {'REQUEST_METHOD' : request.method})
#
# if not result:
# # action, handler
# return None, None
#
# request.route = result
# params = result.copy()
# params.pop('controller', None)
# params.pop('action', None)
#
# handler = None
# controller = result.get('controller')
# controller = self.controllers.get(controller, controller)
# if controller:
# if isinstance(controller, classtype):
# controller = controller()
#
# action = result.get('action')
# if action is not None:
# handler = getattr(controller, action, None)
# else:
# handler = controller
#
# if request.method == 'GET':
# reqparams = request.GET.mixed()
# elif request.method != 'HEAD':
# reqparams = request.POST.mixed()
# else:
# reqparams = {}
#
# reqparams.update(params)
# handler = PageHandler(handler, **reqparams)
#
# return action, handler
. Output only the next line. | 'on_end_resource', 'on_end_request', |
Given the code snippet: <|code_start|># This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
LOGGER = logging.getLogger('solo.web')
class App(object):
hookpoints = ['on_start_resource', 'before_handler',
'on_end_resource', 'on_end_request',
'before_error_response', 'after_error_response']
<|code_end|>
, generate the next line using the imports in this file:
from webob import exc
from webob import Request, Response
from sys import exc_info
from solo.web.ctx import serving
from solo.web.hook import HookMap
from solo.web.dispatcher import RoutesDispatcher
from solo.web.asset import AssetController
import logging
and context (functions, classes, or occasionally code) from other files:
# Path: solo/web/ctx.py
# LOGGER = logging.getLogger('solo.web')
# class GreenletServing(object):
# class _ThreadLocalProxy(object):
# def __init__(self):
# def load(self, request, response):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def clear(self):
# def __init__(self, attrname):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def __delattr__(self, name):
# def _get_dict(self):
# def __getitem__(self, key):
# def __setitem__(self, key, value):
# def __delitem__(self, key):
# def __contains__(self, key):
# def __len__(self):
# def __nonzero__(self):
#
# Path: solo/web/hook.py
# class HookMap(dict):
#
# """A map of call points to lists of callbacks (Hook objects)."""
#
# def __new__(cls, points=None):
# d = dict.__new__(cls)
# for p in points or []:
# d[p] = []
# return d
#
# def __init__(self, *a, **kw):
# pass
#
# def attach(self, point, callback, failsafe=None, priority=None, **kwargs):
# """Append a new Hook made from the supplied arguments."""
# if point not in self:
# self[point] = []
# self[point].append(Hook(callback, failsafe, priority, **kwargs))
# self[point].sort()
#
# def run(self, point):
# """Execute all registered Hooks (callbacks) for the given point."""
# exc = None
# hooks = self.get(point, [])
# for hook in hooks:
# # Some hooks are guaranteed to run even if others at
# # the same hookpoint fail. We will still log the failure,
# # but proceed on to the next hook. The only way
# # to stop all processing from one of these hooks is
# # to raise SystemExit and stop the whole server.
# if exc is None or hook.failsafe:
# try:
# hook()
# except (KeyboardInterrupt, SystemExit):
# raise
# except (exc.HTTPRedirection, exc.HTTPException):
# exc = exc_info()[1]
# except:
# exc = exc_info()[1]
# LOGGER.exception("Hook Error: %s", exc)
# if exc:
# raise exc
#
# def __copy__(self):
# newmap = self.__class__()
# # We can't just use 'update' because we want copies of the
# # mutable values (each is a list) as well.
# for k, v in self.items():
# newmap[k] = v[:]
# return newmap
# copy = __copy__
#
# def __repr__(self):
# cls = self.__class__
# return "%s.%s(points=%r)" % (
# cls.__module__,
# cls.__name__,
# self.keys()
# )
#
# Path: solo/web/dispatcher.py
# class RoutesDispatcher(object):
#
# """A Routes based dispatcher for CherryPy."""
#
# def __init__(self, **mapper_options):
# """Routes dispatcher"""
# self.controllers = {}
# self.mapper = routes.Mapper(**mapper_options)
# self.mapper.controller_scan = self.controllers.keys
#
#
# def connect(self, name, route, controller, **kwargs):
# self.controllers[name] = controller
# self.mapper.connect(name, route, controller=name, **kwargs)
#
#
# def match(self, request, path_info):
# """Find the right page handler."""
#
# result = self.mapper.match(path_info, {'REQUEST_METHOD' : request.method})
#
# if not result:
# # action, handler
# return None, None
#
# request.route = result
# params = result.copy()
# params.pop('controller', None)
# params.pop('action', None)
#
# handler = None
# controller = result.get('controller')
# controller = self.controllers.get(controller, controller)
# if controller:
# if isinstance(controller, classtype):
# controller = controller()
#
# action = result.get('action')
# if action is not None:
# handler = getattr(controller, action, None)
# else:
# handler = controller
#
# if request.method == 'GET':
# reqparams = request.GET.mixed()
# elif request.method != 'HEAD':
# reqparams = request.POST.mixed()
# else:
# reqparams = {}
#
# reqparams.update(params)
# handler = PageHandler(handler, **reqparams)
#
# return action, handler
. Output only the next line. | def __init__(self, name='Lilac', encoding='utf8', debug=False, dispatcher=None): |
Given snippet: <|code_start|>#!/usr/bin/env python
# Copyright (C) 2015 Thomas Huang
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
try:
except ImportError:
test_callable_spec = lambda callable, args, kwargs: None
try:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from webob import exc
from solo.web.ctx import serving
from sys import exc_info
import routes
import inspect
import types
import logging
and context:
# Path: solo/web/ctx.py
# LOGGER = logging.getLogger('solo.web')
# class GreenletServing(object):
# class _ThreadLocalProxy(object):
# def __init__(self):
# def load(self, request, response):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def clear(self):
# def __init__(self, attrname):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def __delattr__(self, name):
# def _get_dict(self):
# def __getitem__(self, key):
# def __setitem__(self, key, value):
# def __delitem__(self, key):
# def __contains__(self, key):
# def __len__(self):
# def __nonzero__(self):
which might include code, classes, or functions. Output only the next line. | classtype = (type, types.ClassType) |
Here is a snippet: <|code_start|>#!/usr/bin/env python
# Copyright (C) 2015 Thomas Huang
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 2 of the License.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
def jsonify(f):
"""The decorator will set response content type to application/json; charset=UTF-8,
and als handle the object which has as_json method"""
@wraps(f)
def __(*args, **kwargs):
response.content_type = 'application/json; charset=UTF-8'
return json_encode(f(*args, **kwargs))
<|code_end|>
. Write the next line using the current file imports:
from functools import wraps
from solo.web.ctx import response
from solo.util import json_encode
and context from other files:
# Path: solo/web/ctx.py
# LOGGER = logging.getLogger('solo.web')
# class GreenletServing(object):
# class _ThreadLocalProxy(object):
# def __init__(self):
# def load(self, request, response):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def clear(self):
# def __init__(self, attrname):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def __delattr__(self, name):
# def _get_dict(self):
# def __getitem__(self, key):
# def __setitem__(self, key, value):
# def __delitem__(self, key):
# def __contains__(self, key):
# def __len__(self):
# def __nonzero__(self):
#
# Path: solo/util.py
# def json_encode(value, ensure_ascii=True, default=as_json):
# """Returns the json serialize stream"""
# return json.dumps(value, default=default, ensure_ascii=ensure_ascii)
, which may include functions, classes, or code. Output only the next line. | return __ |
Given snippet: <|code_start|>class FileIter(object):
""" A fixed-block-size iterator for use as a WSGI app_iter.
``file`` is a Python file pointer (or at least an object with a ``read``
method that takes a size hint).
``block_size`` is an optional block size for iteration."""
def __init__(self, filename, start=None, stop=None, block_size=_BLOCK_SIZE):
self.filename = filename
self.start = start
self.stop = stop
self.block_size = block_size
self.fileiterator = FileIterator(self.filename, self.start, self.stop, self.block_size)
def __iter__(self):
return self
def next(self):
return self.fileiterator.next()
__next__ = next # py3
def app_iter_range(self, start, stop):
return self.__class__(self.filename, start, stop, self.block_size)
def close(self):
self.fileiterator.close()
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import logging
import mimetypes
import os
import os.path
from os.path import (
getmtime,
getsize
)
from webob import exc
from solo.web.ctx import request, response
and context:
# Path: solo/web/ctx.py
# LOGGER = logging.getLogger('solo.web')
# class GreenletServing(object):
# class _ThreadLocalProxy(object):
# def __init__(self):
# def load(self, request, response):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def clear(self):
# def __init__(self, attrname):
# def __getattr__(self, name):
# def __setattr__(self, name, value):
# def __delattr__(self, name):
# def _get_dict(self):
# def __getitem__(self, key):
# def __setitem__(self, key, value):
# def __delitem__(self, key):
# def __contains__(self, key):
# def __len__(self):
# def __nonzero__(self):
which might include code, classes, or functions. Output only the next line. | class FileIterator(object): |
Based on the snippet: <|code_start|>#!/usr/bin/env python
# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
def main(args):
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter
)
parser.add_argument('branch_name')
g = parser.add_mutually_exclusive_group()
g.add_argument('--upstream_current', action='store_true',
help='set upstream branch to current branch.')
g.add_argument('--upstream', metavar='REF', default=root(),
<|code_end|>
, predict the immediate next line with the help of imports:
import argparse
import sys
import subprocess2
from git_common import run, root, set_config, get_or_create_merge_base, tags
from git_common import hash_one
and context (classes, functions, sometimes code) from other files:
# Path: git_common.py
# def run(*cmd, **kwargs):
# """The same as run_with_stderr, except it only returns stdout."""
# return run_with_stderr(*cmd, **kwargs)[0]
#
# def root():
# return config('depot-tools.upstream', 'origin/master')
#
# def set_config(option, value, scope='local'):
# run('config', '--' + scope, option, value)
#
# def get_or_create_merge_base(branch, parent=None):
# """Finds the configured merge base for branch.
#
# If parent is supplied, it's used instead of calling upstream(branch).
# """
# base = branch_config(branch, 'base')
# base_upstream = branch_config(branch, 'base-upstream')
# parent = parent or upstream(branch)
# if not parent:
# return None
# actual_merge_base = run('merge-base', parent, branch)
#
# if base_upstream != parent:
# base = None
# base_upstream = None
#
# def is_ancestor(a, b):
# return run_with_retcode('merge-base', '--is-ancestor', a, b) == 0
#
# if base:
# if not is_ancestor(base, branch):
# logging.debug('Found WRONG pre-set merge-base for %s: %s', branch, base)
# base = None
# elif is_ancestor(base, actual_merge_base):
# logging.debug('Found OLD pre-set merge-base for %s: %s', branch, base)
# base = None
# else:
# logging.debug('Found pre-set merge-base for %s: %s', branch, base)
#
# if not base:
# base = actual_merge_base
# manual_merge_base(branch, base, parent)
#
# return base
#
# def tags(*args):
# return run('tag', *args).splitlines()
#
# Path: git_common.py
# def hash_one(reflike):
# return run('rev-parse', reflike)
. Output only the next line. | help='upstream branch (or tag) to track.') |
Continue the code snippet: <|code_start|>#!/usr/bin/env python
# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
def main(args):
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter
)
parser.add_argument('branch_name')
g = parser.add_mutually_exclusive_group()
g.add_argument('--upstream_current', action='store_true',
help='set upstream branch to current branch.')
g.add_argument('--upstream', metavar='REF', default=root(),
help='upstream branch (or tag) to track.')
g.add_argument('--lkgr', action='store_const', const='lkgr', dest='upstream',
help='set basis ref for new branch to lkgr.')
opts = parser.parse_args(args)
try:
<|code_end|>
. Use current file imports:
import argparse
import sys
import subprocess2
from git_common import run, root, set_config, get_or_create_merge_base, tags
from git_common import hash_one
and context (classes, functions, or code) from other files:
# Path: git_common.py
# def run(*cmd, **kwargs):
# """The same as run_with_stderr, except it only returns stdout."""
# return run_with_stderr(*cmd, **kwargs)[0]
#
# def root():
# return config('depot-tools.upstream', 'origin/master')
#
# def set_config(option, value, scope='local'):
# run('config', '--' + scope, option, value)
#
# def get_or_create_merge_base(branch, parent=None):
# """Finds the configured merge base for branch.
#
# If parent is supplied, it's used instead of calling upstream(branch).
# """
# base = branch_config(branch, 'base')
# base_upstream = branch_config(branch, 'base-upstream')
# parent = parent or upstream(branch)
# if not parent:
# return None
# actual_merge_base = run('merge-base', parent, branch)
#
# if base_upstream != parent:
# base = None
# base_upstream = None
#
# def is_ancestor(a, b):
# return run_with_retcode('merge-base', '--is-ancestor', a, b) == 0
#
# if base:
# if not is_ancestor(base, branch):
# logging.debug('Found WRONG pre-set merge-base for %s: %s', branch, base)
# base = None
# elif is_ancestor(base, actual_merge_base):
# logging.debug('Found OLD pre-set merge-base for %s: %s', branch, base)
# base = None
# else:
# logging.debug('Found pre-set merge-base for %s: %s', branch, base)
#
# if not base:
# base = actual_merge_base
# manual_merge_base(branch, base, parent)
#
# return base
#
# def tags(*args):
# return run('tag', *args).splitlines()
#
# Path: git_common.py
# def hash_one(reflike):
# return run('rev-parse', reflike)
. Output only the next line. | if opts.upstream_current: |
Given the code snippet: <|code_start|> parser.add_argument('branch_name')
g = parser.add_mutually_exclusive_group()
g.add_argument('--upstream_current', action='store_true',
help='set upstream branch to current branch.')
g.add_argument('--upstream', metavar='REF', default=root(),
help='upstream branch (or tag) to track.')
g.add_argument('--lkgr', action='store_const', const='lkgr', dest='upstream',
help='set basis ref for new branch to lkgr.')
opts = parser.parse_args(args)
try:
if opts.upstream_current:
run('checkout', '--track', '-b', opts.branch_name)
else:
if opts.upstream in tags():
# TODO(iannucci): ensure that basis_ref is an ancestor of HEAD?
run('checkout', '--no-track', '-b', opts.branch_name,
hash_one(opts.upstream))
set_config('branch.%s.remote' % opts.branch_name, '.')
set_config('branch.%s.merge' % opts.branch_name, opts.upstream)
else:
# TODO(iannucci): Detect unclean workdir then stash+pop if we need to
# teleport to a conflicting portion of history?
run('checkout', '--track', opts.upstream, '-b', opts.branch_name)
get_or_create_merge_base(opts.branch_name)
except subprocess2.CalledProcessError as cpe:
sys.stdout.write(cpe.stdout)
sys.stderr.write(cpe.stderr)
return 1
<|code_end|>
, generate the next line using the imports in this file:
import argparse
import sys
import subprocess2
from git_common import run, root, set_config, get_or_create_merge_base, tags
from git_common import hash_one
and context (functions, classes, or occasionally code) from other files:
# Path: git_common.py
# def run(*cmd, **kwargs):
# """The same as run_with_stderr, except it only returns stdout."""
# return run_with_stderr(*cmd, **kwargs)[0]
#
# def root():
# return config('depot-tools.upstream', 'origin/master')
#
# def set_config(option, value, scope='local'):
# run('config', '--' + scope, option, value)
#
# def get_or_create_merge_base(branch, parent=None):
# """Finds the configured merge base for branch.
#
# If parent is supplied, it's used instead of calling upstream(branch).
# """
# base = branch_config(branch, 'base')
# base_upstream = branch_config(branch, 'base-upstream')
# parent = parent or upstream(branch)
# if not parent:
# return None
# actual_merge_base = run('merge-base', parent, branch)
#
# if base_upstream != parent:
# base = None
# base_upstream = None
#
# def is_ancestor(a, b):
# return run_with_retcode('merge-base', '--is-ancestor', a, b) == 0
#
# if base:
# if not is_ancestor(base, branch):
# logging.debug('Found WRONG pre-set merge-base for %s: %s', branch, base)
# base = None
# elif is_ancestor(base, actual_merge_base):
# logging.debug('Found OLD pre-set merge-base for %s: %s', branch, base)
# base = None
# else:
# logging.debug('Found pre-set merge-base for %s: %s', branch, base)
#
# if not base:
# base = actual_merge_base
# manual_merge_base(branch, base, parent)
#
# return base
#
# def tags(*args):
# return run('tag', *args).splitlines()
#
# Path: git_common.py
# def hash_one(reflike):
# return run('rev-parse', reflike)
. Output only the next line. | sys.stderr.write('Switched to branch %s.\n' % opts.branch_name) |
Here is a snippet: <|code_start|> )
parser.add_argument('branch_name')
g = parser.add_mutually_exclusive_group()
g.add_argument('--upstream_current', action='store_true',
help='set upstream branch to current branch.')
g.add_argument('--upstream', metavar='REF', default=root(),
help='upstream branch (or tag) to track.')
g.add_argument('--lkgr', action='store_const', const='lkgr', dest='upstream',
help='set basis ref for new branch to lkgr.')
opts = parser.parse_args(args)
try:
if opts.upstream_current:
run('checkout', '--track', '-b', opts.branch_name)
else:
if opts.upstream in tags():
# TODO(iannucci): ensure that basis_ref is an ancestor of HEAD?
run('checkout', '--no-track', '-b', opts.branch_name,
hash_one(opts.upstream))
set_config('branch.%s.remote' % opts.branch_name, '.')
set_config('branch.%s.merge' % opts.branch_name, opts.upstream)
else:
# TODO(iannucci): Detect unclean workdir then stash+pop if we need to
# teleport to a conflicting portion of history?
run('checkout', '--track', opts.upstream, '-b', opts.branch_name)
get_or_create_merge_base(opts.branch_name)
except subprocess2.CalledProcessError as cpe:
sys.stdout.write(cpe.stdout)
sys.stderr.write(cpe.stderr)
<|code_end|>
. Write the next line using the current file imports:
import argparse
import sys
import subprocess2
from git_common import run, root, set_config, get_or_create_merge_base, tags
from git_common import hash_one
and context from other files:
# Path: git_common.py
# def run(*cmd, **kwargs):
# """The same as run_with_stderr, except it only returns stdout."""
# return run_with_stderr(*cmd, **kwargs)[0]
#
# def root():
# return config('depot-tools.upstream', 'origin/master')
#
# def set_config(option, value, scope='local'):
# run('config', '--' + scope, option, value)
#
# def get_or_create_merge_base(branch, parent=None):
# """Finds the configured merge base for branch.
#
# If parent is supplied, it's used instead of calling upstream(branch).
# """
# base = branch_config(branch, 'base')
# base_upstream = branch_config(branch, 'base-upstream')
# parent = parent or upstream(branch)
# if not parent:
# return None
# actual_merge_base = run('merge-base', parent, branch)
#
# if base_upstream != parent:
# base = None
# base_upstream = None
#
# def is_ancestor(a, b):
# return run_with_retcode('merge-base', '--is-ancestor', a, b) == 0
#
# if base:
# if not is_ancestor(base, branch):
# logging.debug('Found WRONG pre-set merge-base for %s: %s', branch, base)
# base = None
# elif is_ancestor(base, actual_merge_base):
# logging.debug('Found OLD pre-set merge-base for %s: %s', branch, base)
# base = None
# else:
# logging.debug('Found pre-set merge-base for %s: %s', branch, base)
#
# if not base:
# base = actual_merge_base
# manual_merge_base(branch, base, parent)
#
# return base
#
# def tags(*args):
# return run('tag', *args).splitlines()
#
# Path: git_common.py
# def hash_one(reflike):
# return run('rev-parse', reflike)
, which may include functions, classes, or code. Output only the next line. | return 1 |
Given the code snippet: <|code_start|>#!/usr/bin/env python
# Copyright 2014 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
def main(args):
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter
)
<|code_end|>
, generate the next line using the imports in this file:
import argparse
import sys
import subprocess2
from git_common import run, root, set_config, get_or_create_merge_base, tags
from git_common import hash_one
and context (functions, classes, or occasionally code) from other files:
# Path: git_common.py
# def run(*cmd, **kwargs):
# """The same as run_with_stderr, except it only returns stdout."""
# return run_with_stderr(*cmd, **kwargs)[0]
#
# def root():
# return config('depot-tools.upstream', 'origin/master')
#
# def set_config(option, value, scope='local'):
# run('config', '--' + scope, option, value)
#
# def get_or_create_merge_base(branch, parent=None):
# """Finds the configured merge base for branch.
#
# If parent is supplied, it's used instead of calling upstream(branch).
# """
# base = branch_config(branch, 'base')
# base_upstream = branch_config(branch, 'base-upstream')
# parent = parent or upstream(branch)
# if not parent:
# return None
# actual_merge_base = run('merge-base', parent, branch)
#
# if base_upstream != parent:
# base = None
# base_upstream = None
#
# def is_ancestor(a, b):
# return run_with_retcode('merge-base', '--is-ancestor', a, b) == 0
#
# if base:
# if not is_ancestor(base, branch):
# logging.debug('Found WRONG pre-set merge-base for %s: %s', branch, base)
# base = None
# elif is_ancestor(base, actual_merge_base):
# logging.debug('Found OLD pre-set merge-base for %s: %s', branch, base)
# base = None
# else:
# logging.debug('Found pre-set merge-base for %s: %s', branch, base)
#
# if not base:
# base = actual_merge_base
# manual_merge_base(branch, base, parent)
#
# return base
#
# def tags(*args):
# return run('tag', *args).splitlines()
#
# Path: git_common.py
# def hash_one(reflike):
# return run('rev-parse', reflike)
. Output only the next line. | parser.add_argument('branch_name') |
Using the snippet: <|code_start|>LA 22 LOUISIANA
MA 25 MASSACHUSETTS
MD 24 MARYLAND
ME 23 MAINE
MI 26 MICHIGAN
MN 27 MINNESOTA
MO 29 MISSOURI
MS 28 MISSISSIPPI
MT 30 MONTANA
NC 37 NORTH CAROLINA
ND 38 NORTH DAKOTA
NE 31 NEBRASKA
NH 33 NEW HAMPSHIRE
NJ 34 NEW JERSEY
NM 35 NEW MEXICO
NV 32 NEVADA
NY 36 NEW YORK
OH 39 OHIO
OK 40 OKLAHOMA
OR 41 OREGON
PA 42 PENNSYLVANIA
RI 44 RHODE ISLAND
SC 45 SOUTH CAROLINA
SD 46 SOUTH DAKOTA
TN 47 TENNESSEE
TX 48 TEXAS
UT 49 UTAH
VA 51 VIRGINIA
VT 50 VERMONT
WA 53 WASHINGTON
<|code_end|>
, determine the next line of code. You have imports:
from mrjob.job import MRJob
from mrjob.protocol import JSONValueProtocol, PickleProtocol, RawValueProtocol
from hose_util import lookup
import re,os,sys
import json
and context (class names, function names, or code) available:
# Path: hose_util.py
# def lookup(myjson, k):
# # return myjson[k]
# if '.' in k:
# # jpath path
# ks = k.split('.')
# v = myjson
# for k in ks: v = v.get(k,{})
# return v or ""
# return myjson.get(k,"")
. Output only the next line. | WI 55 WISCONSIN |
Next line prediction: <|code_start|># Copyright 2020 Google LLC.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
class MaxDecorator(Predictor):
def __init__(self, config=None, decorated_predictors=None):
self.decorated_predictors = decorated_predictors
def UpdateMeasures(self, snapshot):
<|code_end|>
. Use current file imports:
(from simulator.predictor import Predictor
import numpy as np)
and context including class names, function names, or small code snippets from other files:
# Path: simulator/predictor.py
# class Predictor:
# def __init__(self, config, decorated_predictors=None):
# pass
#
# def UpdateMeasures(self, snapshot):
# raise NotImplementedError
#
# def _Predict(self, vmstates):
# raise NotImplementedError
. Output only the next line. | predictions = [] |
Given snippet: <|code_start|># You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
class _State:
def __init__(self):
self.limit = 0
class LimitPredictor(StatefulPredictor):
def __init__(self, config):
super().__init__(config)
def CreateState(self, vm_info):
return _State()
def UpdateState(self, vm_measure, vm_state):
vm_state.limit = vm_measure["sample"]["abstract_metrics"]["limit"]
def Predict(self, vm_states_and_num_samples):
vms_limits = []
for vm_state_and_num_sample in vm_states_and_num_samples:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from simulator.predictor import StatefulPredictor
and context:
# Path: simulator/predictor.py
# class StatefulPredictor(Predictor):
# def __init__(self, config):
# super().__init__(config)
# self.warm_vms = {}
# self.cold_vms = {}
# self.vm_limits = {}
# self.min_num_samples = config.min_num_samples
#
# def _CreateState(self, vminfo):
# raise NotImplementedError
#
# def _UpdateState(self, vmmeasure, vmstate):
# raise NotImplementedError
#
# def _Predict(self, vmstates):
# raise NotImplementedError
#
# def UpdateMeasures(self, snapshot):
# vm_measures = [item for item in vars(snapshot)["measures"]]
# current_vm_keys = []
#
# for vm_measure in vm_measures:
# vm_unique_id = vm_measure["sample"]["info"]["unique_id"]
# if vm_unique_id in self.warm_vms:
# self.UpdateState(vm_measure, self.warm_vms[vm_unique_id].vm_state)
# self.warm_vms[vm_unique_id].vm_num_samples += 1
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
#
# elif vm_unique_id in self.cold_vms:
# self.UpdateState(vm_measure, self.cold_vms[vm_unique_id].vm_state)
# self.cold_vms[vm_unique_id].vm_num_samples += 1
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
# if self.cold_vms[vm_unique_id].vm_num_samples >= self.min_num_samples:
# self.warm_vms[vm_unique_id] = self.cold_vms.pop(vm_unique_id)
# else:
# vm_state = self.CreateState(vm_measure["sample"]["info"])
# self.cold_vms[vm_unique_id] = _StateAndNumSamples(vm_state, 1)
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
# self.UpdateState(vm_measure, self.cold_vms[vm_unique_id].vm_state)
#
# current_vm_keys.append(vm_unique_id)
#
# self.warm_vms = dict(
# (key, self.warm_vms[key]) for key in current_vm_keys if key in self.warm_vms
# )
#
# self.cold_vms = dict(
# (key, self.cold_vms[key]) for key in current_vm_keys if key in self.cold_vms
# )
#
# self.vm_limits = dict(
# (key, self.vm_limits[key])
# for key in current_vm_keys
# if key in self.vm_limits
# )
#
# predicted_peak = (
# 0
# if not list(self.warm_vms.values())
# else self.Predict(list(self.warm_vms.values()))
# )
# total_limit_for_cold_vms = sum(
# self.vm_limits[vm_unique_id] for vm_unique_id in self.cold_vms
# )
# total_limit_for_warm_vms = sum(
# self.vm_limits[vm_unique_id] for vm_unique_id in self.warm_vms
# )
# total_peak = predicted_peak + total_limit_for_cold_vms
# limit = total_limit_for_cold_vms + total_limit_for_warm_vms
#
# return (total_peak, limit)
which might include code, classes, or functions. Output only the next line. | vms_limits.append(vm_state_and_num_sample.vm_state.limit) |
Continue the code snippet: <|code_start|> if self.cap_to_limit == True:
usage = min(usage, limit)
vm_state.usage.appendleft(usage)
vm_state.limit.appendleft(limit)
def Predict(self, vm_states_and_num_samples):
total_normalized_usage = []
for idx in range(self.num_history_samples):
total_limit = 0
total_usage = 0
num_vms = 0
for vm_state_and_num_sample in vm_states_and_num_samples:
if idx < len(vm_state_and_num_sample.vm_state.usage):
total_usage += vm_state_and_num_sample.vm_state.usage[idx]
total_limit += vm_state_and_num_sample.vm_state.limit[idx]
num_vms += 1
usage_to_limit_ratio = 0
if num_vms == 0:
continue
if total_limit > 0:
usage_to_limit_ratio = total_usage / total_limit
total_normalized_usage.append(usage_to_limit_ratio)
predicted_peak = min(
1.0, np.percentile(np.array(total_normalized_usage), self.percentile)
)
current_total_limit = 0
for vm_state_and_num_sample in vm_states_and_num_samples:
if len(vm_state_and_num_sample.vm_state.limit) > 0:
<|code_end|>
. Use current file imports:
from simulator.predictor import StatefulPredictor
from collections import deque
import numpy as np
import statistics
and context (classes, functions, or code) from other files:
# Path: simulator/predictor.py
# class StatefulPredictor(Predictor):
# def __init__(self, config):
# super().__init__(config)
# self.warm_vms = {}
# self.cold_vms = {}
# self.vm_limits = {}
# self.min_num_samples = config.min_num_samples
#
# def _CreateState(self, vminfo):
# raise NotImplementedError
#
# def _UpdateState(self, vmmeasure, vmstate):
# raise NotImplementedError
#
# def _Predict(self, vmstates):
# raise NotImplementedError
#
# def UpdateMeasures(self, snapshot):
# vm_measures = [item for item in vars(snapshot)["measures"]]
# current_vm_keys = []
#
# for vm_measure in vm_measures:
# vm_unique_id = vm_measure["sample"]["info"]["unique_id"]
# if vm_unique_id in self.warm_vms:
# self.UpdateState(vm_measure, self.warm_vms[vm_unique_id].vm_state)
# self.warm_vms[vm_unique_id].vm_num_samples += 1
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
#
# elif vm_unique_id in self.cold_vms:
# self.UpdateState(vm_measure, self.cold_vms[vm_unique_id].vm_state)
# self.cold_vms[vm_unique_id].vm_num_samples += 1
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
# if self.cold_vms[vm_unique_id].vm_num_samples >= self.min_num_samples:
# self.warm_vms[vm_unique_id] = self.cold_vms.pop(vm_unique_id)
# else:
# vm_state = self.CreateState(vm_measure["sample"]["info"])
# self.cold_vms[vm_unique_id] = _StateAndNumSamples(vm_state, 1)
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
# self.UpdateState(vm_measure, self.cold_vms[vm_unique_id].vm_state)
#
# current_vm_keys.append(vm_unique_id)
#
# self.warm_vms = dict(
# (key, self.warm_vms[key]) for key in current_vm_keys if key in self.warm_vms
# )
#
# self.cold_vms = dict(
# (key, self.cold_vms[key]) for key in current_vm_keys if key in self.cold_vms
# )
#
# self.vm_limits = dict(
# (key, self.vm_limits[key])
# for key in current_vm_keys
# if key in self.vm_limits
# )
#
# predicted_peak = (
# 0
# if not list(self.warm_vms.values())
# else self.Predict(list(self.warm_vms.values()))
# )
# total_limit_for_cold_vms = sum(
# self.vm_limits[vm_unique_id] for vm_unique_id in self.cold_vms
# )
# total_limit_for_warm_vms = sum(
# self.vm_limits[vm_unique_id] for vm_unique_id in self.warm_vms
# )
# total_peak = predicted_peak + total_limit_for_cold_vms
# limit = total_limit_for_cold_vms + total_limit_for_warm_vms
#
# return (total_peak, limit)
. Output only the next line. | current_total_limit += vm_state_and_num_sample.vm_state.limit[0] |
Next line prediction: <|code_start|> ] + _SecondsToMicroseconds(fortune_teller.horizon + TIME_STEP_IN_SEC)
results.append(simulation_result)
return results
def _SortBySimulatedTime(data):
key, streams = data
streams = list(streams)
streams.sort(key=lambda k: k["simulated_time"])
return key, streams
def CallFortuneTellerRunner(data, config):
keyed_data = data | "Assign Simulated Machine ID to Data" >> beam.Map(
_AssignSimulatedMachineIDAsKey
)
grouped_data = (
keyed_data | "Group by Machine ID before Sorting" >> beam.GroupByKey()
)
sorted_data = grouped_data | "Sort by Simulated Time" >> beam.Map(
_SortBySimulatedTime
)
results_schema_without_samples_file = open(
"simulator/results_schema_without_samples.json"
<|code_end|>
. Use current file imports:
(import apache_beam as beam
import numpy as np
import json
from collections import deque
from simulator.fortune_teller_factory import FortuneTellerFactory)
and context including class names, function names, or small code snippets from other files:
# Path: simulator/fortune_teller_factory.py
# def FortuneTellerFactory(config):
# oracle_or_predictor = config.WhichOneof("teller")
# if oracle_or_predictor == "oracle":
# return Oracle(config)
#
# if oracle_or_predictor == "predictor":
# return PredictorFactory().CreatePredictor(config.predictor)
. Output only the next line. | ) |
Given the code snippet: <|code_start|>
class _State:
def __init__(self, num_history_samples):
self.num_history_samples = num_history_samples
self.usage = deque(maxlen=self.num_history_samples)
self.limit = deque(maxlen=self.num_history_samples)
class NSigmaPredictor(StatefulPredictor):
def __init__(self, config):
super().__init__(config)
self.num_history_samples = config.num_history_samples
self.cap_to_limit = config.cap_to_limit
self.n = config.n
def CreateState(self, vm_info):
return _State(self.num_history_samples)
def UpdateState(self, vm_measure, vm_state):
limit = vm_measure["sample"]["abstract_metrics"]["limit"]
usage = vm_measure["sample"]["abstract_metrics"]["usage"]
if self.cap_to_limit == True:
usage = min(usage, limit)
vm_state.usage.appendleft(usage)
vm_state.limit.appendleft(limit)
def Predict(self, vm_states_and_num_samples):
total_normalized_usage = []
<|code_end|>
, generate the next line using the imports in this file:
from simulator.predictor import StatefulPredictor
from collections import deque
import numpy as np
import statistics
and context (functions, classes, or occasionally code) from other files:
# Path: simulator/predictor.py
# class StatefulPredictor(Predictor):
# def __init__(self, config):
# super().__init__(config)
# self.warm_vms = {}
# self.cold_vms = {}
# self.vm_limits = {}
# self.min_num_samples = config.min_num_samples
#
# def _CreateState(self, vminfo):
# raise NotImplementedError
#
# def _UpdateState(self, vmmeasure, vmstate):
# raise NotImplementedError
#
# def _Predict(self, vmstates):
# raise NotImplementedError
#
# def UpdateMeasures(self, snapshot):
# vm_measures = [item for item in vars(snapshot)["measures"]]
# current_vm_keys = []
#
# for vm_measure in vm_measures:
# vm_unique_id = vm_measure["sample"]["info"]["unique_id"]
# if vm_unique_id in self.warm_vms:
# self.UpdateState(vm_measure, self.warm_vms[vm_unique_id].vm_state)
# self.warm_vms[vm_unique_id].vm_num_samples += 1
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
#
# elif vm_unique_id in self.cold_vms:
# self.UpdateState(vm_measure, self.cold_vms[vm_unique_id].vm_state)
# self.cold_vms[vm_unique_id].vm_num_samples += 1
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
# if self.cold_vms[vm_unique_id].vm_num_samples >= self.min_num_samples:
# self.warm_vms[vm_unique_id] = self.cold_vms.pop(vm_unique_id)
# else:
# vm_state = self.CreateState(vm_measure["sample"]["info"])
# self.cold_vms[vm_unique_id] = _StateAndNumSamples(vm_state, 1)
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
# self.UpdateState(vm_measure, self.cold_vms[vm_unique_id].vm_state)
#
# current_vm_keys.append(vm_unique_id)
#
# self.warm_vms = dict(
# (key, self.warm_vms[key]) for key in current_vm_keys if key in self.warm_vms
# )
#
# self.cold_vms = dict(
# (key, self.cold_vms[key]) for key in current_vm_keys if key in self.cold_vms
# )
#
# self.vm_limits = dict(
# (key, self.vm_limits[key])
# for key in current_vm_keys
# if key in self.vm_limits
# )
#
# predicted_peak = (
# 0
# if not list(self.warm_vms.values())
# else self.Predict(list(self.warm_vms.values()))
# )
# total_limit_for_cold_vms = sum(
# self.vm_limits[vm_unique_id] for vm_unique_id in self.cold_vms
# )
# total_limit_for_warm_vms = sum(
# self.vm_limits[vm_unique_id] for vm_unique_id in self.warm_vms
# )
# total_peak = predicted_peak + total_limit_for_cold_vms
# limit = total_limit_for_cold_vms + total_limit_for_warm_vms
#
# return (total_peak, limit)
. Output only the next line. | for idx in range(self.num_history_samples): |
Based on the snippet: <|code_start|> return PredictorFactory().CreatePredictor(config.predictor)
class PredictorFactory(object):
__instance = None
def __new__(cls):
if PredictorFactory.__instance is None:
PredictorFactory.__instance = object.__new__(cls)
PredictorFactory.__instance.decorator_factories = {}
PredictorFactory.__instance.concrete_predictor_factories = {}
return PredictorFactory.__instance
def RegisterDecorator(self, name, factory_func):
self.decorator_factories[name] = factory_func
def RegisterPredictor(self, name, factory_func):
self.concrete_predictor_factories[name] = factory_func
def CreatePredictor(self, config):
name = config.WhichOneof("predictor")
if name in self.concrete_predictor_factories:
return self.concrete_predictor_factories[name](getattr(config, name))
elif name in self.decorator_factories:
decorated_predictors = []
for decorated_predictor_config in config.decorated_predictors:
predictor = self.CreatePredictor(decorated_predictor_config)
decorated_predictors.append(predictor)
<|code_end|>
, predict the immediate next line with the help of imports:
from simulator.oracle import Oracle
and context (classes, functions, sometimes code) from other files:
# Path: simulator/oracle.py
# class Oracle:
# def __init__(self, config):
# self.cap_to_limit = config.oracle.cap_to_limit
# self.percentile = min(config.oracle.percentile, 100)
#
# def UpdateMeasures(self, current_snapshot, future_snapshot):
#
# current_vm_limits = [
# usage["sample"]["abstract_metrics"]["limit"]
# for usage in vars(current_snapshot)["measures"]
# ]
#
# if self.cap_to_limit == True:
# current_vm_unique_ids = [
# usage["sample"]["info"]["unique_id"]
# for usage in vars(current_snapshot)["measures"]
# ]
# vm_limits = dict(zip(current_vm_unique_ids, current_vm_limits))
#
# current_total_limit = sum(current_vm_limits)
#
# future_total_usages = []
# for snapshot in future_snapshot:
# usages_in_snapshot = [
# usage["sample"]["abstract_metrics"]["usage"]
# for usage in vars(snapshot)["measures"]
# ]
#
# if self.cap_to_limit == True:
# unique_ids_snapshot = [
# usage["sample"]["info"]["unique_id"]
# for usage in vars(snapshot)["measures"]
# ]
# vm_usages = dict(zip(unique_ids_snapshot, usages_in_snapshot))
# usages_in_snapshot = [
# vm_usages[key]
# if vm_usages[key] < vm_limits[key]
# else vm_limits[key]
# for key in vm_usages.keys()
# ]
#
# future_total_usages.append(sum(usages_in_snapshot))
#
# predicted_peak = np.nanpercentile(
# np.array(future_total_usages), self.percentile
# )
#
# if np.isnan(predicted_peak) == True:
# predicted_peak = current_total_limit
#
# return (predicted_peak, current_total_limit)
. Output only the next line. | return self.decorator_factories[name]( |
Continue the code snippet: <|code_start|># Copyright 2020 Google LLC.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
class AvgDecorator(Predictor):
def __init__(self, config=None, decorated_predictors=None):
self.decorated_predictors = decorated_predictors
def UpdateMeasures(self, snapshot):
<|code_end|>
. Use current file imports:
from simulator.predictor import Predictor
import numpy as np
and context (classes, functions, or code) from other files:
# Path: simulator/predictor.py
# class Predictor:
# def __init__(self, config, decorated_predictors=None):
# pass
#
# def UpdateMeasures(self, snapshot):
# raise NotImplementedError
#
# def _Predict(self, vmstates):
# raise NotImplementedError
. Output only the next line. | predictions = [] |
Based on the snippet: <|code_start|># See the License for the specific language governing permissions and
# limitations under the License.
class _State:
def __init__(self):
self.usage = 0
class MaxPredictor(StatefulPredictor):
def __init__(self, config):
super().__init__(config)
self.cap_to_limit = config.cap_to_limit
def CreateState(self, vm_info):
return _State()
def UpdateState(self, vm_measure, vm_state):
limit = vm_measure["sample"]["abstract_metrics"]["limit"]
usage = vm_measure["sample"]["abstract_metrics"]["usage"]
if self.cap_to_limit == True:
usage = min(usage, limit)
vm_state.usage = max(usage, vm_state.usage)
def Predict(self, vm_states_and_num_samples):
vms_peaks = []
for vm_state_and_num_sample in vm_states_and_num_samples:
vms_peaks.append(vm_state_and_num_sample.vm_state.usage)
<|code_end|>
, predict the immediate next line with the help of imports:
from simulator.predictor import StatefulPredictor
and context (classes, functions, sometimes code) from other files:
# Path: simulator/predictor.py
# class StatefulPredictor(Predictor):
# def __init__(self, config):
# super().__init__(config)
# self.warm_vms = {}
# self.cold_vms = {}
# self.vm_limits = {}
# self.min_num_samples = config.min_num_samples
#
# def _CreateState(self, vminfo):
# raise NotImplementedError
#
# def _UpdateState(self, vmmeasure, vmstate):
# raise NotImplementedError
#
# def _Predict(self, vmstates):
# raise NotImplementedError
#
# def UpdateMeasures(self, snapshot):
# vm_measures = [item for item in vars(snapshot)["measures"]]
# current_vm_keys = []
#
# for vm_measure in vm_measures:
# vm_unique_id = vm_measure["sample"]["info"]["unique_id"]
# if vm_unique_id in self.warm_vms:
# self.UpdateState(vm_measure, self.warm_vms[vm_unique_id].vm_state)
# self.warm_vms[vm_unique_id].vm_num_samples += 1
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
#
# elif vm_unique_id in self.cold_vms:
# self.UpdateState(vm_measure, self.cold_vms[vm_unique_id].vm_state)
# self.cold_vms[vm_unique_id].vm_num_samples += 1
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
# if self.cold_vms[vm_unique_id].vm_num_samples >= self.min_num_samples:
# self.warm_vms[vm_unique_id] = self.cold_vms.pop(vm_unique_id)
# else:
# vm_state = self.CreateState(vm_measure["sample"]["info"])
# self.cold_vms[vm_unique_id] = _StateAndNumSamples(vm_state, 1)
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
# self.UpdateState(vm_measure, self.cold_vms[vm_unique_id].vm_state)
#
# current_vm_keys.append(vm_unique_id)
#
# self.warm_vms = dict(
# (key, self.warm_vms[key]) for key in current_vm_keys if key in self.warm_vms
# )
#
# self.cold_vms = dict(
# (key, self.cold_vms[key]) for key in current_vm_keys if key in self.cold_vms
# )
#
# self.vm_limits = dict(
# (key, self.vm_limits[key])
# for key in current_vm_keys
# if key in self.vm_limits
# )
#
# predicted_peak = (
# 0
# if not list(self.warm_vms.values())
# else self.Predict(list(self.warm_vms.values()))
# )
# total_limit_for_cold_vms = sum(
# self.vm_limits[vm_unique_id] for vm_unique_id in self.cold_vms
# )
# total_limit_for_warm_vms = sum(
# self.vm_limits[vm_unique_id] for vm_unique_id in self.warm_vms
# )
# total_peak = predicted_peak + total_limit_for_cold_vms
# limit = total_limit_for_cold_vms + total_limit_for_warm_vms
#
# return (total_peak, limit)
. Output only the next line. | predicted_peak = sum(vms_peaks) |
Continue the code snippet: <|code_start|> self.num_history_samples = num_history_samples
self.usage = deque(maxlen=self.num_history_samples)
self.limit = deque(maxlen=self.num_history_samples)
class PerVMPercentilePredictor(StatefulPredictor):
def __init__(self, config):
super().__init__(config)
self.num_history_samples = config.num_history_samples
self.percentile = min(config.percentile, 100)
self.cap_to_limit = config.cap_to_limit
def CreateState(self, vm_info):
return _State(self.num_history_samples)
def UpdateState(self, vm_measure, vm_state):
limit = vm_measure["sample"]["abstract_metrics"]["limit"]
usage = vm_measure["sample"]["abstract_metrics"]["usage"]
if self.cap_to_limit == True:
usage = min(usage, limit)
vm_state.usage.append(usage)
vm_state.limit.append(limit)
def Predict(self, vm_states_and_num_samples):
vms_percentiles = []
for vm_state_and_num_sample in vm_states_and_num_samples:
normalized_usage = [
usage / limit
for usage, limit in zip(
<|code_end|>
. Use current file imports:
from simulator.predictor import StatefulPredictor
from collections import deque
import numpy as np
and context (classes, functions, or code) from other files:
# Path: simulator/predictor.py
# class StatefulPredictor(Predictor):
# def __init__(self, config):
# super().__init__(config)
# self.warm_vms = {}
# self.cold_vms = {}
# self.vm_limits = {}
# self.min_num_samples = config.min_num_samples
#
# def _CreateState(self, vminfo):
# raise NotImplementedError
#
# def _UpdateState(self, vmmeasure, vmstate):
# raise NotImplementedError
#
# def _Predict(self, vmstates):
# raise NotImplementedError
#
# def UpdateMeasures(self, snapshot):
# vm_measures = [item for item in vars(snapshot)["measures"]]
# current_vm_keys = []
#
# for vm_measure in vm_measures:
# vm_unique_id = vm_measure["sample"]["info"]["unique_id"]
# if vm_unique_id in self.warm_vms:
# self.UpdateState(vm_measure, self.warm_vms[vm_unique_id].vm_state)
# self.warm_vms[vm_unique_id].vm_num_samples += 1
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
#
# elif vm_unique_id in self.cold_vms:
# self.UpdateState(vm_measure, self.cold_vms[vm_unique_id].vm_state)
# self.cold_vms[vm_unique_id].vm_num_samples += 1
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
# if self.cold_vms[vm_unique_id].vm_num_samples >= self.min_num_samples:
# self.warm_vms[vm_unique_id] = self.cold_vms.pop(vm_unique_id)
# else:
# vm_state = self.CreateState(vm_measure["sample"]["info"])
# self.cold_vms[vm_unique_id] = _StateAndNumSamples(vm_state, 1)
# self.vm_limits[vm_unique_id] = vm_measure["sample"]["abstract_metrics"][
# "limit"
# ]
# self.UpdateState(vm_measure, self.cold_vms[vm_unique_id].vm_state)
#
# current_vm_keys.append(vm_unique_id)
#
# self.warm_vms = dict(
# (key, self.warm_vms[key]) for key in current_vm_keys if key in self.warm_vms
# )
#
# self.cold_vms = dict(
# (key, self.cold_vms[key]) for key in current_vm_keys if key in self.cold_vms
# )
#
# self.vm_limits = dict(
# (key, self.vm_limits[key])
# for key in current_vm_keys
# if key in self.vm_limits
# )
#
# predicted_peak = (
# 0
# if not list(self.warm_vms.values())
# else self.Predict(list(self.warm_vms.values()))
# )
# total_limit_for_cold_vms = sum(
# self.vm_limits[vm_unique_id] for vm_unique_id in self.cold_vms
# )
# total_limit_for_warm_vms = sum(
# self.vm_limits[vm_unique_id] for vm_unique_id in self.warm_vms
# )
# total_peak = predicted_peak + total_limit_for_cold_vms
# limit = total_limit_for_cold_vms + total_limit_for_warm_vms
#
# return (total_peak, limit)
. Output only the next line. | list(vm_state_and_num_sample.vm_state.usage), |
Here is a snippet: <|code_start|> # Assume lines on left and right have opposite signed slopes
left_xs = []
left_ys = []
right_xs = []
right_ys = []
for line in lines:
for x1, y1, x2, y2 in line:
if x2 - x1 == 0: continue; # Infinite slope
slope = float(y2-y1) / float(x2-x1)
if .5 <= abs(slope) < 1.0: # Discard unlikely slopes
if slope > 0:
left_xs.extend([x1, x2])
left_ys.extend([y1, y2])
else:
right_xs.extend([x1, x2])
right_ys.extend([y1, y2])
left_fit = np.polyfit(left_xs, left_ys, 1)
right_fit = np.polyfit(right_xs, right_ys, 1)
y1 = img.shape[0] # Bottom of image
y2 = img.shape[0] / 2+ 50 # Middle of view
x1_left = (y1 - left_fit[1]) / left_fit[0]
x2_left = (y2 - left_fit[1]) / left_fit[0]
x1_right = (y1 - right_fit[1]) / right_fit[0]
x2_right = (y2 - right_fit[1]) / right_fit[0]
y1 = int(y1); y2 = int(y2);
x1_left = int(x1_left); x2_left = int(x2_left);
x1_right = int(x1_right); x2_right = int(x2_right);
<|code_end|>
. Write the next line using the current file imports:
import numpy as np
import cv2
import sys
from self_driving.optical_flow.python import video
from scipy import misc
and context from other files:
# Path: self_driving/optical_flow/python/video.py
# class VideoSynthBase(object):
# class Book(VideoSynthBase):
# class Cube(VideoSynthBase):
# class Chess(VideoSynthBase):
# def __init__(self, size=None, noise=0.0, bg=None, **params):
# def render(self, dst):
# def read(self, dst=None):
# def isOpened(self):
# def __init__(self, **kw):
# def read(self, dst=None):
# def __init__(self, **kw):
# def read(self, dst=None):
# def __init__(self, **kw):
# def draw_quads(self, img, quads, color=(0, 255, 0)):
# def render(self, dst):
# def create_capture(source=0, fallback=presets['chess']):
, which may include functions, classes, or code. Output only the next line. | cv2.line(img, (x1_left, y1), (x2_left, y2), color, thickness) |
Next line prediction: <|code_start|> with self.test_session(use_gpu=False) as sess:
t = constant_op.constant(tensor_input, shape=[1, 3, 3, 2])
argmax_op = tf.argmax(t, axis=3)
argmax = sess.run([argmax_op])
self.assertAllEqual(argmax, [[[[1, 1, 1], [0, 1, 1], [1, 0, 1]]]])
def testColorImage(self):
'''[[[[ 0. 2.]
[ 3. 4.]
[ 5. 6.]]
[[ 8. 7.]
[ 9. 10.]
[ 11. 12.]]
[[ 13. 14.]
[ 16. 15.]
[ 17. 18.]]]]'''
tensor_input = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 8.0, 7.0, 9.0,
10.0, 11.0, 12.0, 13.0, 14.0, 16.0, 15.0, 17.0, 18.0]
with self.test_session(use_gpu=False):
t = constant_op.constant(tensor_input, shape=[3, 3, 1, 2])
argmax_op = tf.argmax(t, dimension=3)
up_color = evaluate.color_image(argmax_op.eval(), 1.)
self.assertAllClose(up_color, [[[[0.60000002, 0.60000002, 0.60000002, 1.]],
[[0.60000002, 0.60000002, 0.60000002, 1.]],
[[0.60000002, 0.60000002, 0.60000002, 1.]]],
[[[0.89411765, 0.10196079, 0.10980392, 1.]],
[[0.60000002, 0.60000002, 0.60000002, 1.]],
[[0.60000002, 0.60000002, 0.60000002, 1.]]],
[[[0.60000002, 0.60000002, 0.60000002, 1.]],
<|code_end|>
. Use current file imports:
(from tensorflow.python.framework import constant_op
from tensorflow.python.platform import test
from self_driving.segnet import evaluate
import tensorflow as tf)
and context including class names, function names, or small code snippets from other files:
# Path: self_driving/segnet/evaluate.py
# LOG_DIR = 'save'
# BATCH_SIZE = 4
# EPOCH = 25
# IMAGE_HEIGHT = 720
# IMAGE_WIDTH = 960
# IMAGE_CHANNEL = 3
# NUM_CLASSES = 32
# def color_mask(tensor, color):
# def one_hot(labels):
# def rgb(logits):
# def main(_):
. Output only the next line. | [[0.89411765, 0.10196079, 0.10980392, 1.]], |
Using the snippet: <|code_start|> # nets
G = generator(batch_size, gf_dim, ch, rows, cols)
G.compile("sgd", "mse")
g_vars = G.trainable_weights
print "G.shape: ", G.output_shape
E = encoder(batch_size, df_dim, ch, rows, cols)
E.compile("sgd", "mse")
e_vars = E.trainable_weights
print "E.shape: ", E.output_shape
D = discriminator(batch_size, df_dim, ch, rows, cols)
D.compile("sgd", "mse")
d_vars = D.trainable_weights
print "D.shape: ", D.output_shape
Z2 = Input(batch_shape=(batch_size, z_dim), name='more_noise')
Z = G.input
Img = D.input
image_grid = put_kernels_on_grid(tf.transpose(Img, [1, 2, 3, 0]), (8, 8))
sum_img = tf.summary.image("Img", image_grid, max_outputs=1)
G_train = G(Z)
E_mean, E_logsigma = E(Img)
G_dec = G(E_mean + Z2 * E_logsigma)
D_fake, F_fake = D(G_train)
D_dec_fake, F_dec_fake = D(G_dec)
D_legit, F_legit = D(Img)
# costs
recon_vs_gan = 1e-6
<|code_end|>
, determine the next line of code. You have imports:
import os
import numpy as np
import tensorflow as tf
from keras import backend as K
from keras.layers import Input, Dense, Reshape, Activation, Convolution2D, Deconvolution2D, LeakyReLU, Flatten, \
BatchNormalization as BN
from keras.models import Sequential, Model
from keras import initializations
from functools import partial
from utils import cifar
from utils.utils import put_kernels_on_grid
and context (class names, function names, or code) available:
# Path: utils/utils.py
# def put_kernels_on_grid(kernel, (grid_Y, grid_X), pad=1):
# '''Visualize conv. features as an image (mostly for the 1st layer).
# Place kernel into a grid, with some paddings between adjacent filters.
# Args:
# kernel: tensor of shape [Y, X, NumChannels, NumKernels]
# (grid_Y, grid_X): shape of the grid. Require: NumKernels == grid_Y * grid_X
# User is responsible of how to break into two multiples.
# pad: number of black pixels around each filter (between them)
#
# Return:
# Tensor of shape [(Y+pad)*grid_Y, (X+pad)*grid_X, NumChannels, 1].
# '''
# # pad X and Y
# x1 = tf.pad(kernel, tf.constant([[pad, 0], [pad, 0], [0, 0], [0, 0]]))
#
# # X and Y dimensions, w.r.t. padding
# Y = kernel.get_shape()[0] + pad
# X = kernel.get_shape()[1] + pad
# ch = kernel.get_shape()[2]
#
# # put NumKernels to the 1st dimension
# x2 = tf.transpose(x1, (3, 0, 1, 2))
# # organize grid on Y axis
# x3 = tf.reshape(x2, tf.pack([grid_X, Y * grid_Y, X, ch]))
#
# # switch X and Y axes
# x4 = tf.transpose(x3, (0, 2, 1, 3))
# # organize grid on X axis
# x5 = tf.reshape(x4, tf.pack([1, X * grid_X, Y * grid_Y, ch]))
#
# # back to normal order (not combining with the next step for clarity)
# x6 = tf.transpose(x5, (2, 1, 3, 0))
#
# # to tf.image_summary order [batch_size, height, width, channels],
# # where in this case batch_size == 1
# x7 = tf.transpose(x6, (3, 0, 1, 2))
#
# # scale to [0, 1]
# x_min = tf.reduce_min(x7)
# x_max = tf.reduce_max(x7)
# x8 = (x7 - x_min) / (x_max - x_min)
#
# return x8
. Output only the next line. | like_loss = tf.reduce_mean(tf.square(F_legit - F_dec_fake)) / 2. |
Given snippet: <|code_start|>BATCH_SIZE = 128
LEARNING_RATE = 1e-3
STEP_PER_EPOCH = udacity_data.NUM_TRAIN_IMAGES / BATCH_SIZE
def loss(pred, labels):
train_vars = tf.trainable_variables()
norm = tf.add_n([tf.nn.l2_loss(v) for v in train_vars])
# create a summary to monitor L2 norm
tf.summary.scalar('L2 Normalization', norm)
losses = tf.sqrt(tf.reduce_mean(tf.square(tf.subtract(pred, labels))))
# create a summary to monitor loss
tf.summary.scalar('Loss', losses)
return norm, losses, losses + norm * 0.0005
def train(total_loss):
global_step = tf.Variable(0, name='global_step', trainable=False)
# create a summary to monitor total loss
tf.summary.scalar('Total Loss', total_loss)
optimizer = tf.train.AdamOptimizer(learning_rate=LEARNING_RATE)
return optimizer.minimize(total_loss, global_step=global_step)
def main(_):
with tf.Graph().as_default():
config = tf.ConfigProto()
config.gpu_options.allocator_type = 'BFC'
sess = tf.InteractiveSession(config=config)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import tensorflow as tf
import model
from utils import udacity_data
and context:
# Path: utils/udacity_data.py
# TRAIN_IMG_PREFIX = "/usr/local/google/home/limeng/Downloads/udacity/ch2_002/output/HMB_%s/"
# TRAIN_CSV = "/usr/local/google/home/limeng/Downloads/udacity/ch2_002/output/HMB_%s/interpolated.csv"
# VAL_IMG_PREFIX = "/usr/local/google/home/limeng/Downloads/udacity/test/HMB_3/"
# VAL_CSV = "/usr/local/google/home/limeng/Downloads/udacity/test/HMB_3/interpolated.csv"
# NUM_TRAIN_IMAGES = 33808
# NUM_VAL_IMAGES = 5279
# def read_csv(csv_file_name, img_prefix):
# def read_data(shuffe=True):
# def load_train_batch(batch_size):
# def load_val_batch(batch_size):
# def main(_):
which might include code, classes, or functions. Output only the next line. | x_image = tf.placeholder(tf.float32, shape=[None, 66, 200, 3], name="x_image") |
Here is a snippet: <|code_start|>dirname = os.path.dirname(os.path.abspath(__file__))
up_dir = os.path.dirname(dirname)
sys.path.append(up_dir)
class REDISDB(Backend):
name = "redis"
expiretime = 60*60*24*7 # for a week
def init(self):
logger.debug("Connecting to Redis")
self.connection = redis.StrictRedis(host='localhost', port=6379, db=12)
def check(self):
logger.debug("check not needed with redis")
def load(self):
logger.debug("Redis auto loads")
def save(self):
self.connection.save()
def addProject(self, key, project, type):
project_string = project + ":::" + type
self.connection.sadd(key, project_string)
def listProjects(self, key):
members = self.connection.smembers(key)
returnList = []
for member in members:
returnList.append(member.split(":::"))
return returnList
def addMeta(self, path, modified, hash, size, type):
pipe = self.connection.pipeline()
pipe.hmset(path, dict(modified=modified, hash=hash, size=size, type=type)).expire(path, self.expiretime).execute()
del pipe
<|code_end|>
. Write the next line using the current file imports:
import sys
import os
import redis
from relo.core.log import logger
from relo.core.interfaces import Backend
and context from other files:
# Path: relo/core/log.py
# LEVEL = {
# 'NORMAL': 0,
# 'INFO': 1,
# 'DEBUG': 2,
# 'CRITICAl': 0,
# 'ERROR': 0,
# 'EXCEPTION': 0,
# }
# ESCAPE = '\033[%sm'
# BOLD = '1;%s'
# UNDERLINE = '4;%s'
# BLUE_ARROW = ESCAPE % (BOLD % '34') # Blue Bold
# DEBUG = ESCAPE % (BOLD % '35') # Magenta Bold
# HEAD = ESCAPE % (BOLD % '1') # Bold White (Standard Color)
# INFO = ESCAPE % '32' # Green Normal
# WARNING = ESCAPE % '33' # Yellow Normal
# ERROR = ESCAPE % '31' # Red Normal
# CRITICAL = ESCAPE % (UNDERLINE % '31') # Red Underline
# ITEM = ESCAPE % (BOLD % '37') # Black Bold/Bright
# SUBITEM = ESCAPE % '37' # White Normal
# ENDC = ESCAPE % '0'
# class Color(object):
# class Logger(object):
# def _deco(cls, msg, color):
# def blueArrow(cls, msg):
# def head(cls, msg):
# def debug(cls, msg):
# def info(cls, msg):
# def warning(cls, msg):
# def error(cls, msg):
# def critical(cls, msg):
# def item(cls, msg):
# def subitem(cls, msg):
# def __init__(self):
# def debug(self, msg):
# def head(self, msg):
# def log(self, msg):
# def info(self, msg):
# def warning(self, msg):
# def error(self, msg):
# def critical(self, msg):
# def item(self, msg):
# def subitem(self, msg):
# def _stdout(self, msg):
# def _stderr(self, msg):
#
# Path: relo/core/interfaces.py
# class Backend(IPlugin):
# """
# Implements external backends that can be used to store indexes and alike
# """
# name = ""
# def meta(self):
# return self.name
# def init(self):
# pass
# def check(self):
# """
# checks for old index
# """
# def load(self):
# """
# loads the current index on start
# """
# pass
# def save(self):
# """
# saves the new index to the drive
# """
# pass
# def addMeta(self, path, modified, hash, size, type):
# """
# adds a new file to the index
# """
# pass
# def end(self):
# pass
, which may include functions, classes, or code. Output only the next line. | def addSet(self, key, value): |
Given the code snippet: <|code_start|>#!/usr/bin/env python
# encoding: utf-8
dirname = os.path.dirname(os.path.abspath(__file__))
up_dir = os.path.dirname(dirname)
sys.path.append(up_dir)
class REDISDB(Backend):
name = "redis"
<|code_end|>
, generate the next line using the imports in this file:
import sys
import os
import redis
from relo.core.log import logger
from relo.core.interfaces import Backend
and context (functions, classes, or occasionally code) from other files:
# Path: relo/core/log.py
# LEVEL = {
# 'NORMAL': 0,
# 'INFO': 1,
# 'DEBUG': 2,
# 'CRITICAl': 0,
# 'ERROR': 0,
# 'EXCEPTION': 0,
# }
# ESCAPE = '\033[%sm'
# BOLD = '1;%s'
# UNDERLINE = '4;%s'
# BLUE_ARROW = ESCAPE % (BOLD % '34') # Blue Bold
# DEBUG = ESCAPE % (BOLD % '35') # Magenta Bold
# HEAD = ESCAPE % (BOLD % '1') # Bold White (Standard Color)
# INFO = ESCAPE % '32' # Green Normal
# WARNING = ESCAPE % '33' # Yellow Normal
# ERROR = ESCAPE % '31' # Red Normal
# CRITICAL = ESCAPE % (UNDERLINE % '31') # Red Underline
# ITEM = ESCAPE % (BOLD % '37') # Black Bold/Bright
# SUBITEM = ESCAPE % '37' # White Normal
# ENDC = ESCAPE % '0'
# class Color(object):
# class Logger(object):
# def _deco(cls, msg, color):
# def blueArrow(cls, msg):
# def head(cls, msg):
# def debug(cls, msg):
# def info(cls, msg):
# def warning(cls, msg):
# def error(cls, msg):
# def critical(cls, msg):
# def item(cls, msg):
# def subitem(cls, msg):
# def __init__(self):
# def debug(self, msg):
# def head(self, msg):
# def log(self, msg):
# def info(self, msg):
# def warning(self, msg):
# def error(self, msg):
# def critical(self, msg):
# def item(self, msg):
# def subitem(self, msg):
# def _stdout(self, msg):
# def _stderr(self, msg):
#
# Path: relo/core/interfaces.py
# class Backend(IPlugin):
# """
# Implements external backends that can be used to store indexes and alike
# """
# name = ""
# def meta(self):
# return self.name
# def init(self):
# pass
# def check(self):
# """
# checks for old index
# """
# def load(self):
# """
# loads the current index on start
# """
# pass
# def save(self):
# """
# saves the new index to the drive
# """
# pass
# def addMeta(self, path, modified, hash, size, type):
# """
# adds a new file to the index
# """
# pass
# def end(self):
# pass
. Output only the next line. | expiretime = 60*60*24*7 # for a week |
Continue the code snippet: <|code_start|>#!/usr/bin/env python
# encoding: utf-8
dirname = os.path.dirname(os.path.abspath(__file__))
up_dir = os.path.dirname(dirname)
sys.path.append(up_dir)
class LOG(DocType):
<|code_end|>
. Use current file imports:
import sys
import os
from relo.core.interfaces import DocType
and context (classes, functions, or code) from other files:
# Path: relo/core/interfaces.py
# class DocType(ReloPlugin):
# """""
# Implements different type of docs
# """""
# def load(self, path):
# self.path = path
# self.fobj = open(path, "r")
# self.content = ""
# for line in self.fobj:
# self.content += line
# self.fobj.close()
# return self.content
. Output only the next line. | name = "LOG Plugin" |
Based on the snippet: <|code_start|>#!/usr/bin/env python
# encoding: utf-8
dirname = os.path.dirname(os.path.abspath(__file__))
up_dir = os.path.dirname(dirname)
sys.path.append(up_dir)
class TEST(DocType):
<|code_end|>
, predict the immediate next line with the help of imports:
import sys
import os
from relo.core.interfaces import DocType
and context (classes, functions, sometimes code) from other files:
# Path: relo/core/interfaces.py
# class DocType(ReloPlugin):
# """""
# Implements different type of docs
# """""
# def load(self, path):
# self.path = path
# self.fobj = open(path, "r")
# self.content = ""
# for line in self.fobj:
# self.content += line
# self.fobj.close()
# return self.content
. Output only the next line. | name = "TEST Plugin" |
Next line prediction: <|code_start|>#!/usr/bin/env python
#encoding: utf-8
def curl(url, path):
command = "curl -L -# -o '%s' '%s'" % (path, url)
logger.debug(command)
subprocess.call(command, shell=True)
class AbstractDownloader(object):
def __init__(self):
pass
def url2name(self, url):
return basename(urlsplit(url)[2])
def download(self, url, path, localFileName = None):
pass
class HTTPDownloader(AbstractDownloader):
def __init__(self):
AbstractDownloader.__init__(self)
pass
def download(self, url, path, fileName = None):
def getFileName(url,openUrl):
if 'Content-Disposition' in openUrl.info():
# If the response has Content-Disposition, try to get filename from it
cd = dict(map(
lambda x: x.strip().split('=') if '=' in x else (x.strip(),''),
<|code_end|>
. Use current file imports:
(import sys, os
import urllib2
import urlparse
import shutil
import subprocess
from os.path import basename
from relo.core.log import logger)
and context including class names, function names, or small code snippets from other files:
# Path: relo/core/log.py
# LEVEL = {
# 'NORMAL': 0,
# 'INFO': 1,
# 'DEBUG': 2,
# 'CRITICAl': 0,
# 'ERROR': 0,
# 'EXCEPTION': 0,
# }
# ESCAPE = '\033[%sm'
# BOLD = '1;%s'
# UNDERLINE = '4;%s'
# BLUE_ARROW = ESCAPE % (BOLD % '34') # Blue Bold
# DEBUG = ESCAPE % (BOLD % '35') # Magenta Bold
# HEAD = ESCAPE % (BOLD % '1') # Bold White (Standard Color)
# INFO = ESCAPE % '32' # Green Normal
# WARNING = ESCAPE % '33' # Yellow Normal
# ERROR = ESCAPE % '31' # Red Normal
# CRITICAL = ESCAPE % (UNDERLINE % '31') # Red Underline
# ITEM = ESCAPE % (BOLD % '37') # Black Bold/Bright
# SUBITEM = ESCAPE % '37' # White Normal
# ENDC = ESCAPE % '0'
# class Color(object):
# class Logger(object):
# def _deco(cls, msg, color):
# def blueArrow(cls, msg):
# def head(cls, msg):
# def debug(cls, msg):
# def info(cls, msg):
# def warning(cls, msg):
# def error(cls, msg):
# def critical(cls, msg):
# def item(cls, msg):
# def subitem(cls, msg):
# def __init__(self):
# def debug(self, msg):
# def head(self, msg):
# def log(self, msg):
# def info(self, msg):
# def warning(self, msg):
# def error(self, msg):
# def critical(self, msg):
# def item(self, msg):
# def subitem(self, msg):
# def _stdout(self, msg):
# def _stderr(self, msg):
. Output only the next line. | openUrl.info().split(';'))) |
Using the snippet: <|code_start|>
if progress is not None:
progress(0)
self._progress = progress
self._lastprogress = 0
self._totalread = 0
def _updateprogress(self, length):
if self._progress is not None:
self._totalread += length
progress = (self._totalread * 100) / self._size
if self._lastprogress < progress <= 100:
self._progress(progress)
self._lastprogress = progress
def read(self, size= -1):
data = self._fileobj.read(size)
self._updateprogress(len(data))
return data
def readline(self, size= -1):
data = self._fileobj.readline(size)
self._updateprogress(len(data))
<|code_end|>
, determine the next line of code. You have imports:
import tarfile
import os
from relo.core.log import logger
and context (class names, function names, or code) available:
# Path: relo/core/log.py
# LEVEL = {
# 'NORMAL': 0,
# 'INFO': 1,
# 'DEBUG': 2,
# 'CRITICAl': 0,
# 'ERROR': 0,
# 'EXCEPTION': 0,
# }
# ESCAPE = '\033[%sm'
# BOLD = '1;%s'
# UNDERLINE = '4;%s'
# BLUE_ARROW = ESCAPE % (BOLD % '34') # Blue Bold
# DEBUG = ESCAPE % (BOLD % '35') # Magenta Bold
# HEAD = ESCAPE % (BOLD % '1') # Bold White (Standard Color)
# INFO = ESCAPE % '32' # Green Normal
# WARNING = ESCAPE % '33' # Yellow Normal
# ERROR = ESCAPE % '31' # Red Normal
# CRITICAL = ESCAPE % (UNDERLINE % '31') # Red Underline
# ITEM = ESCAPE % (BOLD % '37') # Black Bold/Bright
# SUBITEM = ESCAPE % '37' # White Normal
# ENDC = ESCAPE % '0'
# class Color(object):
# class Logger(object):
# def _deco(cls, msg, color):
# def blueArrow(cls, msg):
# def head(cls, msg):
# def debug(cls, msg):
# def info(cls, msg):
# def warning(cls, msg):
# def error(cls, msg):
# def critical(cls, msg):
# def item(cls, msg):
# def subitem(cls, msg):
# def __init__(self):
# def debug(self, msg):
# def head(self, msg):
# def log(self, msg):
# def info(self, msg):
# def warning(self, msg):
# def error(self, msg):
# def critical(self, msg):
# def item(self, msg):
# def subitem(self, msg):
# def _stdout(self, msg):
# def _stderr(self, msg):
. Output only the next line. | return data |
Based on the snippet: <|code_start|>#!/usr/bin/env python
# encoding: utf-8
dirname = os.path.dirname(os.path.abspath(__file__))
up_dir = os.path.dirname(dirname)
sys.path.append(up_dir)
#from pyPdf import PdfFileReader
class PDF(DocType):
name = "PDF Plugin"
def load(self, path):
#self.path = path
#self.pdfObject = PdfFileReader(file(path, "rb"))
#self.content = ""
#for page in self.pdfObject.pages:
# self.content += page.extractText() + "\n"
self.path = path
rsrcmgr = PDFResourceManager()
restr = StringIO()
codec = 'utf-8'
laparams = LAParams()
device = TextConverter(rsrcmgr, restr, codec=codec, laparams=laparams)
fp = file(path, 'rb')
<|code_end|>
, predict the immediate next line with the help of imports:
import sys
import os
from relo.core.interfaces import DocType
from pdfminer.pdfparser import PDFDocument, PDFParser
from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter, process_pdf
from pdfminer.pdfdevice import PDFDevice, TagExtractor
from pdfminer.converter import XMLConverter, HTMLConverter, TextConverter
from pdfminer.cmapdb import CMapDB
from pdfminer.layout import LAParams
from cStringIO import StringIO
and context (classes, functions, sometimes code) from other files:
# Path: relo/core/interfaces.py
# class DocType(ReloPlugin):
# """""
# Implements different type of docs
# """""
# def load(self, path):
# self.path = path
# self.fobj = open(path, "r")
# self.content = ""
# for line in self.fobj:
# self.content += line
# self.fobj.close()
# return self.content
. Output only the next line. | process_pdf(rsrcmgr, device, fp) |
Continue the code snippet: <|code_start|>#!/usr/bin/env python
# encoding: utf-8
class AbstractUpdater(object):
def __init__(self):
self.localVersion = 0
self.remoteVersion = 0
def getLocalVersion(self):
pass
<|code_end|>
. Use current file imports:
from relo.core.log import logger
from relo.core.config import conf, RELO_DEVELOP_VERSION_URL, RELO_MASTER_VERSION_URL, RELO_UPDATE_URL_DEVELOP, RELO_UPDATE_URL_MASTER
from relo.core.exceptions import UpdateException
from relo.core import util
from relo.net.download import curl
import tarfile
import urllib
import sys
import os
and context (classes, functions, or code) from other files:
# Path: relo/core/log.py
# LEVEL = {
# 'NORMAL': 0,
# 'INFO': 1,
# 'DEBUG': 2,
# 'CRITICAl': 0,
# 'ERROR': 0,
# 'EXCEPTION': 0,
# }
# ESCAPE = '\033[%sm'
# BOLD = '1;%s'
# UNDERLINE = '4;%s'
# BLUE_ARROW = ESCAPE % (BOLD % '34') # Blue Bold
# DEBUG = ESCAPE % (BOLD % '35') # Magenta Bold
# HEAD = ESCAPE % (BOLD % '1') # Bold White (Standard Color)
# INFO = ESCAPE % '32' # Green Normal
# WARNING = ESCAPE % '33' # Yellow Normal
# ERROR = ESCAPE % '31' # Red Normal
# CRITICAL = ESCAPE % (UNDERLINE % '31') # Red Underline
# ITEM = ESCAPE % (BOLD % '37') # Black Bold/Bright
# SUBITEM = ESCAPE % '37' # White Normal
# ENDC = ESCAPE % '0'
# class Color(object):
# class Logger(object):
# def _deco(cls, msg, color):
# def blueArrow(cls, msg):
# def head(cls, msg):
# def debug(cls, msg):
# def info(cls, msg):
# def warning(cls, msg):
# def error(cls, msg):
# def critical(cls, msg):
# def item(cls, msg):
# def subitem(cls, msg):
# def __init__(self):
# def debug(self, msg):
# def head(self, msg):
# def log(self, msg):
# def info(self, msg):
# def warning(self, msg):
# def error(self, msg):
# def critical(self, msg):
# def item(self, msg):
# def subitem(self, msg):
# def _stdout(self, msg):
# def _stderr(self, msg):
#
# Path: relo/core/config.py
# VERSION = (0, 6, 'beta')
# INSTALLER_ROOT = os.path.dirname(os.path.abspath(__file__))
# ROOT = os.environ.get("RELO_ROOT")
# ROOT = os.path.join(os.environ["HOME"], ".relo")
# PATH_ETC = os.path.join(ROOT, 'etc')
# PATH_BIN = os.path.join(ROOT, 'bin')
# PATH_LOG = os.path.join(ROOT, 'log')
# PATH_SCRIPTS = os.path.join(ROOT, 'scripts')
# PATH_BIN_RELO = os.path.join(PATH_BIN, 'relo')
# PATH_ETC_CONFIG = os.path.join(PATH_ETC, 'config.cfg')
# PATH_HOME = os.environ.get("RELO_HOME")
# PATH_HOME = os.path.join(os.environ["HOME"], ".relo")
# PATH_HOME_ETC = os.path.join(PATH_HOME, 'etc')
# RELO_UPDATE_URL_MASTER = conf.readConfig('core.master')
# RELO_UPDATE_URL_DEVELOP = conf.readConfig('core.develop')
# RELO_UPDATE_URL_PYPI = conf.readConfig('core.pypi')
# RELO_UPDATE_URL_CONFIG = conf.readConfig('core.config')
# RELO_MASTER_VERSION_URL = conf.readConfig('core.master-version')
# RELO_DEVELOP_VERSION_URL = conf.readConfig('core.develop-version')
# STOP_WORDS = ("the", "of", "to", "and", "a", "in", "is", "it", "you", "that")
# MIN_WORD_LENGTH = 3
# PUNCTUATION_CHARS = ".,;:!?@£$%^&*()-–<>[]{}\\|/`~'\""
# REDIS_KEY_METAPHONES = "id:%(project_id)s:metaphones"
# REDIS_KEY_METAPHONE = "id:%(project_id)s:mp:%(metaphone)s"
# REDIS_KEY_DOCUMENTS = "id:%(project_id)s:docs"
# REDIS_KEY_DOCUMENT = "id%(project_id)s:doc:%(document)s"
# REDIS_KEY_PROJECTS = "projects"
# def get_version():
# def get_long_version():
# def __init__(self):
# def loadConfig(self):
# def saveConfig(self):
# def listConfig(self, category):
# def listCore():
# def listLocal():
# def listNet():
# def readConfig(self, key):
# def writeConfig(self, key, value):
# class ReloConfig(object):
#
# Path: relo/core/exceptions.py
# class UpdateException(Exception):
# """General exception during update"""
#
# Path: relo/core/util.py
# def mkdirs(path):
#
# Path: relo/net/download.py
# def curl(url, path):
# command = "curl -L -# -o '%s' '%s'" % (path, url)
# logger.debug(command)
# subprocess.call(command, shell=True)
. Output only the next line. | def getRemoteVersion(self): |
Using the snippet: <|code_start|>#!/usr/bin/env python
# encoding: utf-8
class AbstractUpdater(object):
def __init__(self):
self.localVersion = 0
<|code_end|>
, determine the next line of code. You have imports:
from relo.core.log import logger
from relo.core.config import conf, RELO_DEVELOP_VERSION_URL, RELO_MASTER_VERSION_URL, RELO_UPDATE_URL_DEVELOP, RELO_UPDATE_URL_MASTER
from relo.core.exceptions import UpdateException
from relo.core import util
from relo.net.download import curl
import tarfile
import urllib
import sys
import os
and context (class names, function names, or code) available:
# Path: relo/core/log.py
# LEVEL = {
# 'NORMAL': 0,
# 'INFO': 1,
# 'DEBUG': 2,
# 'CRITICAl': 0,
# 'ERROR': 0,
# 'EXCEPTION': 0,
# }
# ESCAPE = '\033[%sm'
# BOLD = '1;%s'
# UNDERLINE = '4;%s'
# BLUE_ARROW = ESCAPE % (BOLD % '34') # Blue Bold
# DEBUG = ESCAPE % (BOLD % '35') # Magenta Bold
# HEAD = ESCAPE % (BOLD % '1') # Bold White (Standard Color)
# INFO = ESCAPE % '32' # Green Normal
# WARNING = ESCAPE % '33' # Yellow Normal
# ERROR = ESCAPE % '31' # Red Normal
# CRITICAL = ESCAPE % (UNDERLINE % '31') # Red Underline
# ITEM = ESCAPE % (BOLD % '37') # Black Bold/Bright
# SUBITEM = ESCAPE % '37' # White Normal
# ENDC = ESCAPE % '0'
# class Color(object):
# class Logger(object):
# def _deco(cls, msg, color):
# def blueArrow(cls, msg):
# def head(cls, msg):
# def debug(cls, msg):
# def info(cls, msg):
# def warning(cls, msg):
# def error(cls, msg):
# def critical(cls, msg):
# def item(cls, msg):
# def subitem(cls, msg):
# def __init__(self):
# def debug(self, msg):
# def head(self, msg):
# def log(self, msg):
# def info(self, msg):
# def warning(self, msg):
# def error(self, msg):
# def critical(self, msg):
# def item(self, msg):
# def subitem(self, msg):
# def _stdout(self, msg):
# def _stderr(self, msg):
#
# Path: relo/core/config.py
# VERSION = (0, 6, 'beta')
# INSTALLER_ROOT = os.path.dirname(os.path.abspath(__file__))
# ROOT = os.environ.get("RELO_ROOT")
# ROOT = os.path.join(os.environ["HOME"], ".relo")
# PATH_ETC = os.path.join(ROOT, 'etc')
# PATH_BIN = os.path.join(ROOT, 'bin')
# PATH_LOG = os.path.join(ROOT, 'log')
# PATH_SCRIPTS = os.path.join(ROOT, 'scripts')
# PATH_BIN_RELO = os.path.join(PATH_BIN, 'relo')
# PATH_ETC_CONFIG = os.path.join(PATH_ETC, 'config.cfg')
# PATH_HOME = os.environ.get("RELO_HOME")
# PATH_HOME = os.path.join(os.environ["HOME"], ".relo")
# PATH_HOME_ETC = os.path.join(PATH_HOME, 'etc')
# RELO_UPDATE_URL_MASTER = conf.readConfig('core.master')
# RELO_UPDATE_URL_DEVELOP = conf.readConfig('core.develop')
# RELO_UPDATE_URL_PYPI = conf.readConfig('core.pypi')
# RELO_UPDATE_URL_CONFIG = conf.readConfig('core.config')
# RELO_MASTER_VERSION_URL = conf.readConfig('core.master-version')
# RELO_DEVELOP_VERSION_URL = conf.readConfig('core.develop-version')
# STOP_WORDS = ("the", "of", "to", "and", "a", "in", "is", "it", "you", "that")
# MIN_WORD_LENGTH = 3
# PUNCTUATION_CHARS = ".,;:!?@£$%^&*()-–<>[]{}\\|/`~'\""
# REDIS_KEY_METAPHONES = "id:%(project_id)s:metaphones"
# REDIS_KEY_METAPHONE = "id:%(project_id)s:mp:%(metaphone)s"
# REDIS_KEY_DOCUMENTS = "id:%(project_id)s:docs"
# REDIS_KEY_DOCUMENT = "id%(project_id)s:doc:%(document)s"
# REDIS_KEY_PROJECTS = "projects"
# def get_version():
# def get_long_version():
# def __init__(self):
# def loadConfig(self):
# def saveConfig(self):
# def listConfig(self, category):
# def listCore():
# def listLocal():
# def listNet():
# def readConfig(self, key):
# def writeConfig(self, key, value):
# class ReloConfig(object):
#
# Path: relo/core/exceptions.py
# class UpdateException(Exception):
# """General exception during update"""
#
# Path: relo/core/util.py
# def mkdirs(path):
#
# Path: relo/net/download.py
# def curl(url, path):
# command = "curl -L -# -o '%s' '%s'" % (path, url)
# logger.debug(command)
# subprocess.call(command, shell=True)
. Output only the next line. | self.remoteVersion = 0 |
Given the code snippet: <|code_start|>#!/usr/bin/env python
# encoding: utf-8
class AbstractUpdater(object):
def __init__(self):
self.localVersion = 0
self.remoteVersion = 0
def getLocalVersion(self):
pass
<|code_end|>
, generate the next line using the imports in this file:
from relo.core.log import logger
from relo.core.config import conf, RELO_DEVELOP_VERSION_URL, RELO_MASTER_VERSION_URL, RELO_UPDATE_URL_DEVELOP, RELO_UPDATE_URL_MASTER
from relo.core.exceptions import UpdateException
from relo.core import util
from relo.net.download import curl
import tarfile
import urllib
import sys
import os
and context (functions, classes, or occasionally code) from other files:
# Path: relo/core/log.py
# LEVEL = {
# 'NORMAL': 0,
# 'INFO': 1,
# 'DEBUG': 2,
# 'CRITICAl': 0,
# 'ERROR': 0,
# 'EXCEPTION': 0,
# }
# ESCAPE = '\033[%sm'
# BOLD = '1;%s'
# UNDERLINE = '4;%s'
# BLUE_ARROW = ESCAPE % (BOLD % '34') # Blue Bold
# DEBUG = ESCAPE % (BOLD % '35') # Magenta Bold
# HEAD = ESCAPE % (BOLD % '1') # Bold White (Standard Color)
# INFO = ESCAPE % '32' # Green Normal
# WARNING = ESCAPE % '33' # Yellow Normal
# ERROR = ESCAPE % '31' # Red Normal
# CRITICAL = ESCAPE % (UNDERLINE % '31') # Red Underline
# ITEM = ESCAPE % (BOLD % '37') # Black Bold/Bright
# SUBITEM = ESCAPE % '37' # White Normal
# ENDC = ESCAPE % '0'
# class Color(object):
# class Logger(object):
# def _deco(cls, msg, color):
# def blueArrow(cls, msg):
# def head(cls, msg):
# def debug(cls, msg):
# def info(cls, msg):
# def warning(cls, msg):
# def error(cls, msg):
# def critical(cls, msg):
# def item(cls, msg):
# def subitem(cls, msg):
# def __init__(self):
# def debug(self, msg):
# def head(self, msg):
# def log(self, msg):
# def info(self, msg):
# def warning(self, msg):
# def error(self, msg):
# def critical(self, msg):
# def item(self, msg):
# def subitem(self, msg):
# def _stdout(self, msg):
# def _stderr(self, msg):
#
# Path: relo/core/config.py
# VERSION = (0, 6, 'beta')
# INSTALLER_ROOT = os.path.dirname(os.path.abspath(__file__))
# ROOT = os.environ.get("RELO_ROOT")
# ROOT = os.path.join(os.environ["HOME"], ".relo")
# PATH_ETC = os.path.join(ROOT, 'etc')
# PATH_BIN = os.path.join(ROOT, 'bin')
# PATH_LOG = os.path.join(ROOT, 'log')
# PATH_SCRIPTS = os.path.join(ROOT, 'scripts')
# PATH_BIN_RELO = os.path.join(PATH_BIN, 'relo')
# PATH_ETC_CONFIG = os.path.join(PATH_ETC, 'config.cfg')
# PATH_HOME = os.environ.get("RELO_HOME")
# PATH_HOME = os.path.join(os.environ["HOME"], ".relo")
# PATH_HOME_ETC = os.path.join(PATH_HOME, 'etc')
# RELO_UPDATE_URL_MASTER = conf.readConfig('core.master')
# RELO_UPDATE_URL_DEVELOP = conf.readConfig('core.develop')
# RELO_UPDATE_URL_PYPI = conf.readConfig('core.pypi')
# RELO_UPDATE_URL_CONFIG = conf.readConfig('core.config')
# RELO_MASTER_VERSION_URL = conf.readConfig('core.master-version')
# RELO_DEVELOP_VERSION_URL = conf.readConfig('core.develop-version')
# STOP_WORDS = ("the", "of", "to", "and", "a", "in", "is", "it", "you", "that")
# MIN_WORD_LENGTH = 3
# PUNCTUATION_CHARS = ".,;:!?@£$%^&*()-–<>[]{}\\|/`~'\""
# REDIS_KEY_METAPHONES = "id:%(project_id)s:metaphones"
# REDIS_KEY_METAPHONE = "id:%(project_id)s:mp:%(metaphone)s"
# REDIS_KEY_DOCUMENTS = "id:%(project_id)s:docs"
# REDIS_KEY_DOCUMENT = "id%(project_id)s:doc:%(document)s"
# REDIS_KEY_PROJECTS = "projects"
# def get_version():
# def get_long_version():
# def __init__(self):
# def loadConfig(self):
# def saveConfig(self):
# def listConfig(self, category):
# def listCore():
# def listLocal():
# def listNet():
# def readConfig(self, key):
# def writeConfig(self, key, value):
# class ReloConfig(object):
#
# Path: relo/core/exceptions.py
# class UpdateException(Exception):
# """General exception during update"""
#
# Path: relo/core/util.py
# def mkdirs(path):
#
# Path: relo/net/download.py
# def curl(url, path):
# command = "curl -L -# -o '%s' '%s'" % (path, url)
# logger.debug(command)
# subprocess.call(command, shell=True)
. Output only the next line. | def getRemoteVersion(self): |
Next line prediction: <|code_start|>#!/usr/bin/env python
# encoding: utf-8
class AbstractUpdater(object):
def __init__(self):
self.localVersion = 0
self.remoteVersion = 0
def getLocalVersion(self):
pass
def getRemoteVersion(self):
<|code_end|>
. Use current file imports:
(from relo.core.log import logger
from relo.core.config import conf, RELO_DEVELOP_VERSION_URL, RELO_MASTER_VERSION_URL, RELO_UPDATE_URL_DEVELOP, RELO_UPDATE_URL_MASTER
from relo.core.exceptions import UpdateException
from relo.core import util
from relo.net.download import curl
import tarfile
import urllib
import sys
import os)
and context including class names, function names, or small code snippets from other files:
# Path: relo/core/log.py
# LEVEL = {
# 'NORMAL': 0,
# 'INFO': 1,
# 'DEBUG': 2,
# 'CRITICAl': 0,
# 'ERROR': 0,
# 'EXCEPTION': 0,
# }
# ESCAPE = '\033[%sm'
# BOLD = '1;%s'
# UNDERLINE = '4;%s'
# BLUE_ARROW = ESCAPE % (BOLD % '34') # Blue Bold
# DEBUG = ESCAPE % (BOLD % '35') # Magenta Bold
# HEAD = ESCAPE % (BOLD % '1') # Bold White (Standard Color)
# INFO = ESCAPE % '32' # Green Normal
# WARNING = ESCAPE % '33' # Yellow Normal
# ERROR = ESCAPE % '31' # Red Normal
# CRITICAL = ESCAPE % (UNDERLINE % '31') # Red Underline
# ITEM = ESCAPE % (BOLD % '37') # Black Bold/Bright
# SUBITEM = ESCAPE % '37' # White Normal
# ENDC = ESCAPE % '0'
# class Color(object):
# class Logger(object):
# def _deco(cls, msg, color):
# def blueArrow(cls, msg):
# def head(cls, msg):
# def debug(cls, msg):
# def info(cls, msg):
# def warning(cls, msg):
# def error(cls, msg):
# def critical(cls, msg):
# def item(cls, msg):
# def subitem(cls, msg):
# def __init__(self):
# def debug(self, msg):
# def head(self, msg):
# def log(self, msg):
# def info(self, msg):
# def warning(self, msg):
# def error(self, msg):
# def critical(self, msg):
# def item(self, msg):
# def subitem(self, msg):
# def _stdout(self, msg):
# def _stderr(self, msg):
#
# Path: relo/core/config.py
# VERSION = (0, 6, 'beta')
# INSTALLER_ROOT = os.path.dirname(os.path.abspath(__file__))
# ROOT = os.environ.get("RELO_ROOT")
# ROOT = os.path.join(os.environ["HOME"], ".relo")
# PATH_ETC = os.path.join(ROOT, 'etc')
# PATH_BIN = os.path.join(ROOT, 'bin')
# PATH_LOG = os.path.join(ROOT, 'log')
# PATH_SCRIPTS = os.path.join(ROOT, 'scripts')
# PATH_BIN_RELO = os.path.join(PATH_BIN, 'relo')
# PATH_ETC_CONFIG = os.path.join(PATH_ETC, 'config.cfg')
# PATH_HOME = os.environ.get("RELO_HOME")
# PATH_HOME = os.path.join(os.environ["HOME"], ".relo")
# PATH_HOME_ETC = os.path.join(PATH_HOME, 'etc')
# RELO_UPDATE_URL_MASTER = conf.readConfig('core.master')
# RELO_UPDATE_URL_DEVELOP = conf.readConfig('core.develop')
# RELO_UPDATE_URL_PYPI = conf.readConfig('core.pypi')
# RELO_UPDATE_URL_CONFIG = conf.readConfig('core.config')
# RELO_MASTER_VERSION_URL = conf.readConfig('core.master-version')
# RELO_DEVELOP_VERSION_URL = conf.readConfig('core.develop-version')
# STOP_WORDS = ("the", "of", "to", "and", "a", "in", "is", "it", "you", "that")
# MIN_WORD_LENGTH = 3
# PUNCTUATION_CHARS = ".,;:!?@£$%^&*()-–<>[]{}\\|/`~'\""
# REDIS_KEY_METAPHONES = "id:%(project_id)s:metaphones"
# REDIS_KEY_METAPHONE = "id:%(project_id)s:mp:%(metaphone)s"
# REDIS_KEY_DOCUMENTS = "id:%(project_id)s:docs"
# REDIS_KEY_DOCUMENT = "id%(project_id)s:doc:%(document)s"
# REDIS_KEY_PROJECTS = "projects"
# def get_version():
# def get_long_version():
# def __init__(self):
# def loadConfig(self):
# def saveConfig(self):
# def listConfig(self, category):
# def listCore():
# def listLocal():
# def listNet():
# def readConfig(self, key):
# def writeConfig(self, key, value):
# class ReloConfig(object):
#
# Path: relo/core/exceptions.py
# class UpdateException(Exception):
# """General exception during update"""
#
# Path: relo/core/util.py
# def mkdirs(path):
#
# Path: relo/net/download.py
# def curl(url, path):
# command = "curl -L -# -o '%s' '%s'" % (path, url)
# logger.debug(command)
# subprocess.call(command, shell=True)
. Output only the next line. | pass |
Using the snippet: <|code_start|>
try:
# available in python-2.5 and greater
except ImportError:
# compatibility fallback
logger = getLogger("pki")
<|code_end|>
, determine the next line of code. You have imports:
import os
import re
import string
import random
import pki.models
from subprocess import Popen, PIPE, STDOUT
from shutil import rmtree
from logging import getLogger
from django.template.loader import render_to_string
from pki.helper import subject_for_object
from pki.settings import PKI_OPENSSL_BIN, PKI_OPENSSL_CONF, PKI_DIR, PKI_OPENSSL_TEMPLATE, \
PKI_SELF_SIGNED_SERIAL, PKI_CA_NAME_BLACKLIST
from hashlib import md5 as md5_constructor
from md5 import new as md5_constructor
and context (class names, function names, or code) available:
# Path: pki/helper.py
# def subject_for_object(obj):
# """Return a subject string.
#
# A OpenSSL compatible subject string is returned.
# """
#
# subj = '/CN=%s/C=%s/ST=%s/localityName=%s/O=%s' % ( obj.common_name,
# obj.country,
# obj.state,
# obj.locality,
# obj.organization,
# )
#
# if obj.OU:
# subj += '/organizationalUnitName=%s' % obj.OU
#
# if obj.email:
# subj += '/emailAddress=%s' % obj.email
#
# return subj
#
# Path: pki/settings.py
# PKI_OPENSSL_BIN = getattr(settings, 'PKI_OPENSSL_BIN', '/usr/bin/openssl')
#
# PKI_OPENSSL_CONF = getattr(settings, 'PKI_OPENSSL_CONF', os.path.join(PKI_DIR, 'openssl.conf'))
#
# PKI_DIR = getattr(settings, 'PKI_DIR', os.path.join(PKI_APP_DIR, 'PKI'))
#
# PKI_OPENSSL_TEMPLATE = getattr(settings, 'PKI_OPENSSL_TEMPLATE', 'pki/openssl.conf.in')
#
# PKI_SELF_SIGNED_SERIAL = getattr(settings, 'PKI_SELF_SIGNED_SERIAL', 0x0)
#
# PKI_CA_NAME_BLACKLIST = ('_SELF_SIGNED_CERTIFICATES',)
. Output only the next line. | def refresh_pki_metadata(ca_list): |
Here is a snippet: <|code_start|>
try:
# available in python-2.5 and greater
except ImportError:
# compatibility fallback
logger = getLogger("pki")
<|code_end|>
. Write the next line using the current file imports:
import os
import re
import string
import random
import pki.models
from subprocess import Popen, PIPE, STDOUT
from shutil import rmtree
from logging import getLogger
from django.template.loader import render_to_string
from pki.helper import subject_for_object
from pki.settings import PKI_OPENSSL_BIN, PKI_OPENSSL_CONF, PKI_DIR, PKI_OPENSSL_TEMPLATE, \
PKI_SELF_SIGNED_SERIAL, PKI_CA_NAME_BLACKLIST
from hashlib import md5 as md5_constructor
from md5 import new as md5_constructor
and context from other files:
# Path: pki/helper.py
# def subject_for_object(obj):
# """Return a subject string.
#
# A OpenSSL compatible subject string is returned.
# """
#
# subj = '/CN=%s/C=%s/ST=%s/localityName=%s/O=%s' % ( obj.common_name,
# obj.country,
# obj.state,
# obj.locality,
# obj.organization,
# )
#
# if obj.OU:
# subj += '/organizationalUnitName=%s' % obj.OU
#
# if obj.email:
# subj += '/emailAddress=%s' % obj.email
#
# return subj
#
# Path: pki/settings.py
# PKI_OPENSSL_BIN = getattr(settings, 'PKI_OPENSSL_BIN', '/usr/bin/openssl')
#
# PKI_OPENSSL_CONF = getattr(settings, 'PKI_OPENSSL_CONF', os.path.join(PKI_DIR, 'openssl.conf'))
#
# PKI_DIR = getattr(settings, 'PKI_DIR', os.path.join(PKI_APP_DIR, 'PKI'))
#
# PKI_OPENSSL_TEMPLATE = getattr(settings, 'PKI_OPENSSL_TEMPLATE', 'pki/openssl.conf.in')
#
# PKI_SELF_SIGNED_SERIAL = getattr(settings, 'PKI_SELF_SIGNED_SERIAL', 0x0)
#
# PKI_CA_NAME_BLACKLIST = ('_SELF_SIGNED_CERTIFICATES',)
, which may include functions, classes, or code. Output only the next line. | def refresh_pki_metadata(ca_list): |
Given the code snippet: <|code_start|>#Save the available component classes names defined in CL. This are the classes
#defined in pyoptools.raytrace.comp_lib
_av_comp=[]
#for cl in dir(CL):
# if cl[0].isupper():
# _av_comp.append(cl)
# Replace the check for something more robust than checking if the firs character
# is a capital letter.
for cl in dir(CL):
c=getattr(CL,cl)
if not inspect.isclass(c):
continue
if issubclass(c,(Component,System)):
_av_comp.append(cl)
################################################################################
#Class to manage component libraries libraries
class Library:
def __init__(self, filename, libname=None):
self.parser=cp.ConfigParser()
self.parser.read(filename)
if libname != None:
globals()[libname]=self
def get(self, cmp):
global _av_comp
assert self.parser.has_section(cmp), "Library error in component %s, type not defined"%(cmp,)
<|code_end|>
, generate the next line using the imports in this file:
import six
import inspect
import pyoptools.raytrace.comp_lib as CL
import numpy as np
from six.moves import configparser as cp
from six.moves import reduce
from os import listdir, walk
from os.path import join, split, isdir, splitext,basename, expanduser
from numpy import sqrt
from pkg_resources import resource_stream, resource_filename, \
resource_string, resource_listdir
from pyoptools.raytrace.mat_lib import get_material
from pyoptools.raytrace.system.system import System
from pyoptools.raytrace.component.component import Component
from struct import Struct
and context (functions, classes, or occasionally code) from other files:
# Path: pyoptools/raytrace/mat_lib/material.py
# def get_material(material):
# """Search for a material in all the libraries
#
# This function search in all the material libraries, and return the
# first instance found, that matches the name of the material requested.
# If no material found, returns None
# Arguments:
#
# material
# String with the material name
# """
# for libn, _ in liblist:
# tdict=globals()[libn]
# if material in tdict:
# return tdict[material]
# print (material, " not found")
# raise KeyError
. Output only the next line. | type=self.parser.get(cmp,"type") |
Using the snippet: <|code_start|>
class Job(models.Model):
SCHEDULED = 0
QUEUED = 1
FINISHED = 2
FAILED = 3
STARTED = 4
FLOW = 5
STATUS_CHOICES = (
(SCHEDULED, 'scheduled'),
(QUEUED, 'queued'),
(FINISHED, 'finished'),
(FAILED, 'failed'),
(STARTED, 'started'),
(FLOW, 'flow'),
)
uuid = models.CharField(max_length=64, null=True, blank=True)
connection = None
created_at = models.DateTimeField()
origin = models.CharField(max_length=254, null=True, blank=True)
queue = models.ForeignKey('Queue', null=True, blank=True)
instance = PickledObjectField(null=True, blank=True)
func_name = models.CharField(max_length=254)
args = PickledObjectField(blank=True)
kwargs = PickledObjectField(blank=True)
description = models.CharField(max_length=254)
result_ttl = models.IntegerField(null=True, blank=True)
<|code_end|>
, determine the next line of code. You have imports:
import importlib
import inspect
from datetime import timedelta, datetime
from dateutil.relativedelta import relativedelta, weekday
from dateutil.relativedelta import weekdays as wdays
from picklefield.fields import PickledObjectField
from django.db import models
from django.db import transaction
from django.utils.timezone import now
from six import get_method_self, integer_types
from .exceptions import InvalidInterval
and context (class names, function names, or code) available:
# Path: pq/exceptions.py
# class InvalidInterval(Exception):
# pass
. Output only the next line. | status = models.PositiveIntegerField(null=True, |
Given snippet: <|code_start|> if name is None:
name = 'Stranger'
return 'Hi there, %s!' % (name,)
def do_nothing():
"""The best job in the world."""
pass
def div_by_zero(x):
"""Prepare for a division-by-zero exception."""
return x / 0
def some_calculation(x, y, z=1):
"""Some arbitrary calculation with three numbers. Choose z smartly if you
want a division by zero exception.
"""
return x * y / z
def create_file(path):
"""Creates a file at the given path. Actually, leaves evidence that the
job ran."""
with open(path, 'w') as f:
f.write('Just a sentinel.')
def create_file_after_timeout(path, timeout):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import time
from pq.decorators import job
and context:
# Path: pq/decorators.py
# class job(object):
#
# def __init__(self, queue, connection='default', timeout=None,
# result_ttl=PQ_DEFAULT_RESULT_TTL):
# """A decorator that adds a ``delay`` method to the decorated function,
# which in turn creates a RQ job when called. Accepts a required
# ``queue`` argument that can be either a ``Queue`` instance or a string
# denoting the queue name. For example:
#
# @job(queue='default')
# def simple_add(x, y):
# return x + y
#
# simple_add.delay(1, 2) # Puts simple_add function into queue
# """
# self.queue = queue
# self.connection = connection
# self.timeout = timeout
# self.result_ttl = result_ttl
#
# def __call__(self, f):
# @wraps(f)
# def delay(*args, **kwargs):
# if isinstance(self.queue, string_types):
# queue = Queue.create(name=self.queue, connection=self.connection)
# else:
# queue = self.queue
# return queue.enqueue_call(f, args=args, kwargs=kwargs,
# timeout=self.timeout, result_ttl=self.result_ttl)
# f.delay = delay
# return f
which might include code, classes, or functions. Output only the next line. | time.sleep(timeout) |
Continue the code snippet: <|code_start|>
class TestGetRestrictedDatetime(unittest.TestCase):
def setUp(self):
self.dt = datetime(2013, 1, 1, 6, tzinfo=utc)
@params(
('0-24', datetime(2013,1,1,6, tzinfo=utc)),
('1.30 - 5.30', datetime(2013,1,2,1,30, tzinfo=utc)),
<|code_end|>
. Use current file imports:
import unittest
from datetime import datetime
from django.utils.timezone import utc
from nose2.tools import params
from dateutil.relativedelta import weekdays
from pq.utils import get_restricted_datetime
from pq.exceptions import InvalidWeekdays
and context (classes, functions, or code) from other files:
# Path: pq/utils.py
# def get_restricted_datetime(at, between='', weekdays=None):
# """
# Returns a new datetime that always falls in
# the timerange ``between`` an iso 8601 string or variant,
# and days where days is a list or tuple of relativedelta weekday
# objects.
#
# If the time part of the datetime falls before the
# timerange the datetime will be moved forward to the
# start of the range. In the event the time is after the
# range the datetime will be moved forward to the next
# day.
#
# >>> dt = datetime(2013,1,1,6,30)
# >>> get_restricted_datetime(dt, '7-12')
# datetime(2013,1,1,7)
# >>> get_restricted_datetime(dt, '1:00/6:00')
# datetime(2013,1,2,1)
# >>> get_restricted_datetime(dt, '1:00-6:00')
# datetime(2013,1,2,1)
# >>> get_restricted_datetime(dt, '1:00:10/6:00:59')
# datetime(2013,1,2,1)
# """
# if between:
# pattern = re.compile(
# r"(\d{1,2})[:.]?(\d{0,2})[:.]?\d{0,2}\s*[/-]+" +
# r"\s*(\d{1,2})[:.]?(\d{0,2})[:.]?\d{0,2}"
# )
# r = pattern.search(between)
# if not r:
# raise InvalidBetween("Invalid between range %s" % between)
#
# shour, smin, ehour, emin = r.groups()
# shour = int(shour)
# smin = int(smin) if smin else 0
# ehour = int(ehour)
# emin = int(emin) if emin else 0
# if ehour < shour:
# raise InvalidBetween("Between end cannot be before start")
# elif ehour == 24:
# ehour = 23
# emin = 59
# st = time(shour, smin, tzinfo=at.tzinfo)
# et = time(ehour, emin, tzinfo=at.tzinfo)
# date = at.date()
# compare_st = datetime.combine(date, st)
# compare_et = datetime.combine(date, et)
# if at < compare_st:
# at = compare_st
# elif at > compare_et:
# at = compare_st + timedelta(days=1)
# if weekdays:
# weekdays = list(weekdays)
# for i, value in enumerate(weekdays):
# if isinstance(value, relativedelta.weekday):
# weekdays[i] = value.weekday
# elif isinstance(value, integer_types) and value >=0 and value <=6:
# continue
# else:
# msg = "Invalid weekday %s. Weekdays must be a" % str(value)
# msg = ' '.join([msg, "list or tuple of relativedelta.weekday",
# "instances or integers between 0 and 6"])
# raise InvalidWeekdays(msg)
# weekdays = sorted(weekdays)
# nextdays = relativedelta.weekdays[at.weekday():]
# priordays = relativedelta.weekdays[:at.weekday()]
# for i, day in enumerate(nextdays + priordays):
# if day.weekday in weekdays:
# at += timedelta(days=i)
# break
# return at
#
# Path: pq/exceptions.py
# class InvalidWeekdays(Exception):
# pass
. Output only the next line. | ('7:00-8:00', datetime(2013,1,1,7,0, tzinfo=utc)), |
Based on the snippet: <|code_start|>
class TestGetRestrictedDatetime(unittest.TestCase):
def setUp(self):
self.dt = datetime(2013, 1, 1, 6, tzinfo=utc)
@params(
('0-24', datetime(2013,1,1,6, tzinfo=utc)),
('1.30 - 5.30', datetime(2013,1,2,1,30, tzinfo=utc)),
<|code_end|>
, predict the immediate next line with the help of imports:
import unittest
from datetime import datetime
from django.utils.timezone import utc
from nose2.tools import params
from dateutil.relativedelta import weekdays
from pq.utils import get_restricted_datetime
from pq.exceptions import InvalidWeekdays
and context (classes, functions, sometimes code) from other files:
# Path: pq/utils.py
# def get_restricted_datetime(at, between='', weekdays=None):
# """
# Returns a new datetime that always falls in
# the timerange ``between`` an iso 8601 string or variant,
# and days where days is a list or tuple of relativedelta weekday
# objects.
#
# If the time part of the datetime falls before the
# timerange the datetime will be moved forward to the
# start of the range. In the event the time is after the
# range the datetime will be moved forward to the next
# day.
#
# >>> dt = datetime(2013,1,1,6,30)
# >>> get_restricted_datetime(dt, '7-12')
# datetime(2013,1,1,7)
# >>> get_restricted_datetime(dt, '1:00/6:00')
# datetime(2013,1,2,1)
# >>> get_restricted_datetime(dt, '1:00-6:00')
# datetime(2013,1,2,1)
# >>> get_restricted_datetime(dt, '1:00:10/6:00:59')
# datetime(2013,1,2,1)
# """
# if between:
# pattern = re.compile(
# r"(\d{1,2})[:.]?(\d{0,2})[:.]?\d{0,2}\s*[/-]+" +
# r"\s*(\d{1,2})[:.]?(\d{0,2})[:.]?\d{0,2}"
# )
# r = pattern.search(between)
# if not r:
# raise InvalidBetween("Invalid between range %s" % between)
#
# shour, smin, ehour, emin = r.groups()
# shour = int(shour)
# smin = int(smin) if smin else 0
# ehour = int(ehour)
# emin = int(emin) if emin else 0
# if ehour < shour:
# raise InvalidBetween("Between end cannot be before start")
# elif ehour == 24:
# ehour = 23
# emin = 59
# st = time(shour, smin, tzinfo=at.tzinfo)
# et = time(ehour, emin, tzinfo=at.tzinfo)
# date = at.date()
# compare_st = datetime.combine(date, st)
# compare_et = datetime.combine(date, et)
# if at < compare_st:
# at = compare_st
# elif at > compare_et:
# at = compare_st + timedelta(days=1)
# if weekdays:
# weekdays = list(weekdays)
# for i, value in enumerate(weekdays):
# if isinstance(value, relativedelta.weekday):
# weekdays[i] = value.weekday
# elif isinstance(value, integer_types) and value >=0 and value <=6:
# continue
# else:
# msg = "Invalid weekday %s. Weekdays must be a" % str(value)
# msg = ' '.join([msg, "list or tuple of relativedelta.weekday",
# "instances or integers between 0 and 6"])
# raise InvalidWeekdays(msg)
# weekdays = sorted(weekdays)
# nextdays = relativedelta.weekdays[at.weekday():]
# priordays = relativedelta.weekdays[:at.weekday()]
# for i, day in enumerate(nextdays + priordays):
# if day.weekday in weekdays:
# at += timedelta(days=i)
# break
# return at
#
# Path: pq/exceptions.py
# class InvalidWeekdays(Exception):
# pass
. Output only the next line. | ('7:00-8:00', datetime(2013,1,1,7,0, tzinfo=utc)), |
Given the following code snippet before the placeholder: <|code_start|>try:
except ImportError: # not 2.6+ or is 3.x
try:
except ImportError:
<|code_end|>
, predict the next line using imports from the current file:
from itertools import tee
from future_builtins import zip
from itertools import izip as zip
from bx.intervals.intersection import Intersecter, Interval
from .diffevent import DiffEvent, EventCollection
from IPython import embed
import requests
and context including class names, function names, and sometimes code from other files:
# Path: genda/transcripts/diffevent.py
# class DiffEvent(object):
# """A differential splicing event between
# two or more transcripts
#
# Arguments
# ---------
# event_type : ['skipped_exon', 'mxe', 'A5SE', 'ATS', 'AFE']
# event_type
# start : start position of differential event
# end : end position of differential event
# transcript_id :
# chrom : optional
# exon_num : exon number
# cigar1 : the cigar tuple generated across an event
# cigar2 : the cigar tuple generated across the other transcript
# event
# """
# def __init__(self, event_type, start, end,
# transcript_ids, cigar1=None, cigar2=None,
# chrom=None,
# exon_num=None, exon2 = None, exons = None):
# self.event_type = event_type
# self.start = start
# self.end = end
# # Change to list
# # Make this less chunky
# self.tid = transcript_ids
# self.exon_num = exon_num
# self.chrom = chrom
# self.cigar1 = cigar1
# self.cigar2 = cigar2
# self.exon2 = exon2
# self.exons = exons
#
# def __repr__(self):
# return(str(self.start) + '-' + str(self.end) +\
# ':' + str(self.cigar1) + ':' + str(self.cigar2))
#
# def __eq__(self, other):
# if self.start == other.start and\
# (self.end == other.end) and\
# ((self.cigar1 == other.cigar1) |\
# (self.cigar1 == other.cigar2)) and\
# self.cigar2 in [other.cigar1, other.cigar2]:
# return(True)
# else:
# return(False)
#
# def _extend(self, new_cigar, cig=1):
# """Extends a diffevent for example
# a mutual exclusive exon or two skipped
# exons and other complex events
# """
# old_cig = getattr(self, 'cigar{0!s}'.format(cig))
# old_cig.extend(new_cigar)
# setattr(self, 'cigar{0!s}'.format(cig), old_cig)
#
# def add_transcript(self, transcripts=[]):
# """ Add other transcript pairs that share
# the same differential event
# """
# raise NotImplementedError
#
#
# def cig_to_string(self):
# raise NotImplementedError
#
#
# def calc_size_norm(self):
# """ Calculate rough normalization factor
# """
# if self.event_type == 'skipped_exon':
# return()
#
# class EventCollection(object):
# """ A collection of diffevents
#
# Arguments
# ---------
# events : a list of genda.transcripts.DiffEvents
# transcript_ids : a list of transcripts tested
# """
# equivalent_events = {
# 'SE' : 'skipped_exon',
# 'AS' : 'alternative_start',
# 'MXE' : 'mutually_exclusive_exon',
# }
#
# def __init__(self, events, transcript_ids = None):
# self.events = events
# self.transcript_ids = transcript_ids
#
# def __getitem__(self, key):
# return(self.events[key])
#
# def __len__(self):
# return(len(self.events))
#
# def filter(self, event_type):
# out_events = []
# for i in self.events:
# if i.event_type == event_type or\
# i.event_type == self.equivalent_events[event_type]:
# out_events.append(i)
# return(out_events)
#
# def collapse(self):
# """ Collapses overlapping events
# """
# raise NotImplemented
. Output only the next line. | pass |
Given the code snippet: <|code_start|>log = logging.getLogger("safecity.tropo.views")
KEYWORDS = {
'JOIN': ['join', 'register'],
'UPDATE': ['update', 'change'],
'QUIT': ['quit', 'leave'],
<|code_end|>
, generate the next line using the imports in this file:
from datetime import datetime
from safecity.apps.danger.models import Report
from safecity.apps.locate.location_parser import *
from safecity.apps.signup.models import Resident
from safecity.apps.tropo.tropolib import *
from safecity.lib.messages import *
import logging
and context (functions, classes, or occasionally code) from other files:
# Path: safecity/apps/danger/models.py
# class Report(models.Model):
# """
# Processed data for messages that are reporting suspicious activity.
#
# TODO: support multi-part messages.
# """
# location = models.PointField(
# spatial_index=True,
# help_text='Location extracted from the report.')
#
# text = models.CharField(
# max_length=160,
# help_text='Body of the message.')
#
# sender = models.CharField(
# max_length=16,
# null=True,
# help_text='Phone number of the reporter in e164 format. None if anonymized.')
#
# received = models.DateTimeField(
# auto_now_add=True,
# help_text='Date and time this message was received. Approximate if anonymized.')
#
# objects = models.GeoManager()
#
# class Meta:
# ordering = ['-received']
# get_latest_by = 'received'
#
# def find_nearby_residents(self):
# """
# Get a list of residents near this report.
# """
# return Resident.objects.filter(location__distance_lte=(self.location, D(km=1)))
#
# Path: safecity/apps/signup/models.py
# class Resident(models.Model):
# """
# Individuals who want to receive alerts when activity happens near them.
#
# Privacy notes:
# 1) The text used to register the resident is intentionally not associated with them.
# 2) Created/updated times are not maintained so that any potentially sensitive information
# in their messages can never be associated with them.
# 3) Residents are DELETED when a request is made to deregister them.
# """
# phone_number = models.CharField(
# primary_key=True,
# max_length=16,
# help_text='Phone number this resident registered with in e164 format.')
#
# location = models.PointField(
# spatial_index=True,
# help_text='Location extracted from request message.')
#
# objects = models.GeoManager()
#
# def __unicode__(self):
# return self.phone_number
. Output only the next line. | } |
Given snippet: <|code_start|>log = logging.getLogger("safecity.locate.vet_skip_words")
class Command(NoArgsCommand):
title = 'locate.vet_skip_words'
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import csv
import logging
import os
import re
from optparse import make_option
from django.conf import settings
from django.core.management.base import NoArgsCommand, CommandError
from safecity.apps.locate.location_parser import strip_punctuation, WHITESPACE_REGEX
from safecity.apps.locate.models import *
from safecity.apps.tropo.views import KEYWORDS
and context:
# Path: safecity/apps/locate/location_parser.py
# def strip_punctuation(text):
# return PUNCTUATION_REGEX.sub(' ', text)
#
# WHITESPACE_REGEX = re.compile('\s+')
#
# Path: safecity/apps/tropo/views.py
# KEYWORDS = {
# 'JOIN': ['join', 'register'],
# 'UPDATE': ['update', 'change'],
# 'QUIT': ['quit', 'leave'],
# }
which might include code, classes, or functions. Output only the next line. | help = 'Verify that no skip_words are road names or other keywords.' |
Here is a snippet: <|code_start|> alias_type='CA'
)
alias.roads.add(road)
log.info('Loading alias tables.')
id_name_mapping = {}
reader = csv.DictReader(open(ROADS_CSV, 'r'))
for row in reader:
id_name_mapping[row['Street_ID']] = row['Street Name']
reader = csv.DictReader(open(ALIASES_CSV, 'r'))
for row in reader:
canonical_name = id_name_mapping[row['Base_Street_ID']]
alias_type = ALIAS_TYPES[row['Alias Type']]
alias_name = self.format_alias_name(row['Street Name'])
try:
canonical_alias = RoadAlias.objects.get(
name=canonical_name,
alias_type='CA'
)
except RoadAlias.DoesNotExist:
log.debug('Skipping alias for "%s"--no such road.' % canonical_name)
continue
<|code_end|>
. Write the next line using the current file imports:
import csv
import logging
import os
from optparse import make_option
from django.conf import settings
from django.core.management.base import NoArgsCommand, CommandError
from safecity.apps.locate.location_parser import strip_punctuation, WHITESPACE_REGEX
from safecity.apps.locate.models import *
and context from other files:
# Path: safecity/apps/locate/location_parser.py
# def strip_punctuation(text):
# return PUNCTUATION_REGEX.sub(' ', text)
#
# WHITESPACE_REGEX = re.compile('\s+')
, which may include functions, classes, or code. Output only the next line. | try: |
Based on the snippet: <|code_start|>log = logging.getLogger("safecity.locate.load_aliases")
ROADS_CSV = 'data/streets/names.csv'
ALIASES_CSV = 'data/streets/aliases.csv'
ALIAS_TYPES = {
'ALIAS': 'AL',
'HONORARY': 'HN',
'911': 'EM',
'NAMING_CONV': 'NC',
}
class Command(NoArgsCommand):
title = 'locate.load_centerline'
help = 'Import road alias data into the database using the Django models.'
option_list = NoArgsCommand.option_list + (
make_option('-c', '--clear', action='store_true', dest='clear',
help='Clear all centerline data from the DB.'),
<|code_end|>
, predict the immediate next line with the help of imports:
import csv
import logging
import os
from optparse import make_option
from django.conf import settings
from django.core.management.base import NoArgsCommand, CommandError
from safecity.apps.locate.location_parser import strip_punctuation, WHITESPACE_REGEX
from safecity.apps.locate.models import *
and context (classes, functions, sometimes code) from other files:
# Path: safecity/apps/locate/location_parser.py
# def strip_punctuation(text):
# return PUNCTUATION_REGEX.sub(' ', text)
#
# WHITESPACE_REGEX = re.compile('\s+')
. Output only the next line. | ) |
Given snippet: <|code_start|>
urlpatterns = patterns('',
url('^$',
views.mock,
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.conf.urls.defaults import *
from safecity.apps.mock import views
and context:
# Path: safecity/apps/mock/views.py
# class MockIncomingMessage(IncomingMessage):
# def __init__(self, sender, text, received):
# def respond(self, text):
# def forward(self, recipients):
# def mock(request):
# def mock_sms_ajax(request):
which might include code, classes, or functions. Output only the next line. | name='mock'), |
Here is a snippet: <|code_start|>
urlpatterns = patterns('',
url('^$',
views.index,
name='public_index'),
<|code_end|>
. Write the next line using the current file imports:
from django.conf.urls.defaults import *
from safecity.apps.public import views
and context from other files:
# Path: safecity/apps/public/views.py
# def index(request):
, which may include functions, classes, or code. Output only the next line. | ) |
Next line prediction: <|code_start|>
urlpatterns = patterns('',
url('^incoming/',
views.incoming,
<|code_end|>
. Use current file imports:
(from django.conf.urls.defaults import *
from safecity.apps.tropo import views)
and context including class names, function names, or small code snippets from other files:
# Path: safecity/apps/tropo/views.py
# KEYWORDS = {
# 'JOIN': ['join', 'register'],
# 'UPDATE': ['update', 'change'],
# 'QUIT': ['quit', 'leave'],
# }
# def incoming(request):
# def process_message(message):
# def process_join(message):
# def process_quit(message):
# def process_update(message):
# def process_report(message):
. Output only the next line. | name='tropo_incoming'), |
Given snippet: <|code_start|> self.reconnect_wait_time = self.MAX_WAIT_TIME
def __reset_wait_time(self):
self.reconnect_wait_time = self.STARTING_WAIT_TIME
def __run(self):
while self.running:
if not self.connected:
if not self.last_connect_attempt or time.time() - self.last_connect_attempt > self.reconnect_wait_time:
try:
self.last_connect_attempt = time.time()
self.packet_layer.connect(*self.connect_args, **self.connect_kwargs)
self.connected = True
except IOError:
echo_colorized_warning('Could not connect, will reattempt.')
try:
self.packet_layer.close()
except IOError:
pass
self.__increment_wait_time()
else:
time.sleep(1)
else:
io_occured = False
# lets attempt to read in a packet
try:
read_packet = self.packet_layer.read()
self.__reset_wait_time()
if read_packet:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import threading
import time
import cachetools
from apex.aprs import util as aprs_util
from .util import echo_colorized_frame
from .util import echo_colorized_warning
and context:
# Path: src/apex/util.py
# def echo_colorized_frame(frame, port_name, direction_in):
# formatted_aprs = '>'.join([click.style(frame['source'], fg='green'), click.style(frame['destination'], fg='blue')])
# paths = []
# for path in frame['path']:
# paths.append(click.style(path, fg='cyan'))
# paths = ','.join(paths)
# if frame['path']:
# formatted_aprs = ','.join([formatted_aprs, paths])
# formatted_aprs += ':'
# formatted_aprs += frame['text']
# if direction_in:
# click.echo(click.style(port_name + ' << ', fg='magenta') + formatted_aprs)
# else:
# click.echo(click.style(port_name + ' >> ', fg='magenta', bold=True, blink=True) + formatted_aprs)
#
# Path: src/apex/util.py
# def echo_colorized_warning(text):
# click.echo(click.style('Warning: ', fg='yellow') + click.style(text))
which might include code, classes, or functions. Output only the next line. | with self.lock: |
Next line prediction: <|code_start|> io_occured = True
except IOError:
echo_colorized_warning('Read failed. Will disconnect and attempt to reconnect.')
try:
self.packet_layer.close()
except IOError:
pass
self.connected = False
continue
# lets try to write a packet, if any are waiting.
write_packet = None
with self.lock:
if self.to_packet_layer:
write_packet = self.to_packet_layer.popitem()[1]
if write_packet:
try:
self.packet_layer.write(write_packet)
io_occured = True
self.__reset_wait_time()
except IOError:
echo_colorized_warning('Write failed. Will disconnect and attempt to reconnect.')
self.to_packet_layer[str(aprs_util.hash_frame(read_packet))] = write_packet
try:
self.packet_layer.close()
except IOError:
pass
self.connected = False
continue
<|code_end|>
. Use current file imports:
(import threading
import time
import cachetools
from apex.aprs import util as aprs_util
from .util import echo_colorized_frame
from .util import echo_colorized_warning)
and context including class names, function names, or small code snippets from other files:
# Path: src/apex/util.py
# def echo_colorized_frame(frame, port_name, direction_in):
# formatted_aprs = '>'.join([click.style(frame['source'], fg='green'), click.style(frame['destination'], fg='blue')])
# paths = []
# for path in frame['path']:
# paths.append(click.style(path, fg='cyan'))
# paths = ','.join(paths)
# if frame['path']:
# formatted_aprs = ','.join([formatted_aprs, paths])
# formatted_aprs += ':'
# formatted_aprs += frame['text']
# if direction_in:
# click.echo(click.style(port_name + ' << ', fg='magenta') + formatted_aprs)
# else:
# click.echo(click.style(port_name + ' >> ', fg='magenta', bold=True, blink=True) + formatted_aprs)
#
# Path: src/apex/util.py
# def echo_colorized_warning(text):
# click.echo(click.style('Warning: ', fg='yellow') + click.style(text))
. Output only the next line. | if not io_occured: |
Given snippet: <|code_start|> print('\n')
for num in list:
print(str(num))
def printFeatures(featureset):
for list in badext.docExtract():
print('\n')
for num in list:
print(str(num))
printFeatures(badext.docExtract())
docList = []
loadedDocList = []
os.listdir('./datasets/C50train/AaronPressman/')
def loadAuthorDocs(authordir):
for doc in os.listdir(authordir):
with open(doc) as openeddoc:
loadedDocList.append(openneddoc.read())
def loadAuthorDocs(authordir):
for doc in os.listdir(authordir):
with open(doc) as openeddoc:
loadedDocList.append(openneddoc.read())
def loadAuthorDocs(authordir):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from unstyle.dochandler import DocumentExtractor
from unstyle.featuresets import basic9
from unstyle.featuresets.basic9 import Basic9Extractor
import os
import numpy as np
and context:
# Path: unstyle/dochandler.py
# class DocumentExtractor:
#
# """A class that performs feature extraction on a given set of documents.
#
# :param feat_extractor: An instance of a feature extractor (e.g. the Basic-9
# feature set, or writeprints. Any class implementing FeatureSetExtractor
# should work.)
# :param docs: An arbitrary number of documents (strings of text).
#
# Example:
# >>>from unstyle.featuresets.basic9 import Basic9Extractor
# >>>d = DocumentExtractor(Basic9Extractor(), ["text of document 1", "text of
# document 2"])
# >>>d.docExtract()
# """
#
# def __init__(self, feat_extractor, docs):
# self.documents = docs
# self.featureSet = feat_extractor
#
# if self.documents is None:
# raise TypeError
#
# def docExtract(self):
# """Extract features from each document. Return it as a matrix of (number of
# docs) by (number of features)."""
#
# self.fv = []
# for doc in self.documents:
# self.fv.append(self.featureSet.extract(doc))
#
# # Convert to a numpy matrix.
# return np.array(np.asmatrix(self.fv))
# # return self.fv
#
# Path: unstyle/featuresets/basic9.py
# class Basic9Extractor(FeatureSetExtractor):
# def __init__(self):
#
# Path: unstyle/featuresets/basic9.py
# class Basic9Extractor(FeatureSetExtractor):
#
# """The Basic-9 feature set extractor.[1]
#
# [1] Michael Brennan and Rachel Greenstadt. Practical Attacks Against Authorship
# Recognition Techniques in Proceedings of the Twenty-First Conference on
# Innovative Applications of Artificial Intelligence (IAAI), Pasadena, California,
# July 2009.
# """
#
# def __init__(self):
# self.features = [
# "letterSpace",
# "gunningFog",
# "avgSyllablesPerWord",
# "unique_words",
# "sentenceCount",
# "characterSpace",
# "avgSentenceLength",
# "complexity",
# "fleschReadingEase"
# ]
which might include code, classes, or functions. Output only the next line. | documents = [] |
Given the following code snippet before the placeholder: <|code_start|>d.documents
lynneDocs
with open("./datasets/C50train/LynneO'Donnell/116963") as lynne:
lynneDocs = lynne.read()
with open("./datasets/C50train/LynneO'Donnell/116963newsML.txt") as lynne:
lynneDocs = lynne.read()
lynneDocs
d = DocumentExtractor(Basic9Extractor(), [lynneDocs, "This is another test."])
d.documents
d.docExtract()
with open("./datasets/C50train/WilliamKazer/101226newsML.txt") as williamk:
williambad = williamk.read()
williambad
badext1 = DocumentExtractor(Basic9Extractor(), williambad)
badext1.docExtract()
# for num in badext1.docExtract()"
for num in badext1.docExtract():
print(num)
williamk
williambad
badext1 = DocumentExtractor(Basic9Extractor(), [williambad])
badext1.docExtract()
for num in badext1.docExtract():
print(num)
for num in badext1.docExtract():
<|code_end|>
, predict the next line using imports from the current file:
from unstyle.dochandler import DocumentExtractor
from unstyle.featuresets import basic9
from unstyle.featuresets.basic9 import Basic9Extractor
import os
import numpy as np
and context including class names, function names, and sometimes code from other files:
# Path: unstyle/dochandler.py
# class DocumentExtractor:
#
# """A class that performs feature extraction on a given set of documents.
#
# :param feat_extractor: An instance of a feature extractor (e.g. the Basic-9
# feature set, or writeprints. Any class implementing FeatureSetExtractor
# should work.)
# :param docs: An arbitrary number of documents (strings of text).
#
# Example:
# >>>from unstyle.featuresets.basic9 import Basic9Extractor
# >>>d = DocumentExtractor(Basic9Extractor(), ["text of document 1", "text of
# document 2"])
# >>>d.docExtract()
# """
#
# def __init__(self, feat_extractor, docs):
# self.documents = docs
# self.featureSet = feat_extractor
#
# if self.documents is None:
# raise TypeError
#
# def docExtract(self):
# """Extract features from each document. Return it as a matrix of (number of
# docs) by (number of features)."""
#
# self.fv = []
# for doc in self.documents:
# self.fv.append(self.featureSet.extract(doc))
#
# # Convert to a numpy matrix.
# return np.array(np.asmatrix(self.fv))
# # return self.fv
#
# Path: unstyle/featuresets/basic9.py
# class Basic9Extractor(FeatureSetExtractor):
# def __init__(self):
#
# Path: unstyle/featuresets/basic9.py
# class Basic9Extractor(FeatureSetExtractor):
#
# """The Basic-9 feature set extractor.[1]
#
# [1] Michael Brennan and Rachel Greenstadt. Practical Attacks Against Authorship
# Recognition Techniques in Proceedings of the Twenty-First Conference on
# Innovative Applications of Artificial Intelligence (IAAI), Pasadena, California,
# July 2009.
# """
#
# def __init__(self):
# self.features = [
# "letterSpace",
# "gunningFog",
# "avgSyllablesPerWord",
# "unique_words",
# "sentenceCount",
# "characterSpace",
# "avgSentenceLength",
# "complexity",
# "fleschReadingEase"
# ]
. Output only the next line. | for char in num: |
Predict the next line after this snippet: <|code_start|> print(n)
#print(str(clf.score(preprocessing.scale(testvecs), testlabels) * 100) + "% score on this dataset.")
testvecsscaled = preprocessing.scale(testvecs)
# Cross-validation
print("Computing cross validation...")
cvIterations = 7
scores = cross_validation.cross_val_score(clf, extracted, labels,
cv=cvIterations)
print("Accuracy by " + str(cvIterations) + "-fold CV: %0.2f (+/- %0.2f)" %
(scores.mean(), scores.std() * 2))
def plot_confusion_matrix(cm, title='Confusion matrix', cmap=plt.cm.Blues):
plt.imshow(cm, interpolation='nearest', cmap=cmap)
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(authorSet))
plt.xticks(tick_marks, list(authorSet), rotation=45)
plt.yticks(tick_marks, list(authorSet))
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
y_pred = clf.predict(testvecsscaled)
print("Predictions: ", y_pred)
cm = confusion_matrix(labels, y_pred)
cm_normalized = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
np.set_printoptions(precision=2)
plt.figure()
<|code_end|>
using the current file's imports:
from unstyle.dochandler import DocumentExtractor
from unstyle.featuresets.basic9 import Basic9Extractor
from sklearn import svm
from sklearn import preprocessing
from sklearn import cross_validation
from sklearn.grid_search import GridSearchCV
from sklearn.feature_selection import chi2, SelectKBest
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report
from sklearn.cross_validation import train_test_split
import codecs
import numpy as np
import matplotlib.pyplot as plt
and any relevant context from other files:
# Path: unstyle/dochandler.py
# class DocumentExtractor:
#
# """A class that performs feature extraction on a given set of documents.
#
# :param feat_extractor: An instance of a feature extractor (e.g. the Basic-9
# feature set, or writeprints. Any class implementing FeatureSetExtractor
# should work.)
# :param docs: An arbitrary number of documents (strings of text).
#
# Example:
# >>>from unstyle.featuresets.basic9 import Basic9Extractor
# >>>d = DocumentExtractor(Basic9Extractor(), ["text of document 1", "text of
# document 2"])
# >>>d.docExtract()
# """
#
# def __init__(self, feat_extractor, docs):
# self.documents = docs
# self.featureSet = feat_extractor
#
# if self.documents is None:
# raise TypeError
#
# def docExtract(self):
# """Extract features from each document. Return it as a matrix of (number of
# docs) by (number of features)."""
#
# self.fv = []
# for doc in self.documents:
# self.fv.append(self.featureSet.extract(doc))
#
# # Convert to a numpy matrix.
# return np.array(np.asmatrix(self.fv))
# # return self.fv
#
# Path: unstyle/featuresets/basic9.py
# class Basic9Extractor(FeatureSetExtractor):
#
# """The Basic-9 feature set extractor.[1]
#
# [1] Michael Brennan and Rachel Greenstadt. Practical Attacks Against Authorship
# Recognition Techniques in Proceedings of the Twenty-First Conference on
# Innovative Applications of Artificial Intelligence (IAAI), Pasadena, California,
# July 2009.
# """
#
# def __init__(self):
# self.features = [
# "letterSpace",
# "gunningFog",
# "avgSyllablesPerWord",
# "unique_words",
# "sentenceCount",
# "characterSpace",
# "avgSentenceLength",
# "complexity",
# "fleschReadingEase"
# ]
. Output only the next line. | plot_confusion_matrix(cm) |
Given snippet: <|code_start|>
# scale our feature vectors to make them suitable for SVM input
print("Scaling feature vectors...")
extracted = preprocessing.scale(extracted)
# instantiate classifier and train it
print("Instantiating classifier...")
clf = svm.SVC(probability=True, kernel='linear', class_weight='auto')
print("Fitting dataset to classifier...")
clf.fit(extracted, labels)
# do some predictions, again with test vectors scaled
print("Computing predictions...")
normalizedpredic = clf.predict(preprocessing.scale(testvecs))
# compute number of authors
authorSet = set()
for label in labels:
authorSet.add(label)
print("Comparing authors:")
for n in authorSet:
print(n)
#print(str(clf.score(preprocessing.scale(testvecs), testlabels) * 100) + "% score on this dataset.")
testvecsscaled = preprocessing.scale(testvecs)
# Cross-validation
print("Computing cross validation...")
cvIterations = 7
scores = cross_validation.cross_val_score(clf, extracted, labels,
cv=cvIterations)
print("Accuracy by " + str(cvIterations) + "-fold CV: %0.2f (+/- %0.2f)" %
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from unstyle.dochandler import DocumentExtractor
from unstyle.featuresets.basic9 import Basic9Extractor
from sklearn import svm
from sklearn import preprocessing
from sklearn import cross_validation
from sklearn.grid_search import GridSearchCV
from sklearn.feature_selection import chi2, SelectKBest
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report
from sklearn.cross_validation import train_test_split
import codecs
import numpy as np
import matplotlib.pyplot as plt
and context:
# Path: unstyle/dochandler.py
# class DocumentExtractor:
#
# """A class that performs feature extraction on a given set of documents.
#
# :param feat_extractor: An instance of a feature extractor (e.g. the Basic-9
# feature set, or writeprints. Any class implementing FeatureSetExtractor
# should work.)
# :param docs: An arbitrary number of documents (strings of text).
#
# Example:
# >>>from unstyle.featuresets.basic9 import Basic9Extractor
# >>>d = DocumentExtractor(Basic9Extractor(), ["text of document 1", "text of
# document 2"])
# >>>d.docExtract()
# """
#
# def __init__(self, feat_extractor, docs):
# self.documents = docs
# self.featureSet = feat_extractor
#
# if self.documents is None:
# raise TypeError
#
# def docExtract(self):
# """Extract features from each document. Return it as a matrix of (number of
# docs) by (number of features)."""
#
# self.fv = []
# for doc in self.documents:
# self.fv.append(self.featureSet.extract(doc))
#
# # Convert to a numpy matrix.
# return np.array(np.asmatrix(self.fv))
# # return self.fv
#
# Path: unstyle/featuresets/basic9.py
# class Basic9Extractor(FeatureSetExtractor):
#
# """The Basic-9 feature set extractor.[1]
#
# [1] Michael Brennan and Rachel Greenstadt. Practical Attacks Against Authorship
# Recognition Techniques in Proceedings of the Twenty-First Conference on
# Innovative Applications of Artificial Intelligence (IAAI), Pasadena, California,
# July 2009.
# """
#
# def __init__(self):
# self.features = [
# "letterSpace",
# "gunningFog",
# "avgSyllablesPerWord",
# "unique_words",
# "sentenceCount",
# "characterSpace",
# "avgSentenceLength",
# "complexity",
# "fleschReadingEase"
# ]
which might include code, classes, or functions. Output only the next line. | (scores.mean(), scores.std() * 2)) |
Next line prediction: <|code_start|> return self._server.password_grant(account_ident, credentials, scope)
class Server(object):
def __init__(self, dao=None):
self._dao = dao
def register_client(self, client_id, **kwds):
if self._dao.has_client_id(client_id):
raise RegisterError('client_id have been registered.')
else:
client_data = kwds.copy()
client_data['client_id'] = client_id
self._dao.insert_client(client_data)
def register_account(self, account):
identity = account.get('username', None)
if self._dao.has_username(identity):
raise RegisterError('username had been registered')
else:
uid = self._dao.insert_account(account)
return uid
def authorization_request(self, account_ident, client_id, redirect_uri=None, scope=None):
if self._dao.has_client_id(client_id):
authorization_code_data = {
'code': rndgen(),
'issue_time': datetime.datetime.utcnow(),
'expires_in': 300,
'disabled': False,
'account_ident': account_ident,
<|code_end|>
. Use current file imports:
(import datetime
import re
from uuid import uuid4
from base64 import b32encode
from .exception import RegisterError, AuthorizationError
from urlparse import urlparse
from urllib.parse import urlparse)
and context including class names, function names, or small code snippets from other files:
# Path: huacaya/auth/exception.py
# class RegisterError(Exception):
# pass
#
# class AuthorizationError(Exception):
# pass
. Output only the next line. | 'redirect_uri': redirect_uri, |
Predict the next line after this snippet: <|code_start|> def has_authorization_code(self, authorization_code):
return authorization_code in self._codes
def insert_authorization_code(self, authorization_code):
self._codes.put_object(authorization_code['code'], authorization_code)
def has_token(self, token):
return token in self._tokens
def find_account_by_token(self, token):
account_id = self._tokens.get_object(token).get('account_ident')
return self._accounts.get_object(account_id)
def find_account(self, data):
for account_id in self._accounts:
if set(data.items()).issubset(self._accounts[account_id].items()):
return self._accounts[account_id]
return None
def get_account_by_id(self, account_id):
return self._accounts.get_object(account_id)
def update_token(self, token, param):
token_data = self._tokens.get_object(token)
token_data.update(param)
self._tokens.put_object(token, token_data)
def get_authorization_code(self, authorization_code):
return self._codes.get_object(authorization_code) if authorization_code in self._codes else None
<|code_end|>
using the current file's imports:
import datetime
import re
from uuid import uuid4
from base64 import b32encode
from .exception import RegisterError, AuthorizationError
from urlparse import urlparse
from urllib.parse import urlparse
and any relevant context from other files:
# Path: huacaya/auth/exception.py
# class RegisterError(Exception):
# pass
#
# class AuthorizationError(Exception):
# pass
. Output only the next line. | def update_authorization_code(self, authorization_code, param): |
Based on the snippet: <|code_start|># -*- coding: utf-8 -*-
__author__ = 'chinfeng'
try:
except ImportError:
logger = logging.getLogger(__name__)
def json_default(obj):
if isinstance(obj, datetime.datetime):
return str(obj)
else:
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import uuid
import json
import datetime
import tornado.web
import logging
from tornado.web import HTTPError
from tornado.escape import json_decode
from urllib import urlencode
from urlparse import urlsplit, urlunsplit
from urllib.parse import urlencode, urlsplit, urlunsplit
from .auth import AuthorizationError
and context (classes, functions, sometimes code) from other files:
# Path: huacaya/auth/auth.py
# class Provider(object):
# class Server(object):
# class ServerDaoWithStorage(object):
# def __init__(self, server):
# def authorization_request(self, account_ident, client_id, redirect_uri=None, scope=None):
# def verify_authorization_code(self, authorization_code):
# def authorization_code_grant(self, authorization_code, client_id, redirect_uri=None):
# def verify_token(self, token):
# def verify_scope(self, access_token, scope):
# def refresh_token_grant(self, refresh_token):
# def implicit_grant(self, account_ident, client_id, redirect_uri=None, scope=None):
# def password_grant(self, account_ident, credentials, scope=None):
# def __init__(self, dao=None):
# def register_client(self, client_id, **kwds):
# def register_account(self, account):
# def authorization_request(self, account_ident, client_id, redirect_uri=None, scope=None):
# def authorization_code_grant(self, authorization_code, client_id=None, redirect_uri=None):
# def verify_authorization_code(self, authorization_code):
# def verify_token(self, token):
# def verify_scope(self, access_token, scope):
# def refresh_token_grant(self, refresh_token):
# def implicit_grant(self, account_ident, client_id, redirect_uri=None, scope=None):
# def password_grant(self, account_ident, credentials, scope=None):
# def revoke_authorization_code(self, authorization_code):
# def revoke_token(self, token):
# def _redirect_uri_identical(self, auth_redirect_uri, acc_redirect_url):
# def has_client_id(self, client_id):
# def get_accounts(self):
# def get_tokens(self):
# def get_clients(self):
# def find_account(self, credentials):
# def get_account_by_token(self, token):
# def __init__(self, storage):
# def _clients(self):
# def _tokens(self):
# def _accounts(self):
# def _codes(self):
# def has_client_id(self, client_id):
# def insert_client(self, client_data):
# def has_username(self, username):
# def insert_account(self, account):
# def has_authorization_code(self, authorization_code):
# def insert_authorization_code(self, authorization_code):
# def has_token(self, token):
# def find_account_by_token(self, token):
# def find_account(self, data):
# def get_account_by_id(self, account_id):
# def update_token(self, token, param):
# def get_authorization_code(self, authorization_code):
# def update_authorization_code(self, authorization_code, param):
# def insert_token(self, token_data):
# def get_token(self, token):
# def get_accounts(self):
# def get_tokens(self):
# def get_clients(self):
. Output only the next line. | return obj |
Here is a snippet: <|code_start|>
def send(self, *args, **kwargs):
for e in self._events:
e.call(*args, **kwargs)
class _EventManager(object):
def __init__(self, owner):
self._owner = owner
def __getattr__(self, key):
return _EventProxy(
(e for e in (self._owner.events() or set()) if e.name == key)
)
def __getitem__(self, item):
return self.__getattr__(item)
class Requirement(object):
def __init__(self, instance, fn, service_names, service_dict):
self._instance = instance
self._fn = fn
self._service_names = service_names
self._service_dict = service_dict
def __call__(self, *args, **kwargs):
ctx = self._instance.__context__
_args = list(args)
_kwargs = kwargs.copy()
<|code_end|>
. Write the next line using the current file imports:
import zipfile
import os
import functools
import itertools
import zipimport
import threading
import collections
import ConfigParser as configparser
import configparser
import types
import logging
from queue import Queue
from Queue import Queue
from importlib import reload
from imp import reload
from importlib.machinery import SourceFileLoader
from imp import load_source
from importlib import import_module
from .configuration import LocalConfiguration
from .executor import Executor
from inspect import isgeneratorfunction
and context from other files:
# Path: gumpy/configuration.py
# class LocalConfiguration(Configuration):
# def __init__(self, path=None):
# if path and os.path.isdir(path):
# self._dir = os.path.abspath(path)
# else:
# self._dir = None
# self._docs = {}
#
# def __getattr__(self, key):
# if key in self._docs:
# return self._docs[key]
#
# if self._dir:
# fn = os.path.join(self._dir, key)
# self._docs[key] = _LocalDocument(fn)
# else:
# self._docs[key] = _LocalDocument()
# return self._docs[key]
#
# def __getitem__(self, item):
# return self.__getattr__(item)
#
# def __del__(self):
# self.close()
#
# def close(self):
# for doc in self._docs.values():
# doc.close()
#
# def persist(self):
# for doc in self._docs.values():
# doc.persist()
#
# def reload(self):
# if self._dir:
# for key in self._docs:
# fn = os.path.join(self._dir, key)
# self._docs[key] = _LocalDocument(fn)
# else:
# for key in self._docs:
# self._docs[key] = _LocalDocument()
#
# Path: gumpy/executor.py
# class Executor(object):
# def __init__(self):
# self._task_deque = deque()
# self._lock = Lock()
# self._thread_ident = None
# self._closed = False
#
# def _step(self):
# try:
# future, gen = self._task_deque.popleft()
# future.consume_result(next(gen))
# self._task_deque.append((future, gen))
# return True
# except StopIteration:
# future.set_done()
# return True
# except IndexError:
# return False
# except BaseException as err:
# logger.exception(err)
# future.set_exception(err)
# return True
#
# def loop(self, forever=False):
# with self._lock:
# if not self._thread_ident:
# self._thread_ident = current_thread().ident
# if self._thread_ident != current_thread().ident:
# # ensure same thread for loop
# raise ThreadError('Executor.loop for one thread only.')
# while (self._step() or forever) and (not self._closed):
# pass
#
# self._thread_ident = None
#
# def close(self):
# self._closed = True
#
# def call(self, fn):
# return self.call_posterior(fn)
#
# def call_prior(self, fn):
# future = Future(self)
# self._task_deque.appendleft((future, _gen(fn)))
# return future
#
# def call_posterior(self, fn):
# future = Future(self)
# self._task_deque.append((future, _gen(fn)))
# return future
, which may include functions, classes, or code. Output only the next line. | for sn in self._service_names: |
Given the code snippet: <|code_start|>
class Activator(_Callable):
def __init__(self, func):
super(self.__class__, self).__init__(func)
class Deactivator(_Callable):
def __init__(self, func):
super(self.__class__, self).__init__(func)
class Task(object):
def __init__(self, fn, instance):
self._fn = fn
self._instance = instance
def __call__(self, *args, **kwargs):
method = types.MethodType(self._fn, self._instance)
if isgeneratorfunction(method):
for n in method(*args, **kwargs):
yield n
else:
yield method(*args, **kwargs)
def spawn(self, *args, **kwargs):
method = types.MethodType(self._fn, self._instance)
if hasattr(self._instance, '__executor__'):
extr = self._instance.__executor__
else:
extr = kwargs.pop('__executor__', None)
<|code_end|>
, generate the next line using the imports in this file:
import zipfile
import os
import functools
import itertools
import zipimport
import threading
import collections
import ConfigParser as configparser
import configparser
import types
import logging
from queue import Queue
from Queue import Queue
from importlib import reload
from imp import reload
from importlib.machinery import SourceFileLoader
from imp import load_source
from importlib import import_module
from .configuration import LocalConfiguration
from .executor import Executor
from inspect import isgeneratorfunction
and context (functions, classes, or occasionally code) from other files:
# Path: gumpy/configuration.py
# class LocalConfiguration(Configuration):
# def __init__(self, path=None):
# if path and os.path.isdir(path):
# self._dir = os.path.abspath(path)
# else:
# self._dir = None
# self._docs = {}
#
# def __getattr__(self, key):
# if key in self._docs:
# return self._docs[key]
#
# if self._dir:
# fn = os.path.join(self._dir, key)
# self._docs[key] = _LocalDocument(fn)
# else:
# self._docs[key] = _LocalDocument()
# return self._docs[key]
#
# def __getitem__(self, item):
# return self.__getattr__(item)
#
# def __del__(self):
# self.close()
#
# def close(self):
# for doc in self._docs.values():
# doc.close()
#
# def persist(self):
# for doc in self._docs.values():
# doc.persist()
#
# def reload(self):
# if self._dir:
# for key in self._docs:
# fn = os.path.join(self._dir, key)
# self._docs[key] = _LocalDocument(fn)
# else:
# for key in self._docs:
# self._docs[key] = _LocalDocument()
#
# Path: gumpy/executor.py
# class Executor(object):
# def __init__(self):
# self._task_deque = deque()
# self._lock = Lock()
# self._thread_ident = None
# self._closed = False
#
# def _step(self):
# try:
# future, gen = self._task_deque.popleft()
# future.consume_result(next(gen))
# self._task_deque.append((future, gen))
# return True
# except StopIteration:
# future.set_done()
# return True
# except IndexError:
# return False
# except BaseException as err:
# logger.exception(err)
# future.set_exception(err)
# return True
#
# def loop(self, forever=False):
# with self._lock:
# if not self._thread_ident:
# self._thread_ident = current_thread().ident
# if self._thread_ident != current_thread().ident:
# # ensure same thread for loop
# raise ThreadError('Executor.loop for one thread only.')
# while (self._step() or forever) and (not self._closed):
# pass
#
# self._thread_ident = None
#
# def close(self):
# self._closed = True
#
# def call(self, fn):
# return self.call_posterior(fn)
#
# def call_prior(self, fn):
# future = Future(self)
# self._task_deque.appendleft((future, _gen(fn)))
# return future
#
# def call_posterior(self, fn):
# future = Future(self)
# self._task_deque.append((future, _gen(fn)))
# return future
. Output only the next line. | if extr: |
Given the following code snippet before the placeholder: <|code_start|># -*- coding: utf-8 -*-
__author__ = 'chinfeng'
try:
except ImportError:
class OAuthTestCase(WSGITestCase):
def get_app(self):
<|code_end|>
, predict the next line using imports from the current file:
import uuid
from urlparse import urlparse, parse_qs
from urllib import urlencode
from urllib.parse import urlparse, parse_qs, urlencode
from tests.wsgi import WSGITestCase
from huacaya.auth import Server, Provider, ServerDaoWithStorage
from huacaya.auth import EndpointApplication
from huacaya.storage import StorageService
from tornado.wsgi import WSGIAdapter
from huacaya.auth import RegisterError, InvalidTokenError, AuthorizationError
and context including class names, function names, and sometimes code from other files:
# Path: tests/wsgi.py
# class WSGITestCase(unittest.TestCase):
# def __init__(self, *args, **kwds):
# unittest.TestCase.__init__(self, *args, **kwds)
# self._cookie_jar = CookieJar()
# app = self.get_app()
# validator(app)
# self._port = random.randint(50000, 60000)
# self._httpd = make_server('', self._port, app)
# self._serve_thread = threading.Thread(target=self._httpd.serve_forever)
# self._serve_thread.setDaemon(True)
# self._opener = build_opener(NoRedirectionProcessor, HTTPCookieProcessor(self._cookie_jar))
#
# def setUp(self):
# self._serve_thread.start()
#
# def tearDown(self):
# self._httpd.shutdown()
# self._serve_thread.join()
#
# def get_app(self):
# raise NotImplementedError
#
# def reset(self):
# self._cookie_jar = CookieJar()
# self._opener = build_opener(NoRedirectionProcessor, HTTPCookieProcessor(self._cookie_jar))
#
# def request(self, url, method=None, data=None, headers=None):
# headers = headers or {}
# method = method or 'GET'
#
# if isinstance(data, dict):
# for k, v in headers.items():
# if k.lower().startswith('content-type') and v.lower().startswith('application/json'):
# data = json.dumps(data).encode('utf-8') if isinstance(data, dict) else data
# method = 'POST'
# break
# else:
# if method == 'GET':
# headers = {}
# url = '?'.join((url, urlencode(data)))
# data = None
# else:
# headers['Content-Type'] = 'application/x-www-form-urlencoded'
# data = urlencode(data).encode('utf-8')
#
# request = Request('http://localhost:%d%s' % (self._port, url), data=data, headers=headers)
# if method.upper() not in ('GET', 'POST'):
# request.get_method = lambda m=method: m
# response = self._opener.open(request)
#
# try:
# # for py3
# charset = response.headers.get_param('charset')
# except AttributeError:
# # for py2
# charset = response.headers.getparam('charset')
# response.body = response.read().decode(charset)
# response.charset = charset
# if response.headers.get('content-type').startswith('application/json'):
# response.dct = json.loads(response.body)
# else:
# response.dct = {}
# response.status = '%d %s' % (response.code, response.msg)
# return response
. Output only the next line. | self._storage = StorageService() |
Given the code snippet: <|code_start|>
def __iter__(self):
for doc in self._collection.find(fields={'key': True, '_id': False}):
yield doc['key']
def keys(self):
return list(self)
class MongoStorage(StorageBase):
def __init__(self, db):
self._db = db
def get_bucket(self, name):
try:
self._db.validate_collection(name)
return MongoBucket(self._db[name])
except OperationFailure:
return MongoBucket(self._db.create_collection(name))
def __getitem__(self, item):
return self.get_bucket(item)
def delete(self, bucket):
if isinstance(bucket, str):
return self._db.drop_collection(bucket)
elif isinstance(bucket, MongoBucket):
return self._db.drop_collection(bucket.name)
else:
raise KeyError('No such bucket: {0}'.format(bucket))
<|code_end|>
, generate the next line using the imports in this file:
from .base import BucketBase, StorageBase
from pymongo.errors import OperationFailure
and context (functions, classes, or occasionally code) from other files:
# Path: huacaya/storage/base.py
# class BucketBase(object):
# def drop(self):
# raise NotImplementedError
#
# def put(self, entity):
# raise NotImplementedError
#
# def get(self, stub):
# raise NotImplementedError
#
# def delete(self, stub):
# raise NotImplementedError
#
# def update(self, entity):
# raise NotImplementedError
#
# def __contains__(self, item):
# raise NotImplementedError
#
# def __getitem__(self, item):
# return self.get(item)
#
# class StorageBase(object):
# def create_bucket(self, name, index=()):
# raise NotImplementedError
#
# def get_bucket(self, name):
# raise NotImplementedError
#
# def drop(self, bucket):
# raise NotImplementedError
#
# def __contains__(self, item):
# raise NotImplementedError
#
# def __getitem__(self, item):
# return self.get_bucket(item)
. Output only the next line. | def __contains__(self, item): |
Given snippet: <|code_start|> if obj:
return obj['content']
def delete_object(self, key):
self._collection.remove({'key': key})
def find(self, fields):
find_fields = {'content.%s' % k: v for k, v in fields.items()}
for doc in self._collection.find(find_fields):
yield doc
def find_one(self, fields):
find_fields = {'content.%s' % k: v for k, v in fields.items()}
return self._collection.find_one(find_fields)
def __getitem__(self, item):
return self.get_object(item)
def __contains__(self, item):
return self._collection.find({'key': item}).count() > 0
def __iter__(self):
for doc in self._collection.find(fields={'key': True, '_id': False}):
yield doc['key']
def keys(self):
return list(self)
class MongoStorage(StorageBase):
def __init__(self, db):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import BucketBase, StorageBase
from pymongo.errors import OperationFailure
and context:
# Path: huacaya/storage/base.py
# class BucketBase(object):
# def drop(self):
# raise NotImplementedError
#
# def put(self, entity):
# raise NotImplementedError
#
# def get(self, stub):
# raise NotImplementedError
#
# def delete(self, stub):
# raise NotImplementedError
#
# def update(self, entity):
# raise NotImplementedError
#
# def __contains__(self, item):
# raise NotImplementedError
#
# def __getitem__(self, item):
# return self.get(item)
#
# class StorageBase(object):
# def create_bucket(self, name, index=()):
# raise NotImplementedError
#
# def get_bucket(self, name):
# raise NotImplementedError
#
# def drop(self, bucket):
# raise NotImplementedError
#
# def __contains__(self, item):
# raise NotImplementedError
#
# def __getitem__(self, item):
# return self.get_bucket(item)
which might include code, classes, or functions. Output only the next line. | self._db = db |
Predict the next line after this snippet: <|code_start|># -*- coding: utf-8 -*-
__author__ = 'chinfeng'
logger = logging.getLogger(__name__)
class GumTestCase(TestCase):
def setUp(self):
logging.basicConfig(level=logging.DEBUG, format='[%(asctime)-15s %(levelname)s:%(module)s] %(message)s')
fmk = default_framework()
fmk.install_bundle('samples.mod_bdl')
fmk.install_bundle('samples.pkg_bdl')
fmk.install_bundle(os.path.join(os.path.dirname(samples.__file__), 'file_bdl.py'))
fmk.install_bundle(os.path.join(os.path.dirname(samples.__file__), 'zip_bdl.zip'))
fmk.__executor__.loop()
<|code_end|>
using the current file's imports:
from unittest import TestCase
from gumpy import default_framework
import os
import threading
import samples
import logging
and any relevant context from other files:
# Path: gumpy/framework.py
# def async(func):
# def _async_callable(instance, *args, **kwargs):
# def service_uri(uri, pwd_level=_SERVICE_LEVEL):
# def __init__(self, subject, **metadata):
# def __call__(self, *args, **kwargs):
# def nesting(self):
# def nested(self):
# def root_nesting(self):
# def subject(self):
# def metadata(self):
# def _other_metadata_items(self, annotation=None):
# def __init__(self, subject, name=None):
# def subject(self):
# def __init__(self, cls, name=None, provides=None):
# def create(self, bundle):
# def __init__(self, func):
# def __call__(self, *args, **kwargs):
# def __init__(self, func):
# def __init__(self, func):
# def __init__(self, fn, instance):
# def __call__(self, *args, **kwargs):
# def spawn(self, *args, **kwargs):
# def __init__(self, instance, bind_fn, unbind_fn, resource_uri, cardinality):
# def bind(self, resource_reference):
# def unbind(self, resource_reference):
# def match(self, reference):
# def __reference__(self):
# def resource_uri(self):
# def is_satisfied(self):
# def is_filled(self):
# def __init__(self, instance, func):
# def call(self, *args, **kwargs):
# def name(self):
# def __init__(self, events=None):
# def send(self, *args, **kwargs):
# def __init__(self, owner):
# def __getattr__(self, key):
# def __getitem__(self, item):
# def __init__(self, instance, fn, service_names, service_dict):
# def __call__(self, *args, **kwargs):
# def check_satisfied(self, ctx):
# def __init__(self, bundle, cls, name=None, provides=None):
# def name(self):
# def provides(self):
# def cls(self):
# def consumers(self):
# def events(self):
# def is_avaliable(self):
# def is_satisfied(self):
# def __framework__(self):
# def __executor__(self):
# def start(self):
# def stop(self):
# def get_service(self):
# def check_requirement(self):
# def __init__(self, framework, uri):
# def __executor__(self):
# def path(self):
# def uri(self):
# def name(self):
# def state(self):
# def service_references(self):
# def __framework__(self):
# def configuration(self):
# def event_manager(self):
# def em(self):
# def events(self):
# def start(self):
# def stop(self):
# def get_service_reference(self, uri):
# def get_service_reference_by_name(self, name):
# def get_service(self, uri):
# def get(self, uri):
# def __init__(self, configuration=None, repo_path=None):
# def dismiss(self, producer):
# def digest(self, entry):
# def _digest_from_producer(self, producer):
# def _digest_from_consumer(self, consumer):
# def repo_path(self):
# def bundles(self):
# def configuration(self):
# def events(self):
# def event_manager(self):
# def em(self):
# def producers(self):
# def consumers(self):
# def get_bundle(self, uri, default=None):
# def get_repo_list(self):
# def install_bundle(self, uri):
# def install_bundles(self, tp_list):
# def get_service_reference(self, uri):
# def get_service(self, name):
# def get(self, uri):
# def restore_state(self):
# def _start_later(f, b):
# def stop(self):
# def terminate(self):
# def _save_status(self):
# def call(self, fn, *args, **kwargs):
# def __call__(self):
# _BUNDLE_LEVEL = 0
# _SERVICE_LEVEL = 1
# ST_INSTALLED = _immutable_prop((0, 'INSTALLED'))
# ST_RESOLVED = _immutable_prop((1, 'RESOLVED'))
# ST_STARTING = _immutable_prop((2, 'STARTING'))
# ST_ACTIVE = _immutable_prop((3, 'ACTIVE'))
# ST_STOPING = _immutable_prop((4, 'STOPING'))
# ST_UNINSTALLED = _immutable_prop((5, 'UNINSTALLED'))
# class BundleInstallError(RuntimeError):
# class BundleUnavailableError(RuntimeError):
# class BundleReloadError(RuntimeError):
# class ServiceUnavaliableError(RuntimeError):
# class Annotation(object):
# class ServiceAnnotation(Annotation):
# class ServiceReferenceFactory(object):
# class _Callable(object):
# class Activator(_Callable):
# class Deactivator(_Callable):
# class Task(object):
# class Consumer(object):
# class EventSlot(object):
# class _EventProxy(object):
# class _EventManager(object):
# class Requirement(object):
# class ServiceReference(object):
# class BundleContext(object):
# class Framework(object):
# class DefaultFrameworkSingleton(object):
. Output only the next line. | self._fmk = fmk |
Given snippet: <|code_start|> indexes VARCHAR
)
''')
def create_bucket(self, name, indexes=()):
# TODO
# CREATE BUCKET TABLE
cursor = self._sqlite_db.cursor()
if indexes:
cursor.execute(
'INSERT OR REPLACE INTO settings(bucket, indexes) VALUES(?, ?)',
(name, ','.join(indexes))
)
else:
indexes_val = cursor.execute(
'SELECT COALESCE((SELECT indexes FROM settings WHERE bucket=?), NULL)', (name, )
).fetchone()[0]
indexes = indexes_val.split(',') if indexes_val else ()
cursor.execute('''
CREATE TABLE IF NOT EXISTS {table}_entities (
id CHAR(32) PRIMARY KEY,
updated DATETIME NOT NULL,
body BLOB
)
'''.format(table=name))
cursor.execute('''
CREATE TABLE IF NOT EXISTS {table}_indexes (
index_name VARCHAR,
index_val VARCHAR,
entity_id CHAR(32),
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import uuid
import sqlite3
import datetime
import itertools
import cPickle as pickle
import pickle
from .base import StorageBase, BucketBase
and context:
# Path: huacaya/storage/base.py
# class StorageBase(object):
# def create_bucket(self, name, index=()):
# raise NotImplementedError
#
# def get_bucket(self, name):
# raise NotImplementedError
#
# def drop(self, bucket):
# raise NotImplementedError
#
# def __contains__(self, item):
# raise NotImplementedError
#
# def __getitem__(self, item):
# return self.get_bucket(item)
#
# class BucketBase(object):
# def drop(self):
# raise NotImplementedError
#
# def put(self, entity):
# raise NotImplementedError
#
# def get(self, stub):
# raise NotImplementedError
#
# def delete(self, stub):
# raise NotImplementedError
#
# def update(self, entity):
# raise NotImplementedError
#
# def __contains__(self, item):
# raise NotImplementedError
#
# def __getitem__(self, item):
# return self.get(item)
which might include code, classes, or functions. Output only the next line. | PRIMARY KEY (entity_id, index_name), |
Predict the next line after this snippet: <|code_start|> )
''')
def create_bucket(self, name, indexes=()):
# TODO
# CREATE BUCKET TABLE
cursor = self._sqlite_db.cursor()
if indexes:
cursor.execute(
'INSERT OR REPLACE INTO settings(bucket, indexes) VALUES(?, ?)',
(name, ','.join(indexes))
)
else:
indexes_val = cursor.execute(
'SELECT COALESCE((SELECT indexes FROM settings WHERE bucket=?), NULL)', (name, )
).fetchone()[0]
indexes = indexes_val.split(',') if indexes_val else ()
cursor.execute('''
CREATE TABLE IF NOT EXISTS {table}_entities (
id CHAR(32) PRIMARY KEY,
updated DATETIME NOT NULL,
body BLOB
)
'''.format(table=name))
cursor.execute('''
CREATE TABLE IF NOT EXISTS {table}_indexes (
index_name VARCHAR,
index_val VARCHAR,
entity_id CHAR(32),
PRIMARY KEY (entity_id, index_name),
<|code_end|>
using the current file's imports:
import uuid
import sqlite3
import datetime
import itertools
import cPickle as pickle
import pickle
from .base import StorageBase, BucketBase
and any relevant context from other files:
# Path: huacaya/storage/base.py
# class StorageBase(object):
# def create_bucket(self, name, index=()):
# raise NotImplementedError
#
# def get_bucket(self, name):
# raise NotImplementedError
#
# def drop(self, bucket):
# raise NotImplementedError
#
# def __contains__(self, item):
# raise NotImplementedError
#
# def __getitem__(self, item):
# return self.get_bucket(item)
#
# class BucketBase(object):
# def drop(self):
# raise NotImplementedError
#
# def put(self, entity):
# raise NotImplementedError
#
# def get(self, stub):
# raise NotImplementedError
#
# def delete(self, stub):
# raise NotImplementedError
#
# def update(self, entity):
# raise NotImplementedError
#
# def __contains__(self, item):
# raise NotImplementedError
#
# def __getitem__(self, item):
# return self.get(item)
. Output only the next line. | FOREIGN KEY (entity_id) REFERENCES {table}_entities(id) ON DELETE CASCADE |
Based on the snippet: <|code_start|> if isinstance(obj, bytes):
return {'__bytes__': base64.b64encode(obj).decode('ascii')}
else:
return super(self.__class__, self).default(obj)
class EnhancedJSONDecoder(json.JSONDecoder):
def __init__(self, *args, **kwargs):
json.JSONDecoder.__init__(self, *args, object_hook=self.object_hook, **kwargs)
def object_hook(self, dct):
if '__utctimestamp__' in dct:
return datetime.datetime.fromtimestamp(dct['__utctimestamp__'])
elif '__bytes__' in dct:
return base64.b64decode(dct['__bytes__'].encode('ascii'))
else:
return dct
def _dumps(dct):
return json.dumps(dct, cls=EnhancedJSONEncoder)
def _loads(raw):
return json.loads(raw, cls=EnhancedJSONDecoder)
class MockBucket(BucketBase):
def __init__(self, storage, db, name):
self._storage = storage
self._db = db
self._name = name
self._db.cursor().execute('''
CREATE TABLE IF NOT EXISTS {0} (
id INTEGER PRIMARY KEY AUTOINCREMENT,
<|code_end|>
, predict the immediate next line with the help of imports:
from .base import BucketBase, StorageBase
from time import mktime
import json
import datetime
import base64
import sqlite3
and context (classes, functions, sometimes code) from other files:
# Path: huacaya/storage/base.py
# class BucketBase(object):
# def drop(self):
# raise NotImplementedError
#
# def put(self, entity):
# raise NotImplementedError
#
# def get(self, stub):
# raise NotImplementedError
#
# def delete(self, stub):
# raise NotImplementedError
#
# def update(self, entity):
# raise NotImplementedError
#
# def __contains__(self, item):
# raise NotImplementedError
#
# def __getitem__(self, item):
# return self.get(item)
#
# class StorageBase(object):
# def create_bucket(self, name, index=()):
# raise NotImplementedError
#
# def get_bucket(self, name):
# raise NotImplementedError
#
# def drop(self, bucket):
# raise NotImplementedError
#
# def __contains__(self, item):
# raise NotImplementedError
#
# def __getitem__(self, item):
# return self.get_bucket(item)
. Output only the next line. | k VARCHAR UNIQUE, |
Based on the snippet: <|code_start|># -*- coding: utf-8 -*-
__author__ = 'chinfeng'
_singleton_storage = None
class EnhancedJSONEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, datetime.datetime):
return {'__utctimestamp__': mktime(obj.timetuple())}
if isinstance(obj, bytes):
return {'__bytes__': base64.b64encode(obj).decode('ascii')}
else:
return super(self.__class__, self).default(obj)
class EnhancedJSONDecoder(json.JSONDecoder):
def __init__(self, *args, **kwargs):
json.JSONDecoder.__init__(self, *args, object_hook=self.object_hook, **kwargs)
def object_hook(self, dct):
if '__utctimestamp__' in dct:
return datetime.datetime.fromtimestamp(dct['__utctimestamp__'])
elif '__bytes__' in dct:
return base64.b64decode(dct['__bytes__'].encode('ascii'))
else:
return dct
def _dumps(dct):
return json.dumps(dct, cls=EnhancedJSONEncoder)
def _loads(raw):
<|code_end|>
, predict the immediate next line with the help of imports:
from .base import BucketBase, StorageBase
from time import mktime
import json
import datetime
import base64
import sqlite3
and context (classes, functions, sometimes code) from other files:
# Path: huacaya/storage/base.py
# class BucketBase(object):
# def drop(self):
# raise NotImplementedError
#
# def put(self, entity):
# raise NotImplementedError
#
# def get(self, stub):
# raise NotImplementedError
#
# def delete(self, stub):
# raise NotImplementedError
#
# def update(self, entity):
# raise NotImplementedError
#
# def __contains__(self, item):
# raise NotImplementedError
#
# def __getitem__(self, item):
# return self.get(item)
#
# class StorageBase(object):
# def create_bucket(self, name, index=()):
# raise NotImplementedError
#
# def get_bucket(self, name):
# raise NotImplementedError
#
# def drop(self, bucket):
# raise NotImplementedError
#
# def __contains__(self, item):
# raise NotImplementedError
#
# def __getitem__(self, item):
# return self.get_bucket(item)
. Output only the next line. | return json.loads(raw, cls=EnhancedJSONDecoder) |
Given the following code snippet before the placeholder: <|code_start|>
@service
class WSGIService(object):
@configuration(rootapp='rootapp')
def __init__(self, rootapp):
self._apps = {}
self._server = None
self._rootapp = rootapp
self.start_wsgi_server()
@configuration(port=('port', 8001))
def start_wsgi_server(self, port):
try:
sc = functools.partial(ThreadPoolWSGIServer, 20)
self._server = wsgiref.simple_server.make_server(
'', port, self._wsgi_app, server_class=sc
)
self._server.serve_forever()
except BaseException as err:
err.args = ('tserv start fails.', ) + err.args
logger.exception(err)
def on_stop(self):
if self._server:
self._server.shutdown()
del self._server
@bind('tserv.application')
def application(self, app):
wsgiref.validate.validator(app)
<|code_end|>
, predict the next line using imports from the current file:
import multiprocessing.pool
import functools
import wsgiref.simple_server, wsgiref.util, wsgiref.validate
import logging
from gumpy.deco import service, configuration, bind, event
and context including class names, function names, and sometimes code from other files:
# Path: gumpy/deco.py
# class _RequirementHepler(object):
# class _ConsumerHelper(object):
# class _EventHepler(object):
# class activate(Annotation):
# class deactivate(Annotation):
# class _TaskHelper(object):
# def __init__(self, fn, args, kwargs):
# def __get__(self, instance, owner):
# def __init__(self, fn, resource_uri, cardinality):
# def __get__(self, instance, owner):
# def unbind(self, fn):
# def __init__(self, fn):
# def __get__(self, instance, owner):
# def configuration(**config_map):
# def deco(func):
# def configuration_injected_func(self, *args, **kwargs):
# def subject(self):
# def subject(self):
# def __init__(self, fn):
# def __get__(self, instance, owner):
. Output only the next line. | if hasattr(app, '__route__'): |
Given the following code snippet before the placeholder: <|code_start|>
def on_stop(self):
if self._server:
self._server.shutdown()
del self._server
@bind('tserv.application')
def application(self, app):
wsgiref.validate.validator(app)
if hasattr(app, '__route__'):
self._apps[app.__route__] = app
else:
self._apps[app.__class__.__name__] = app
@application.unbind
def application(self, app):
if hasattr(app, '__route__'):
del self._apps[app.__route__]
else:
del self._apps[app.__class__.__name__]
def _wsgi_app(self, environ, start_response):
if self._apps:
app_route = wsgiref.util.shift_path_info(environ)
if app_route in self._apps:
environ['SCRIPT_NAME'] = ''
return self._apps[app_route](environ, start_response)
elif self._rootapp:
return self._apps[self._rootapp](environ, start_response)
start_response('404 NOT FOUND', [('Content-type', 'text/plain'), ])
<|code_end|>
, predict the next line using imports from the current file:
import multiprocessing.pool
import functools
import wsgiref.simple_server, wsgiref.util, wsgiref.validate
import logging
from gumpy.deco import service, configuration, bind, event
and context including class names, function names, and sometimes code from other files:
# Path: gumpy/deco.py
# class _RequirementHepler(object):
# class _ConsumerHelper(object):
# class _EventHepler(object):
# class activate(Annotation):
# class deactivate(Annotation):
# class _TaskHelper(object):
# def __init__(self, fn, args, kwargs):
# def __get__(self, instance, owner):
# def __init__(self, fn, resource_uri, cardinality):
# def __get__(self, instance, owner):
# def unbind(self, fn):
# def __init__(self, fn):
# def __get__(self, instance, owner):
# def configuration(**config_map):
# def deco(func):
# def configuration_injected_func(self, *args, **kwargs):
# def subject(self):
# def subject(self):
# def __init__(self, fn):
# def __get__(self, instance, owner):
. Output only the next line. | return ['no application deployed'.encode('utf-8')] |
Continue the code snippet: <|code_start|> '', port, self._wsgi_app, server_class=sc
)
self._server.serve_forever()
except BaseException as err:
err.args = ('tserv start fails.', ) + err.args
logger.exception(err)
def on_stop(self):
if self._server:
self._server.shutdown()
del self._server
@bind('tserv.application')
def application(self, app):
wsgiref.validate.validator(app)
if hasattr(app, '__route__'):
self._apps[app.__route__] = app
else:
self._apps[app.__class__.__name__] = app
@application.unbind
def application(self, app):
if hasattr(app, '__route__'):
del self._apps[app.__route__]
else:
del self._apps[app.__class__.__name__]
def _wsgi_app(self, environ, start_response):
if self._apps:
app_route = wsgiref.util.shift_path_info(environ)
<|code_end|>
. Use current file imports:
import multiprocessing.pool
import functools
import wsgiref.simple_server, wsgiref.util, wsgiref.validate
import logging
from gumpy.deco import service, configuration, bind, event
and context (classes, functions, or code) from other files:
# Path: gumpy/deco.py
# class _RequirementHepler(object):
# class _ConsumerHelper(object):
# class _EventHepler(object):
# class activate(Annotation):
# class deactivate(Annotation):
# class _TaskHelper(object):
# def __init__(self, fn, args, kwargs):
# def __get__(self, instance, owner):
# def __init__(self, fn, resource_uri, cardinality):
# def __get__(self, instance, owner):
# def unbind(self, fn):
# def __init__(self, fn):
# def __get__(self, instance, owner):
# def configuration(**config_map):
# def deco(func):
# def configuration_injected_func(self, *args, **kwargs):
# def subject(self):
# def subject(self):
# def __init__(self, fn):
# def __get__(self, instance, owner):
. Output only the next line. | if app_route in self._apps: |
Given the following code snippet before the placeholder: <|code_start|>
def process_request(self, request, client_address):
self._pool.apply_async(self.process_request_worker, args=(request, client_address))
def serve_forever(self, *args, **kwds):
self._pool.apply_async(wsgiref.simple_server.WSGIServer.serve_forever, args=(self, ) + args, kwds=kwds)
def shutdown(self):
super(self.__class__, self).shutdown()
self._pool.terminate()
@service
class WSGIService(object):
@configuration(rootapp='rootapp')
def __init__(self, rootapp):
self._apps = {}
self._server = None
self._rootapp = rootapp
self.start_wsgi_server()
@configuration(port=('port', 8001))
def start_wsgi_server(self, port):
try:
sc = functools.partial(ThreadPoolWSGIServer, 20)
self._server = wsgiref.simple_server.make_server(
'', port, self._wsgi_app, server_class=sc
)
self._server.serve_forever()
except BaseException as err:
err.args = ('tserv start fails.', ) + err.args
<|code_end|>
, predict the next line using imports from the current file:
import multiprocessing.pool
import functools
import wsgiref.simple_server, wsgiref.util, wsgiref.validate
import logging
from gumpy.deco import service, configuration, bind, event
and context including class names, function names, and sometimes code from other files:
# Path: gumpy/deco.py
# class _RequirementHepler(object):
# class _ConsumerHelper(object):
# class _EventHepler(object):
# class activate(Annotation):
# class deactivate(Annotation):
# class _TaskHelper(object):
# def __init__(self, fn, args, kwargs):
# def __get__(self, instance, owner):
# def __init__(self, fn, resource_uri, cardinality):
# def __get__(self, instance, owner):
# def unbind(self, fn):
# def __init__(self, fn):
# def __get__(self, instance, owner):
# def configuration(**config_map):
# def deco(func):
# def configuration_injected_func(self, *args, **kwargs):
# def subject(self):
# def subject(self):
# def __init__(self, fn):
# def __get__(self, instance, owner):
. Output only the next line. | logger.exception(err) |
Predict the next line for this snippet: <|code_start|># -*- coding: utf-8 -*-
__author__ = 'chinfeng'
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write('Hello world!')
@service
@provide('tserv.application')
@provide('cserv.application')
class FirstApplication(tornado.wsgi.WSGIAdapter):
__route__ = 'firstapp'
def __init__(self):
super(self.__class__, self).__init__(
tornado.web.Application([
(r'/?', MainHandler),
<|code_end|>
with the help of current file imports:
from gumpy.deco import service, provide
import tornado.web
import tornado.wsgi
and context from other files:
# Path: gumpy/deco.py
# class _RequirementHepler(object):
# class _ConsumerHelper(object):
# class _EventHepler(object):
# class activate(Annotation):
# class deactivate(Annotation):
# class _TaskHelper(object):
# def __init__(self, fn, args, kwargs):
# def __get__(self, instance, owner):
# def __init__(self, fn, resource_uri, cardinality):
# def __get__(self, instance, owner):
# def unbind(self, fn):
# def __init__(self, fn):
# def __get__(self, instance, owner):
# def configuration(**config_map):
# def deco(func):
# def configuration_injected_func(self, *args, **kwargs):
# def subject(self):
# def subject(self):
# def __init__(self, fn):
# def __get__(self, instance, owner):
, which may contain function names, class names, or code. Output only the next line. | ]) |
Continue the code snippet: <|code_start|># -*- coding: utf-8 -*-
__author__ = 'chinfeng'
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write('Hello world!')
@service
@provide('tserv.application')
@provide('cserv.application')
class FirstApplication(tornado.wsgi.WSGIAdapter):
<|code_end|>
. Use current file imports:
from gumpy.deco import service, provide
import tornado.web
import tornado.wsgi
and context (classes, functions, or code) from other files:
# Path: gumpy/deco.py
# class _RequirementHepler(object):
# class _ConsumerHelper(object):
# class _EventHepler(object):
# class activate(Annotation):
# class deactivate(Annotation):
# class _TaskHelper(object):
# def __init__(self, fn, args, kwargs):
# def __get__(self, instance, owner):
# def __init__(self, fn, resource_uri, cardinality):
# def __get__(self, instance, owner):
# def unbind(self, fn):
# def __init__(self, fn):
# def __get__(self, instance, owner):
# def configuration(**config_map):
# def deco(func):
# def configuration_injected_func(self, *args, **kwargs):
# def subject(self):
# def subject(self):
# def __init__(self, fn):
# def __get__(self, instance, owner):
. Output only the next line. | __route__ = 'firstapp' |
Given snippet: <|code_start|> wsgiref.validate.validator(app)
if hasattr(app, '__route__'):
self._apps[app.__route__] = app
else:
self._apps[app.__class__.__name__] = app
@application.unbind
def application(self, app):
if hasattr(app, '__route__'):
del self._apps[app.__route__]
else:
del self._apps[app.__class__.__name__]
@bind('cserv.default.application', '0..1')
def default_application(self, app):
wsgiref.validate.validator(app)
self._default_app = app
@default_application.unbind
def application_default(self, app):
self._default_app = None
def _wsgi_app(self, environ, start_response):
if self._apps:
app_route = wsgiref.util.shift_path_info(environ)
if app_route in self._apps:
environ['SCRIPT_NAME'] = ''
return self._apps[app_route](environ, start_response)
elif self._default_app:
return self._default_app(environ, start_response)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import functools
import threading
import wsgiref.simple_server, wsgiref.util, wsgiref.validate
import logging
from gumpy.deco import service, configuration, bind, event
from util import HTTP_STATUS
and context:
# Path: gumpy/deco.py
# class _RequirementHepler(object):
# class _ConsumerHelper(object):
# class _EventHepler(object):
# class activate(Annotation):
# class deactivate(Annotation):
# class _TaskHelper(object):
# def __init__(self, fn, args, kwargs):
# def __get__(self, instance, owner):
# def __init__(self, fn, resource_uri, cardinality):
# def __get__(self, instance, owner):
# def unbind(self, fn):
# def __init__(self, fn):
# def __get__(self, instance, owner):
# def configuration(**config_map):
# def deco(func):
# def configuration_injected_func(self, *args, **kwargs):
# def subject(self):
# def subject(self):
# def __init__(self, fn):
# def __get__(self, instance, owner):
which might include code, classes, or functions. Output only the next line. | start_response(HTTP_STATUS(404), [('Content-Type', 'text/plain'), ]) |
Predict the next line for this snippet: <|code_start|> self._apps = {}
self._server = None
self._default_app = None
self.start_wsgi_server()
@configuration(port=('port', 8002))
def start_wsgi_server(self, port):
try:
sc = functools.partial(TaskPoolWSGIServer, self.__executor__)
self._server = wsgiref.simple_server.make_server(
'', port, self._wsgi_app, server_class=sc
)
t = threading.Thread(target=self._server.serve_forever)
t.setDaemon(True)
t.start()
except BaseException as err:
err.args = ('tserv start fails.', ) + err.args
logger.exception(err)
def on_stop(self):
if self._server:
self._server.shutdown()
del self._server
@bind('cserv.application')
def application(self, app):
wsgiref.validate.validator(app)
if hasattr(app, '__route__'):
self._apps[app.__route__] = app
<|code_end|>
with the help of current file imports:
import functools
import threading
import wsgiref.simple_server, wsgiref.util, wsgiref.validate
import logging
from gumpy.deco import service, configuration, bind, event
from util import HTTP_STATUS
and context from other files:
# Path: gumpy/deco.py
# class _RequirementHepler(object):
# class _ConsumerHelper(object):
# class _EventHepler(object):
# class activate(Annotation):
# class deactivate(Annotation):
# class _TaskHelper(object):
# def __init__(self, fn, args, kwargs):
# def __get__(self, instance, owner):
# def __init__(self, fn, resource_uri, cardinality):
# def __get__(self, instance, owner):
# def unbind(self, fn):
# def __init__(self, fn):
# def __get__(self, instance, owner):
# def configuration(**config_map):
# def deco(func):
# def configuration_injected_func(self, *args, **kwargs):
# def subject(self):
# def subject(self):
# def __init__(self, fn):
# def __get__(self, instance, owner):
, which may contain function names, class names, or code. Output only the next line. | else: |
Predict the next line for this snippet: <|code_start|>__author__ = 'chinfeng'
logger = logging.getLogger(__name__)
class TaskPoolWSGIServer(wsgiref.simple_server.WSGIServer):
def __init__(self, executor, *args, **kwds):
wsgiref.simple_server.WSGIServer.__init__(self, *args, **kwds)
self._executor = executor
def process_request_coroutine(self, request, client_address):
try:
self.finish_request(request, client_address)
self.shutdown_request(request)
except:
self.handle_error(request, client_address)
self.shutdown_request(request)
def process_request(self, request, client_address):
self._executor.call(functools.partial(self.process_request_coroutine, request, client_address))
@service
class WSGIService(object):
def __init__(self):
self._apps = {}
self._server = None
self._default_app = None
self.start_wsgi_server()
@configuration(port=('port', 8002))
<|code_end|>
with the help of current file imports:
import functools
import threading
import wsgiref.simple_server, wsgiref.util, wsgiref.validate
import logging
from gumpy.deco import service, configuration, bind, event
from util import HTTP_STATUS
and context from other files:
# Path: gumpy/deco.py
# class _RequirementHepler(object):
# class _ConsumerHelper(object):
# class _EventHepler(object):
# class activate(Annotation):
# class deactivate(Annotation):
# class _TaskHelper(object):
# def __init__(self, fn, args, kwargs):
# def __get__(self, instance, owner):
# def __init__(self, fn, resource_uri, cardinality):
# def __get__(self, instance, owner):
# def unbind(self, fn):
# def __init__(self, fn):
# def __get__(self, instance, owner):
# def configuration(**config_map):
# def deco(func):
# def configuration_injected_func(self, *args, **kwargs):
# def subject(self):
# def subject(self):
# def __init__(self, fn):
# def __get__(self, instance, owner):
, which may contain function names, class names, or code. Output only the next line. | def start_wsgi_server(self, port): |
Given snippet: <|code_start|># -*- coding: utf-8 -*-
__author__ = 'chinfeng'
logger = logging.getLogger(__name__)
class TaskPoolWSGIServer(wsgiref.simple_server.WSGIServer):
def __init__(self, executor, *args, **kwds):
wsgiref.simple_server.WSGIServer.__init__(self, *args, **kwds)
self._executor = executor
def process_request_coroutine(self, request, client_address):
try:
self.finish_request(request, client_address)
self.shutdown_request(request)
except:
self.handle_error(request, client_address)
self.shutdown_request(request)
def process_request(self, request, client_address):
self._executor.call(functools.partial(self.process_request_coroutine, request, client_address))
@service
class WSGIService(object):
def __init__(self):
self._apps = {}
self._server = None
self._default_app = None
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import functools
import threading
import wsgiref.simple_server, wsgiref.util, wsgiref.validate
import logging
from gumpy.deco import service, configuration, bind, event
from util import HTTP_STATUS
and context:
# Path: gumpy/deco.py
# class _RequirementHepler(object):
# class _ConsumerHelper(object):
# class _EventHepler(object):
# class activate(Annotation):
# class deactivate(Annotation):
# class _TaskHelper(object):
# def __init__(self, fn, args, kwargs):
# def __get__(self, instance, owner):
# def __init__(self, fn, resource_uri, cardinality):
# def __get__(self, instance, owner):
# def unbind(self, fn):
# def __init__(self, fn):
# def __get__(self, instance, owner):
# def configuration(**config_map):
# def deco(func):
# def configuration_injected_func(self, *args, **kwargs):
# def subject(self):
# def subject(self):
# def __init__(self, fn):
# def __get__(self, instance, owner):
which might include code, classes, or functions. Output only the next line. | self.start_wsgi_server() |
Given snippet: <|code_start|># -*- coding: utf-8 -*-
from __future__ import unicode_literals
my_vcr = VCR(
path_transformer=VCR.ensure_suffix(".yaml"),
cassette_library_dir="tests/cassettes/",
record_mode=pytest.config.getoption("--vcrmode"),
)
logging.basicConfig() # you need to initialize logging, otherwise you will not see anything from vcrpy
vcr_log = logging.getLogger("vcr")
vcr_log.setLevel(logging.DEBUG)
@pytest.fixture
def botmock():
bot = bot_mock.BotMock()
module_urltitle.init(bot)
return bot
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import logging
import bot_mock
import pytest
from nose.tools import eq_
from pyfibot.modules import module_urltitle
from utils import check_re
from vcr import VCR
and context:
# Path: pyfibot/modules/module_urltitle.py
# TITLE_LAG_MAXIMUM = 10
# CACHE_ENABLED = True
# CACHE_ENABLED = not CACHE_ENABLED
# def init(botref):
# def __get_bs(bot, url):
# def __get_title_tag(url):
# def __get_length_str(secs):
# def __get_age_str(published, use_fresh=True):
# def __get_views(views):
# def __escaped_fragment(url, meta=False):
# def command_cache(bot, user, channel, args):
# def handle_url(bot, user, channel, url, msg):
# def _check_redundant(url, title):
# def _levenshtein_distance(s, t):
# def _title(bot, channel, title, smart=False, prefix=None, url=None):
# def _parse_tweet_from_src(url):
# def _handle_mobile_tweet(url):
# def _handle_tweet2(url):
# def _handle_tweet(url):
# def twit_timestr(dt):
# def _handle_youtube_shorturl(url):
# def _handle_youtube_gdata(url):
# def _handle_ircquotes(url):
# def _handle_alko2(url):
# def _handle_alko(url):
# def _handle_vimeo(url):
# def _handle_stackoverflow(url):
# def _handle_reddit(url):
# def _handle_areena(url):
# def _parse_publication_events(data):
# def get_duration(event):
# def get_episode(identifier):
# def get_series(identifier):
# def _handle_wikipedia(url):
# def clean_page_name(url):
# def get_content(url):
# def _handle_imgur(url):
# def create_title(data):
# def _handle_dailymotion(url):
# def _handle_ebay(url):
# def _handle_ebay_no_prefix(url):
# def _handle_ebay_cgi(url):
# def _handle_dealextreme(url):
# def _handle_dealextreme_www(url):
# def fetch_nettiX(url, fields_to_fetch):
# def _handle_nettiauto(url):
# def _handle_nettivene(url):
# def _handle_nettimoto(url):
# def _handle_nettikaravaani(url):
# def _handle_nettivaraosa(url):
# def _handle_nettikone(url):
# def _handle_hitbox(url):
# def _handle_steamstore(url):
# def _handle_discogs(url):
# def _handle_gfycat(url):
which might include code, classes, or functions. Output only the next line. | lengh_str_regex = r"\d+(h|m|s)(\d+(m))?(\d+s)?" |
Given the code snippet: <|code_start|> ),
module_urltitle.handle_url(botmock, None, "#channel", msg, msg),
)
@my_vcr.use_cassette()
def test_six(botmock):
msg = "http://fi.wikipedia.org/wiki/Birger_Ek"
module_urltitle.init(botmock)
eq_(
(
"#channel",
u"Title: Rolf Birger Ek oli suomalainen lentäjä ja Mannerheim-ristin ritari.",
),
module_urltitle.handle_url(botmock, None, "#channel", msg, msg),
)
@my_vcr.use_cassette()
def test_seven(botmock):
msg = "http://en.wikipedia.org/wiki/Ramon_Llull"
eq_(
(
"#channel",
u"Title: Ramon Llull was a mathematician, polymath, philosopher, logician, writer and mystic from the Kingdom of Majorca.",
),
module_urltitle.handle_url(botmock, None, "#channel", msg, msg),
)
<|code_end|>
, generate the next line using the imports in this file:
from nose.tools import eq_
from pyfibot.modules import module_urltitle
from vcr import VCR
import bot_mock
import pytest
and context (functions, classes, or occasionally code) from other files:
# Path: pyfibot/modules/module_urltitle.py
# TITLE_LAG_MAXIMUM = 10
# CACHE_ENABLED = True
# CACHE_ENABLED = not CACHE_ENABLED
# def init(botref):
# def __get_bs(bot, url):
# def __get_title_tag(url):
# def __get_length_str(secs):
# def __get_age_str(published, use_fresh=True):
# def __get_views(views):
# def __escaped_fragment(url, meta=False):
# def command_cache(bot, user, channel, args):
# def handle_url(bot, user, channel, url, msg):
# def _check_redundant(url, title):
# def _levenshtein_distance(s, t):
# def _title(bot, channel, title, smart=False, prefix=None, url=None):
# def _parse_tweet_from_src(url):
# def _handle_mobile_tweet(url):
# def _handle_tweet2(url):
# def _handle_tweet(url):
# def twit_timestr(dt):
# def _handle_youtube_shorturl(url):
# def _handle_youtube_gdata(url):
# def _handle_ircquotes(url):
# def _handle_alko2(url):
# def _handle_alko(url):
# def _handle_vimeo(url):
# def _handle_stackoverflow(url):
# def _handle_reddit(url):
# def _handle_areena(url):
# def _parse_publication_events(data):
# def get_duration(event):
# def get_episode(identifier):
# def get_series(identifier):
# def _handle_wikipedia(url):
# def clean_page_name(url):
# def get_content(url):
# def _handle_imgur(url):
# def create_title(data):
# def _handle_dailymotion(url):
# def _handle_ebay(url):
# def _handle_ebay_no_prefix(url):
# def _handle_ebay_cgi(url):
# def _handle_dealextreme(url):
# def _handle_dealextreme_www(url):
# def fetch_nettiX(url, fields_to_fetch):
# def _handle_nettiauto(url):
# def _handle_nettivene(url):
# def _handle_nettimoto(url):
# def _handle_nettikaravaani(url):
# def _handle_nettivaraosa(url):
# def _handle_nettikone(url):
# def _handle_hitbox(url):
# def _handle_steamstore(url):
# def _handle_discogs(url):
# def _handle_gfycat(url):
. Output only the next line. | @my_vcr.use_cassette() |
Using the snippet: <|code_start|>
log = logging.getLogger("bot_mock")
class BotMock(botcore.CoreCommands):
config = {}
def __init__(self, config={}, network=None):
self.config = config
if network:
self.network = network
self.nickname = self.network.nickname
self.lineRate = self.network.linerate
self.password = self.network.password
<|code_end|>
, determine the next line of code. You have imports:
import os.path
import yaml
import logging
import requests
from pyfibot import pyfibot
from pyfibot import botcore
and context (class names, function names, or code) available:
# Path: pyfibot/pyfibot.py
# USE_COLOR = True
# FORMAT = (
# "[%(asctime)-15s][%(levelname)-20s][$BOLD%(name)-15s$RESET] %(message)s"
# )
# FORMAT = "%s %s" % (
# FORMAT, " ($BOLD%(filename)s$RESET:%(lineno)d)")
# COLOR_FORMAT = colorlogger.formatter_message(FORMAT, True)
# FORMAT = "%(asctime)-15s %(levelname)-8s %(name)-11s %(message)s"
# FORMAT = "%s %s" % (FORMAT, " (%(filename)s:%(lineno)d)")
# class Network(object):
# class InstantDisconnectProtocol(protocol.Protocol):
# class ThrottledClientFactory(protocol.ClientFactory):
# class PyFiBotFactory(ThrottledClientFactory):
# def __init__(
# self,
# root,
# alias,
# address,
# nickname,
# realname=None,
# channels=None,
# linerate=None,
# password=None,
# is_ssl=False,
# ):
# def __repr__(self):
# def connectionMade(self):
# def clientConnectionLost(self, connector, reason):
# def clientConnectionFailed(self, connector, reason):
# def __init__(self, config):
# def startFactory(self):
# def stopFactory(self):
# def buildProtocol(self, address):
# def createNetwork(
# self,
# address,
# alias,
# nickname,
# realname,
# channels=None,
# linerate=None,
# password=None,
# is_ssl=False,
# ):
# def setNetwork(self, net):
# def clientConnectionLost(self, connector, reason):
# def _finalize_modules(self, modules=None):
# def _loadmodules(self):
# def _unload_removed_modules(self):
# def _findmodules(self):
# def _getGlobals(self):
# def get_url(self, url, nocache=False, params=None, headers=None, cookies=None):
# def getIdent(self, user):
# def getHost(self, user):
# def isAdmin(self, user):
# def to_utf8(self, _string):
# def to_unicode(self, _string):
# def reload_config(self):
# def find_bot_for_network(self, network):
# def init_logging(config):
# def read_config():
# def validate_config(config):
# def main():
#
# Path: pyfibot/botcore.py
# class CoreCommands(object):
# class PyFiBot(irc.IRCClient, CoreCommands):
# def command_echo(self, user, channel, args):
# def command_ping(self, user, channel, args):
# def command_rehash(self, user, channel, args):
# def say(self, channel, message, length=None):
# def command_join(self, user, channel, args):
# def command_leave(self, user, channel, args):
# def command_part(self, user, channel, args):
# def command_quit(self, user, channel, args):
# def command_channels(self, user, channel, args):
# def command_help(self, user, channel, cmnd):
# def __init__(self, config, network):
# def __repr__(self):
# def printResult(self, msg, info):
# def printError(self, msg, info):
# def connectionMade(self):
# def connectionLost(self, reason):
# def signedOn(self):
# def joinChannels(self):
# def pong(self, user, secs):
# def repeatingPing(self, delay):
# def get_url(self, url, nocache=False, params=None, headers=None, cookies=None):
# def getUrl(self, url, nocache=False, params=None, headers=None, cookies=None):
# def isAdmin(self, user):
# def is_admin(self, user):
# def get_nick(self, user):
# def getNick(self, user):
# def log(self, message):
# def callLater(self, delay, callable):
# def privmsg(self, user, channel, msg):
# def _runhandler(self, handler, *args, **kwargs):
# def _runEvents(self, eventname, *args, **kwargs):
# def _command(self, user, channel, cmnd):
# def say(self, channel, message, length=None):
# def act(self, channel, message, length=None):
# def mode(self, chan, set, modes, limit=None, user=None, mask=None):
# def kick(self, channel, user, reason=None):
# def join(self, channel, key=None):
# def leave(self, channel, key=None):
# def quit(self, message=""):
# def XXregister(self, nickname, hostname="foo", servername="bar"):
# def irc_JOIN(self, prefix, params):
# def irc_PART(self, prefix, params):
# def irc_NICK(self, prefix, params):
# def irc_QUIT(self, prefix, params):
# def joined(self, channel):
# def left(self, channel):
# def noticed(self, user, channel, message):
# def modeChanged(self, user, channel, set, modes, args):
# def kickedFrom(self, channel, kicker, message):
# def nickChanged(self, nick):
# def userJoined(self, user, channel):
# def userLeft(self, user, channel, message):
# def userKicked(self, kickee, channel, kicker, message):
# def action(self, user, channel, data):
# def topicUpdated(self, user, channel, topic):
# def userRenamed(self, oldnick, newnick):
# def receivedMOTD(self, motd):
# def isupport(self, options):
# def created(self, when):
# def yourHost(self, info):
# def myInfo(self, servername, version, umodes, cmodes):
# def luserMe(self, info):
. Output only the next line. | def get_url(self, url, nocache=False, params=None, headers=None, cookies=None): |
Predict the next line for this snippet: <|code_start|> return self.extract_packet(self.cls, x)
class ASN1F_CHOICE(ASN1F_PACKET):
ASN1_tag = ASN1_Class_UNIVERSAL.NONE
def __init__(self, name, default, *args):
self.name=name
self.choice = {}
# FIXME TypeError: unhashable type: 'ASN1Tag
for p in args:
self.choice[int(p.ASN1_root.ASN1_tag)] = p
# print("ASN1_tag %r %s" % ( p.ASN1_root.ASN1_tag, p))
logger.debug("self.choice %s", self.choice)
# self.context=context
self.default=default
def m2i(self, pkt, x):
if len(x) == 0:
return packet.Raw(),""
raise ASN1_Error("ASN1F_CHOICE: got empty string")
# if ord(x[0]) not in self.choice:
if x[0] not in self.choice:
# return packet.Raw(x),"" # XXX return RawASN1 packet ? Raise error
# raise ASN1_Error("Decoding Error: choice [%i] not found in %r" % (ord(x[0]), list(self.choice.keys())))
raise ASN1_Error(
"Decoding Error: choice [%i] not found in %s" % (x[0], self.choice))
# z = ASN1F_PACKET.extract_packet(self, self.choice[ord(x[0])], x)
z = ASN1F_PACKET.extract_packet(self, self.choice[x[0]], x)
return z
def randval(self):
<|code_end|>
with the help of current file imports:
import logging
from .asn1.asn1 import *
from .asn1.ber import *
from .helpers import BasePacket
from functools import reduce
from . import packet
and context from other files:
# Path: modules/python/dionaea/smb/include/helpers.py
# class BasePacket(Gen):
# pass
, which may contain function names, class names, or code. Output only the next line. | return RandChoice(*[fuzz(x()) for x in list(self.choice.values())]) |
Given the code snippet: <|code_start|>
class ProjectsTestCase(TestCase):
list_url = '/projects/'
add_url = '/projects/add/'
def test_login_required_for_list(self):
response = self.client.get(self.list_url)
self.assertRedirectToLogin(response, self.list_url)
def test_user_see_list_page(self):
self.login()
response = self.client.get(self.list_url)
self.assert200(response)
self.assertTemplateUsed('projects/list.jade')
def test_login_required_for_add(self):
response = self.client.get(self.add_url)
self.assertRedirectToLogin(response, self.add_url)
response = self.client.post(self.add_url)
self.assertRedirectToLogin(response, self.add_url)
def test_user_see_add_form(self):
self.login()
response = self.client.get(self.add_url)
<|code_end|>
, generate the next line using the imports in this file:
from datetime import datetime
from flask import url_for
from tests.base import TestCase
from app.accounts.models import Project, User
import mock
and context (functions, classes, or occasionally code) from other files:
# Path: tests/base.py
# class TestCase(_TestCase):
# db = db
#
# def create_app(self):
# app.config.from_object('tests.settings_test')
# app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
# return app
#
# def setUp(self):
# db.create_all()
# self.user = create_admin()
#
# def tearDown(self):
# db.session.remove()
# db.drop_all()
#
# def login(self, email=None, password=None):
# data = dict(
# email=email or self.app.config['ADMIN_USER']['email'],
# password=password or self.app.config['ADMIN_USER']['password'],
# remember=True,
# )
# return self.client.post('/user/sign-in', data=data,
# follow_redirects=True)
#
# def logout(self):
# return self.client.get('/user/sign-out', follow_redirects=True)
#
# def assertRedirectToLogin(self, response, next_url):
# expected = '/user/sign-in?next=http%3A//localhost{0}'.format(next_url)
# self.assertRedirects(response, expected)
#
# Path: app/accounts/models.py
# class Project(db.Model, models.BaseModelMixin, models.CreateAndModifyMixin):
# __tablename__ = 'projects'
#
# title = db.Column(db.Unicode(255), nullable=False)
#
# intercom_app_id = db.Column(db.Unicode(255), nullable=False, unique=True)
# intercom_api_key = db.Column(db.Unicode(255), nullable=False)
# intercom_webhooks_internal_secret = db.Column(db.Unicode(255))
# intercom_subscription_id = db.Column(db.Unicode(255))
#
# aws_access_id = db.Column(db.Unicode(255), nullable=False)
# aws_secret_access_key = db.Column(db.Unicode(255), nullable=False)
#
# user_id = db.Column(db.Integer(), db.ForeignKey('users.id'),
# nullable=False)
# user = db.relationship('User', back_populates='projects')
#
# intercom_users = db.relationship('IntercomUser',
# back_populates='project')
#
# def __unicode__(self):
# return self.title
#
# @classmethod
# def get_for_current_user_or_404(cls, pk):
# return cls.get_or_404(cls.user_id == current_user.id, cls.id == pk)
#
# def get_intercom_client(project):
# from app.intercom.service import IntercomClient
# return IntercomClient(project.intercom_app_id,
# project.intercom_api_key)
#
# def start_awis_session(project):
# """ Initiate contextmanager for working with AWIS.
# """
# return AWISContextManager(project.aws_access_id,
# project.aws_secret_access_key)
#
# def delete(self):
# client = self.get_intercom_client()
# client.unsubscribe(self.intercom_subscription_id)
# return super(Project, self).delete()
#
# class User(db.Model, UserMixin, models.BaseModelMixin):
# __tablename__ = 'users'
#
# email = db.Column(db.Unicode(255), nullable=False, unique=True)
# password = db.Column(db.String(255), nullable=False)
#
# confirmed_at = db.Column(db.DateTime())
# reset_password_token = db.Column(db.String(100), nullable=False,
# default='')
#
# is_enabled = db.Column(db.Boolean(), nullable=False, default=False)
# is_admin = db.Column(db.Boolean(), nullable=False, default=False)
#
# projects = db.relationship('Project', back_populates='user')
#
# def __unicode__(self):
# return self.email
#
# def is_active(self):
# # HACK for Flask-Login :/
# return self.is_enabled
. Output only the next line. | self.assert200(response) |
Continue the code snippet: <|code_start|> def test_user_see_list_page(self):
self.login()
response = self.client.get(self.list_url)
self.assert200(response)
self.assertTemplateUsed('projects/list.jade')
def test_login_required_for_add(self):
response = self.client.get(self.add_url)
self.assertRedirectToLogin(response, self.add_url)
response = self.client.post(self.add_url)
self.assertRedirectToLogin(response, self.add_url)
def test_user_see_add_form(self):
self.login()
response = self.client.get(self.add_url)
self.assert200(response)
self.assertTemplateUsed('projects/form.jade')
@mock.patch('app.intercom.service.IntercomClient.subscribe')
def test_add_with_valid_data(self, subscribe):
subscribe.return_value = {'id': 'some-id'}
valid_data = dict(
title='title',
intercom_app_id='intercom_app_id',
intercom_api_key='intercom_api_key',
aws_access_id='aws_access_id',
<|code_end|>
. Use current file imports:
from datetime import datetime
from flask import url_for
from tests.base import TestCase
from app.accounts.models import Project, User
import mock
and context (classes, functions, or code) from other files:
# Path: tests/base.py
# class TestCase(_TestCase):
# db = db
#
# def create_app(self):
# app.config.from_object('tests.settings_test')
# app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
# return app
#
# def setUp(self):
# db.create_all()
# self.user = create_admin()
#
# def tearDown(self):
# db.session.remove()
# db.drop_all()
#
# def login(self, email=None, password=None):
# data = dict(
# email=email or self.app.config['ADMIN_USER']['email'],
# password=password or self.app.config['ADMIN_USER']['password'],
# remember=True,
# )
# return self.client.post('/user/sign-in', data=data,
# follow_redirects=True)
#
# def logout(self):
# return self.client.get('/user/sign-out', follow_redirects=True)
#
# def assertRedirectToLogin(self, response, next_url):
# expected = '/user/sign-in?next=http%3A//localhost{0}'.format(next_url)
# self.assertRedirects(response, expected)
#
# Path: app/accounts/models.py
# class Project(db.Model, models.BaseModelMixin, models.CreateAndModifyMixin):
# __tablename__ = 'projects'
#
# title = db.Column(db.Unicode(255), nullable=False)
#
# intercom_app_id = db.Column(db.Unicode(255), nullable=False, unique=True)
# intercom_api_key = db.Column(db.Unicode(255), nullable=False)
# intercom_webhooks_internal_secret = db.Column(db.Unicode(255))
# intercom_subscription_id = db.Column(db.Unicode(255))
#
# aws_access_id = db.Column(db.Unicode(255), nullable=False)
# aws_secret_access_key = db.Column(db.Unicode(255), nullable=False)
#
# user_id = db.Column(db.Integer(), db.ForeignKey('users.id'),
# nullable=False)
# user = db.relationship('User', back_populates='projects')
#
# intercom_users = db.relationship('IntercomUser',
# back_populates='project')
#
# def __unicode__(self):
# return self.title
#
# @classmethod
# def get_for_current_user_or_404(cls, pk):
# return cls.get_or_404(cls.user_id == current_user.id, cls.id == pk)
#
# def get_intercom_client(project):
# from app.intercom.service import IntercomClient
# return IntercomClient(project.intercom_app_id,
# project.intercom_api_key)
#
# def start_awis_session(project):
# """ Initiate contextmanager for working with AWIS.
# """
# return AWISContextManager(project.aws_access_id,
# project.aws_secret_access_key)
#
# def delete(self):
# client = self.get_intercom_client()
# client.unsubscribe(self.intercom_subscription_id)
# return super(Project, self).delete()
#
# class User(db.Model, UserMixin, models.BaseModelMixin):
# __tablename__ = 'users'
#
# email = db.Column(db.Unicode(255), nullable=False, unique=True)
# password = db.Column(db.String(255), nullable=False)
#
# confirmed_at = db.Column(db.DateTime())
# reset_password_token = db.Column(db.String(100), nullable=False,
# default='')
#
# is_enabled = db.Column(db.Boolean(), nullable=False, default=False)
# is_admin = db.Column(db.Boolean(), nullable=False, default=False)
#
# projects = db.relationship('Project', back_populates='user')
#
# def __unicode__(self):
# return self.email
#
# def is_active(self):
# # HACK for Flask-Login :/
# return self.is_enabled
. Output only the next line. | aws_secret_access_key='aws_secret_access_key', |
Given the following code snippet before the placeholder: <|code_start|>
projects = self.get_context_variable('projects')
self.assertEqual(len(projects), 1)
self.assertEqual(projects[0].title, valid_data['title'])
self.assertTrue(subscribe.called)
def test_invalid_data_not_added(self):
self.login()
response = self.client.post(self.add_url)
self.assert200(response)
form = self.get_context_variable('form')
self.assertTrue(form.errors)
class ProjectUpdateTestCase(TestCase):
def setUp(self):
super(ProjectUpdateTestCase, self).setUp()
self.project = Project(
title='title',
intercom_app_id='intercom_app_id',
intercom_api_key='intercom_api_key',
aws_access_id='aws_access_id',
aws_secret_access_key='aws_secret_access_key',
user_id=self.user.id)
self.project.save()
self.url = url_for('accounts.project_update', pk=self.project.id)
<|code_end|>
, predict the next line using imports from the current file:
from datetime import datetime
from flask import url_for
from tests.base import TestCase
from app.accounts.models import Project, User
import mock
and context including class names, function names, and sometimes code from other files:
# Path: tests/base.py
# class TestCase(_TestCase):
# db = db
#
# def create_app(self):
# app.config.from_object('tests.settings_test')
# app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
# return app
#
# def setUp(self):
# db.create_all()
# self.user = create_admin()
#
# def tearDown(self):
# db.session.remove()
# db.drop_all()
#
# def login(self, email=None, password=None):
# data = dict(
# email=email or self.app.config['ADMIN_USER']['email'],
# password=password or self.app.config['ADMIN_USER']['password'],
# remember=True,
# )
# return self.client.post('/user/sign-in', data=data,
# follow_redirects=True)
#
# def logout(self):
# return self.client.get('/user/sign-out', follow_redirects=True)
#
# def assertRedirectToLogin(self, response, next_url):
# expected = '/user/sign-in?next=http%3A//localhost{0}'.format(next_url)
# self.assertRedirects(response, expected)
#
# Path: app/accounts/models.py
# class Project(db.Model, models.BaseModelMixin, models.CreateAndModifyMixin):
# __tablename__ = 'projects'
#
# title = db.Column(db.Unicode(255), nullable=False)
#
# intercom_app_id = db.Column(db.Unicode(255), nullable=False, unique=True)
# intercom_api_key = db.Column(db.Unicode(255), nullable=False)
# intercom_webhooks_internal_secret = db.Column(db.Unicode(255))
# intercom_subscription_id = db.Column(db.Unicode(255))
#
# aws_access_id = db.Column(db.Unicode(255), nullable=False)
# aws_secret_access_key = db.Column(db.Unicode(255), nullable=False)
#
# user_id = db.Column(db.Integer(), db.ForeignKey('users.id'),
# nullable=False)
# user = db.relationship('User', back_populates='projects')
#
# intercom_users = db.relationship('IntercomUser',
# back_populates='project')
#
# def __unicode__(self):
# return self.title
#
# @classmethod
# def get_for_current_user_or_404(cls, pk):
# return cls.get_or_404(cls.user_id == current_user.id, cls.id == pk)
#
# def get_intercom_client(project):
# from app.intercom.service import IntercomClient
# return IntercomClient(project.intercom_app_id,
# project.intercom_api_key)
#
# def start_awis_session(project):
# """ Initiate contextmanager for working with AWIS.
# """
# return AWISContextManager(project.aws_access_id,
# project.aws_secret_access_key)
#
# def delete(self):
# client = self.get_intercom_client()
# client.unsubscribe(self.intercom_subscription_id)
# return super(Project, self).delete()
#
# class User(db.Model, UserMixin, models.BaseModelMixin):
# __tablename__ = 'users'
#
# email = db.Column(db.Unicode(255), nullable=False, unique=True)
# password = db.Column(db.String(255), nullable=False)
#
# confirmed_at = db.Column(db.DateTime())
# reset_password_token = db.Column(db.String(100), nullable=False,
# default='')
#
# is_enabled = db.Column(db.Boolean(), nullable=False, default=False)
# is_admin = db.Column(db.Boolean(), nullable=False, default=False)
#
# projects = db.relationship('Project', back_populates='user')
#
# def __unicode__(self):
# return self.email
#
# def is_active(self):
# # HACK for Flask-Login :/
# return self.is_enabled
. Output only the next line. | def test_page_not_allowed_for_anon(self): |
Given the code snippet: <|code_start|>
def test_listing_works(self):
self.login()
response = self.client.get(self.url)
self.assert200(response)
self.assertTemplateUsed('fep/list.jade')
content = response.data.decode('utf-8')
for item in self.items:
self.assertTrue(item.domain in content)
def test_add_duplicate(self):
self.login()
response = self.client.post(self.url,
data={'domain': self.items[0].domain})
self.assert200(response)
form = self.get_context_variable('form')
self.assertTrue(form.errors)
self.assertEqual(len(self.items), FreeEmailProvider.query.count())
def test_empty_submit(self):
self.login()
response = self.client.post(self.url)
self.assert200(response)
form = self.get_context_variable('form')
<|code_end|>
, generate the next line using the imports in this file:
from flask import url_for
from tests.base import TestCase
from app.accounts.models import FreeEmailProvider
and context (functions, classes, or occasionally code) from other files:
# Path: tests/base.py
# class TestCase(_TestCase):
# db = db
#
# def create_app(self):
# app.config.from_object('tests.settings_test')
# app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
# return app
#
# def setUp(self):
# db.create_all()
# self.user = create_admin()
#
# def tearDown(self):
# db.session.remove()
# db.drop_all()
#
# def login(self, email=None, password=None):
# data = dict(
# email=email or self.app.config['ADMIN_USER']['email'],
# password=password or self.app.config['ADMIN_USER']['password'],
# remember=True,
# )
# return self.client.post('/user/sign-in', data=data,
# follow_redirects=True)
#
# def logout(self):
# return self.client.get('/user/sign-out', follow_redirects=True)
#
# def assertRedirectToLogin(self, response, next_url):
# expected = '/user/sign-in?next=http%3A//localhost{0}'.format(next_url)
# self.assertRedirects(response, expected)
#
# Path: app/accounts/models.py
# class FreeEmailProvider(db.Model, models.BaseModelMixin):
# __tablename__ = 'free_email_providers'
#
# domain = db.Column(db.Unicode(255), nullable=False, index=True)
#
# def __unicode__(self):
# return self.domain
#
# @classmethod
# def exists(cls, domain):
# return bool(cls.query.filter(cls.domain == domain).first())
. Output only the next line. | self.assertTrue(form.errors) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.