Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Given snippet: <|code_start|># -*- coding: utf-8 -*-
handler404 = 'app.views.error_views.not_found_404'
handler400 = 'app.views.error_views.bad_request_400'
handler403 = 'app.views.error_views.permission_denied_403'
handler500 = 'app.views.error_views.internal_error_500'
urlpatterns = [
url(settings.ADMIN_URL, include(admin.site.urls)),
# API urls
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.conf.urls import include, url
from django.conf.urls.static import static
from django.conf import settings
from django.contrib import admin
from app.views import (index_views, additional_views, add_book_views, selected_book_views, library_views,
read_book_views, profile_views, about_views, reminder_views)
and context:
# Path: app/views/index_views.py
# RANDOM_BOOKS_COUNT = 6
# def index(request):
# def home(request):
# def login_response(request, username, password):
# def user_login(request):
# def is_user_exists(request, form):
# def is_mail_exists(request, form):
# def sign_in(request):
# def restore_data(request, form):
#
# Path: app/views/additional_views.py
# def user_logout(request):
# def share_txt(request, file):
# def share_xml(request, file):
# def unsubscribe(request, token):
# def payment_success(request):
#
# Path: app/views/add_book_views.py
# READ_PRIVILEGES = 0o644
# def add_book(request):
# def generate_authors(request, form):
# def generate_books(request, form):
# def add_book_successful(request, form):
#
# Path: app/views/selected_book_views.py
# BOOK_COVER_HEIGHT = 350
# COMMENTS_PER_PAGE = 20
# COMMENTS_START_PAGE = 1
# RANDOM_BOOKS_COUNT = 6
# def selected_book(request, book_id):
# def store_image(request, form):
# def add_book_to_home(request, form):
# def remove_book_from_home(request, form):
# def change_rating(request, form):
# def set_rating(request, rating_form):
# def add_comment(request, form):
# def load_comments(request, form):
# def report_book(request, form):
#
# Path: app/views/library_views.py
# MOST_READ_BOOKS_COUNT = 9
# def all_categories(request):
# def selected_category(request, category_id):
# def selected_author(request, author_id):
# def sort(request, form):
# def find_books(request, form):
# def load_books(request, category_id, form):
#
# Path: app/views/read_book_views.py
# def open_book(request, book_id):
# def set_current_page(request, form):
#
# Path: app/views/profile_views.py
# AVATAR_WIDTH = 250
# def profile(request, profile_id):
# def load_uploaded_books(request, profile_id, form):
# def upload_avatar(request):
# def change_password(request, form):
#
# Path: app/views/about_views.py
# def about(request):
# def send_message(request, form):
#
# Path: app/views/reminder_views.py
# def update_reminder(request):
which might include code, classes, or functions. Output only the next line. | url(r'^api/v1/', include('api.urls')), |
Here is a snippet: <|code_start|> url(r'comment-add', selected_book_views.add_comment, name='add_comment_app'),
url(r'load-comments', selected_book_views.load_comments, name='load_comments_app'),
url(r'report-book', selected_book_views.report_book, name='report-book'),
# Library urls.
url(r'library', library_views.all_categories, name='categories'),
url(r'^category/(?P<category_id>\d+)/$', library_views.selected_category, name='category'),
url(r'^category/(?P<category_id>\d+)/load-books/$', library_views.load_books, name='load_books'),
url(r'sort', library_views.sort, name='book_sort'),
url(r'search-book', library_views.find_books, name='search_book_app'),
url(r'^author/(?P<author_id>\d+)/$', library_views.selected_author, name='author'),
# Profile urls.
url(r'profile/(?P<profile_id>\d+)/$', profile_views.profile, name='profile'),
url(r'profile/(?P<profile_id>\d+)/load-books/$', profile_views.load_uploaded_books, name='load_uploaded_books_app'),
url(r'upload-avatar', profile_views.upload_avatar, name='upload_avatar'),
url(r'change-password', profile_views.change_password, name='change_password'),
# About project urls.
url(r'about', about_views.about, name='about'),
url(r'send-message', about_views.send_message, name='send_message'),
# Additional urls.
url(r'logout', additional_views.user_logout, name='logout'),
url(r'unsubscribe/(?P<token>[0-9a-zA-Z_-]+)/', additional_views.unsubscribe, name='unsubscribe'),
url(r'(?P<file>[%&+ \w]+.txt)', additional_views.share_txt, name='share_txt'),
url(r'(?P<file>[%&+ \w]+.xml)', additional_views.share_xml, name='share_xml'),
url(r'^update-reminder', reminder_views.update_reminder, name='update_reminder'),
url(r'^payment-success', additional_views.payment_success, name='payment_success_app')
<|code_end|>
. Write the next line using the current file imports:
from django.conf.urls import include, url
from django.conf.urls.static import static
from django.conf import settings
from django.contrib import admin
from app.views import (index_views, additional_views, add_book_views, selected_book_views, library_views,
read_book_views, profile_views, about_views, reminder_views)
and context from other files:
# Path: app/views/index_views.py
# RANDOM_BOOKS_COUNT = 6
# def index(request):
# def home(request):
# def login_response(request, username, password):
# def user_login(request):
# def is_user_exists(request, form):
# def is_mail_exists(request, form):
# def sign_in(request):
# def restore_data(request, form):
#
# Path: app/views/additional_views.py
# def user_logout(request):
# def share_txt(request, file):
# def share_xml(request, file):
# def unsubscribe(request, token):
# def payment_success(request):
#
# Path: app/views/add_book_views.py
# READ_PRIVILEGES = 0o644
# def add_book(request):
# def generate_authors(request, form):
# def generate_books(request, form):
# def add_book_successful(request, form):
#
# Path: app/views/selected_book_views.py
# BOOK_COVER_HEIGHT = 350
# COMMENTS_PER_PAGE = 20
# COMMENTS_START_PAGE = 1
# RANDOM_BOOKS_COUNT = 6
# def selected_book(request, book_id):
# def store_image(request, form):
# def add_book_to_home(request, form):
# def remove_book_from_home(request, form):
# def change_rating(request, form):
# def set_rating(request, rating_form):
# def add_comment(request, form):
# def load_comments(request, form):
# def report_book(request, form):
#
# Path: app/views/library_views.py
# MOST_READ_BOOKS_COUNT = 9
# def all_categories(request):
# def selected_category(request, category_id):
# def selected_author(request, author_id):
# def sort(request, form):
# def find_books(request, form):
# def load_books(request, category_id, form):
#
# Path: app/views/read_book_views.py
# def open_book(request, book_id):
# def set_current_page(request, form):
#
# Path: app/views/profile_views.py
# AVATAR_WIDTH = 250
# def profile(request, profile_id):
# def load_uploaded_books(request, profile_id, form):
# def upload_avatar(request):
# def change_password(request, form):
#
# Path: app/views/about_views.py
# def about(request):
# def send_message(request, form):
#
# Path: app/views/reminder_views.py
# def update_reminder(request):
, which may include functions, classes, or code. Output only the next line. | ] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT) |
Using the snippet: <|code_start|># -*- coding: utf-8 -*-
handler404 = 'app.views.error_views.not_found_404'
handler400 = 'app.views.error_views.bad_request_400'
handler403 = 'app.views.error_views.permission_denied_403'
handler500 = 'app.views.error_views.internal_error_500'
urlpatterns = [
url(settings.ADMIN_URL, include(admin.site.urls)),
# API urls
<|code_end|>
, determine the next line of code. You have imports:
from django.conf.urls import include, url
from django.conf.urls.static import static
from django.conf import settings
from django.contrib import admin
from app.views import (index_views, additional_views, add_book_views, selected_book_views, library_views,
read_book_views, profile_views, about_views, reminder_views)
and context (class names, function names, or code) available:
# Path: app/views/index_views.py
# RANDOM_BOOKS_COUNT = 6
# def index(request):
# def home(request):
# def login_response(request, username, password):
# def user_login(request):
# def is_user_exists(request, form):
# def is_mail_exists(request, form):
# def sign_in(request):
# def restore_data(request, form):
#
# Path: app/views/additional_views.py
# def user_logout(request):
# def share_txt(request, file):
# def share_xml(request, file):
# def unsubscribe(request, token):
# def payment_success(request):
#
# Path: app/views/add_book_views.py
# READ_PRIVILEGES = 0o644
# def add_book(request):
# def generate_authors(request, form):
# def generate_books(request, form):
# def add_book_successful(request, form):
#
# Path: app/views/selected_book_views.py
# BOOK_COVER_HEIGHT = 350
# COMMENTS_PER_PAGE = 20
# COMMENTS_START_PAGE = 1
# RANDOM_BOOKS_COUNT = 6
# def selected_book(request, book_id):
# def store_image(request, form):
# def add_book_to_home(request, form):
# def remove_book_from_home(request, form):
# def change_rating(request, form):
# def set_rating(request, rating_form):
# def add_comment(request, form):
# def load_comments(request, form):
# def report_book(request, form):
#
# Path: app/views/library_views.py
# MOST_READ_BOOKS_COUNT = 9
# def all_categories(request):
# def selected_category(request, category_id):
# def selected_author(request, author_id):
# def sort(request, form):
# def find_books(request, form):
# def load_books(request, category_id, form):
#
# Path: app/views/read_book_views.py
# def open_book(request, book_id):
# def set_current_page(request, form):
#
# Path: app/views/profile_views.py
# AVATAR_WIDTH = 250
# def profile(request, profile_id):
# def load_uploaded_books(request, profile_id, form):
# def upload_avatar(request):
# def change_password(request, form):
#
# Path: app/views/about_views.py
# def about(request):
# def send_message(request, form):
#
# Path: app/views/reminder_views.py
# def update_reminder(request):
. Output only the next line. | url(r'^api/v1/', include('api.urls')), |
Predict the next line for this snippet: <|code_start|># -*- coding: utf-8 -*-
handler404 = 'app.views.error_views.not_found_404'
handler400 = 'app.views.error_views.bad_request_400'
handler403 = 'app.views.error_views.permission_denied_403'
handler500 = 'app.views.error_views.internal_error_500'
urlpatterns = [
url(settings.ADMIN_URL, include(admin.site.urls)),
# API urls
<|code_end|>
with the help of current file imports:
from django.conf.urls import include, url
from django.conf.urls.static import static
from django.conf import settings
from django.contrib import admin
from app.views import (index_views, additional_views, add_book_views, selected_book_views, library_views,
read_book_views, profile_views, about_views, reminder_views)
and context from other files:
# Path: app/views/index_views.py
# RANDOM_BOOKS_COUNT = 6
# def index(request):
# def home(request):
# def login_response(request, username, password):
# def user_login(request):
# def is_user_exists(request, form):
# def is_mail_exists(request, form):
# def sign_in(request):
# def restore_data(request, form):
#
# Path: app/views/additional_views.py
# def user_logout(request):
# def share_txt(request, file):
# def share_xml(request, file):
# def unsubscribe(request, token):
# def payment_success(request):
#
# Path: app/views/add_book_views.py
# READ_PRIVILEGES = 0o644
# def add_book(request):
# def generate_authors(request, form):
# def generate_books(request, form):
# def add_book_successful(request, form):
#
# Path: app/views/selected_book_views.py
# BOOK_COVER_HEIGHT = 350
# COMMENTS_PER_PAGE = 20
# COMMENTS_START_PAGE = 1
# RANDOM_BOOKS_COUNT = 6
# def selected_book(request, book_id):
# def store_image(request, form):
# def add_book_to_home(request, form):
# def remove_book_from_home(request, form):
# def change_rating(request, form):
# def set_rating(request, rating_form):
# def add_comment(request, form):
# def load_comments(request, form):
# def report_book(request, form):
#
# Path: app/views/library_views.py
# MOST_READ_BOOKS_COUNT = 9
# def all_categories(request):
# def selected_category(request, category_id):
# def selected_author(request, author_id):
# def sort(request, form):
# def find_books(request, form):
# def load_books(request, category_id, form):
#
# Path: app/views/read_book_views.py
# def open_book(request, book_id):
# def set_current_page(request, form):
#
# Path: app/views/profile_views.py
# AVATAR_WIDTH = 250
# def profile(request, profile_id):
# def load_uploaded_books(request, profile_id, form):
# def upload_avatar(request):
# def change_password(request, form):
#
# Path: app/views/about_views.py
# def about(request):
# def send_message(request, form):
#
# Path: app/views/reminder_views.py
# def update_reminder(request):
, which may contain function names, class names, or code. Output only the next line. | url(r'^api/v1/', include('api.urls')), |
Predict the next line for this snippet: <|code_start|># -*- coding: utf-8 -*-
handler404 = 'app.views.error_views.not_found_404'
handler400 = 'app.views.error_views.bad_request_400'
handler403 = 'app.views.error_views.permission_denied_403'
handler500 = 'app.views.error_views.internal_error_500'
urlpatterns = [
url(settings.ADMIN_URL, include(admin.site.urls)),
# API urls
<|code_end|>
with the help of current file imports:
from django.conf.urls import include, url
from django.conf.urls.static import static
from django.conf import settings
from django.contrib import admin
from app.views import (index_views, additional_views, add_book_views, selected_book_views, library_views,
read_book_views, profile_views, about_views, reminder_views)
and context from other files:
# Path: app/views/index_views.py
# RANDOM_BOOKS_COUNT = 6
# def index(request):
# def home(request):
# def login_response(request, username, password):
# def user_login(request):
# def is_user_exists(request, form):
# def is_mail_exists(request, form):
# def sign_in(request):
# def restore_data(request, form):
#
# Path: app/views/additional_views.py
# def user_logout(request):
# def share_txt(request, file):
# def share_xml(request, file):
# def unsubscribe(request, token):
# def payment_success(request):
#
# Path: app/views/add_book_views.py
# READ_PRIVILEGES = 0o644
# def add_book(request):
# def generate_authors(request, form):
# def generate_books(request, form):
# def add_book_successful(request, form):
#
# Path: app/views/selected_book_views.py
# BOOK_COVER_HEIGHT = 350
# COMMENTS_PER_PAGE = 20
# COMMENTS_START_PAGE = 1
# RANDOM_BOOKS_COUNT = 6
# def selected_book(request, book_id):
# def store_image(request, form):
# def add_book_to_home(request, form):
# def remove_book_from_home(request, form):
# def change_rating(request, form):
# def set_rating(request, rating_form):
# def add_comment(request, form):
# def load_comments(request, form):
# def report_book(request, form):
#
# Path: app/views/library_views.py
# MOST_READ_BOOKS_COUNT = 9
# def all_categories(request):
# def selected_category(request, category_id):
# def selected_author(request, author_id):
# def sort(request, form):
# def find_books(request, form):
# def load_books(request, category_id, form):
#
# Path: app/views/read_book_views.py
# def open_book(request, book_id):
# def set_current_page(request, form):
#
# Path: app/views/profile_views.py
# AVATAR_WIDTH = 250
# def profile(request, profile_id):
# def load_uploaded_books(request, profile_id, form):
# def upload_avatar(request):
# def change_password(request, form):
#
# Path: app/views/about_views.py
# def about(request):
# def send_message(request, form):
#
# Path: app/views/reminder_views.py
# def update_reminder(request):
, which may contain function names, class names, or code. Output only the next line. | url(r'^api/v1/', include('api.urls')), |
Using the snippet: <|code_start|># -*- coding: utf-8 -*-
# ----------------------------------------------------------------------------------------------------------------------
class ReminderViewsTest(TestCase):
# ------------------------------------------------------------------------------------------------------------------
@classmethod
def setUpTestData(cls):
cls.user = User.objects.create_user(username='logged_user', email='test@user.com', password='Dummy#password')
cls.the_user = TheUser.objects.get(id_user=cls.user)
cls.anonymous_client = Client()
cls.logged_client = Client()
cls.logged_client.login(username='logged_user', password='Dummy#password')
# ------------------------------------------------------------------------------------------------------------------
def test_update_reminder_not_logged(self):
response = self.anonymous_client.post(reverse('update_reminder'), {})
self.assertEqual(response.resolver_match.func, update_reminder)
self.assertEqual(response.status_code, 404)
# ------------------------------------------------------------------------------------------------------------------
def test_update_reminder_not_post(self):
response = self.logged_client.get(reverse('update_reminder'))
self.assertEqual(response.resolver_match.func, update_reminder)
<|code_end|>
, determine the next line of code. You have imports:
from django.contrib.auth.models import User
from django.test import TestCase, Client
from django.shortcuts import reverse
from ...models import TheUser
from ...views.reminder_views import update_reminder
and context (class names, function names, or code) available:
# Path: app/models.py
# class TheUser(models.Model):
# """
# Class for user objects in database.
# """
# REMINDER_TEMPLATE = json.dumps({
# "common": {
# "fb_page": True,
# "fb_group": True,
# "twitter": True,
# "vk": True,
# "disabled_all": False
# },
# "api": {
# "app_rate": True
# },
# "web": {
# "app_download": True,
# },
# })
#
# id_user = models.OneToOneField(User)
# user_photo = models.ImageField(blank=True, upload_to='user', storage=OverwriteStorage())
# auth_token = models.CharField(max_length=50, null=True, blank=True)
# subscription = models.BooleanField(default=True)
# reminder = models.CharField(max_length=256, null=False, default=REMINDER_TEMPLATE)
#
# # ------------------------------------------------------------------------------------------------------------------
# def __str__(self):
# return str(self.id_user)
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_api_reminders(self):
# """
# Returns the reminders only necessary for API endpoints.
# """
# data = json.loads(self.reminder)
#
# mobile_data = dict(data['common'])
# mobile_data.update(data['api'])
#
# return mobile_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_web_reminders(self):
# """
# Returns the reminders only necessary for web part.
# """
# data = json.loads(self.reminder)
#
# web_data = dict(data['common'])
# web_data.update(data['web'])
#
# return web_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def update_reminder(self, field, value):
# """
# Updates the reminder status.
# """
# data = json.loads(self.reminder)
#
# for key in data:
# if field in data[key]:
# data[key][field] = value
#
# self.reminder = json.dumps(data)
# self.save()
#
# Path: app/views/reminder_views.py
# def update_reminder(request):
# """
# Changes the reminder status.
# """
# if request.method == 'POST' and request.user.is_authenticated():
# form = UpdateReminderForm(request.POST)
#
# if form.is_valid():
# the_user = get_object_or_404(TheUser, id_user=request.user)
# the_user.update_reminder(form.cleaned_data['field'], form.cleaned_data['value'])
#
# return HttpResponse(status=200)
# return HttpResponse(status=404)
# return HttpResponse(status=404)
. Output only the next line. | self.assertEqual(response.status_code, 404) |
Based on the snippet: <|code_start|> url(r'read-book', read_book_views.open_book),
url(r'set-current-page', read_book_views.set_current_page),
# Add book urls.
url(r'generate-authors', upload_book_views.generate_authors),
url(r'generate-books', upload_book_views.generate_books),
url(r'generate-languages', upload_book_views.generate_languages),
url(r'^upload-book', upload_book_views.upload_book),
# Library urls.
url(r'categories', library_views.all_categories),
url(r'^category', library_views.selected_category, name='category_api'),
url(r'search-book', library_views.find_book),
# Selected book urls.
url(r'^book', selected_book_views.selected_book, name='book_api'),
url(r'^add-book-home', selected_book_views.add_book_to_home, name='add_book_home_api'),
url(r'^remove-book-home', selected_book_views.remove_book_from_home),
url(r'change-rating', selected_book_views.change_rating),
url(r'comment-add', selected_book_views.add_comment),
# Profile urls.
url(r'my-profile', profile_views.my_profile),
url(r'change-password', profile_views.change_password),
url(r'^upload-avatar', profile_views.upload_avatar),
# Other urls.
url(r'send-support-message', additional_views.save_support_message),
url(r'^get-reminders', reminder_views.get_reminders),
url(r'^update-reminder', reminder_views.update_reminder)
<|code_end|>
, predict the immediate next line with the help of imports:
from django.conf.urls import url
from .views import (index_views,
home_views,
library_views,
profile_views,
selected_book_views,
read_book_views,
upload_book_views,
additional_views,
reminder_views)
and context (classes, functions, sometimes code) from other files:
# Path: api/views/index_views.py
# def login_response(request, username):
# def user_login(request):
# def restore_data(request):
# def is_user_exists(request):
# def is_mail_exists(request):
# def sign_in(request):
#
# Path: api/views/home_views.py
# RANDOM_BOOKS_COUNT = 6
# def home(request):
# def recommendations(request):
# def uploaded_books(request):
#
# Path: api/views/library_views.py
# OUTPUT_BOOKS_PER_PAGE = 20
# def all_categories(request):
# def selected_category(request):
# def find_book(request):
#
# Path: api/views/profile_views.py
# AVATAR_WIDTH = 250
# def my_profile(request):
# def change_password(request):
# def upload_avatar(request):
#
# Path: api/views/selected_book_views.py
# def selected_book(request):
# def add_book_to_home(request):
# def remove_book_from_home(request):
# def change_rating(request):
# def add_comment(request):
#
# Path: api/views/read_book_views.py
# def open_book(request):
# def set_current_page(request):
#
# Path: api/views/upload_book_views.py
# def upload_book(request):
# def generate_authors(request):
# def generate_books(request):
# def generate_languages(request):
#
# Path: api/views/additional_views.py
# def save_support_message(request):
#
# Path: api/views/reminder_views.py
# def get_reminders(request):
# def update_reminder(request):
. Output only the next line. | ] |
Using the snippet: <|code_start|> url(r'read-book', read_book_views.open_book),
url(r'set-current-page', read_book_views.set_current_page),
# Add book urls.
url(r'generate-authors', upload_book_views.generate_authors),
url(r'generate-books', upload_book_views.generate_books),
url(r'generate-languages', upload_book_views.generate_languages),
url(r'^upload-book', upload_book_views.upload_book),
# Library urls.
url(r'categories', library_views.all_categories),
url(r'^category', library_views.selected_category, name='category_api'),
url(r'search-book', library_views.find_book),
# Selected book urls.
url(r'^book', selected_book_views.selected_book, name='book_api'),
url(r'^add-book-home', selected_book_views.add_book_to_home, name='add_book_home_api'),
url(r'^remove-book-home', selected_book_views.remove_book_from_home),
url(r'change-rating', selected_book_views.change_rating),
url(r'comment-add', selected_book_views.add_comment),
# Profile urls.
url(r'my-profile', profile_views.my_profile),
url(r'change-password', profile_views.change_password),
url(r'^upload-avatar', profile_views.upload_avatar),
# Other urls.
url(r'send-support-message', additional_views.save_support_message),
url(r'^get-reminders', reminder_views.get_reminders),
url(r'^update-reminder', reminder_views.update_reminder)
<|code_end|>
, determine the next line of code. You have imports:
from django.conf.urls import url
from .views import (index_views,
home_views,
library_views,
profile_views,
selected_book_views,
read_book_views,
upload_book_views,
additional_views,
reminder_views)
and context (class names, function names, or code) available:
# Path: api/views/index_views.py
# def login_response(request, username):
# def user_login(request):
# def restore_data(request):
# def is_user_exists(request):
# def is_mail_exists(request):
# def sign_in(request):
#
# Path: api/views/home_views.py
# RANDOM_BOOKS_COUNT = 6
# def home(request):
# def recommendations(request):
# def uploaded_books(request):
#
# Path: api/views/library_views.py
# OUTPUT_BOOKS_PER_PAGE = 20
# def all_categories(request):
# def selected_category(request):
# def find_book(request):
#
# Path: api/views/profile_views.py
# AVATAR_WIDTH = 250
# def my_profile(request):
# def change_password(request):
# def upload_avatar(request):
#
# Path: api/views/selected_book_views.py
# def selected_book(request):
# def add_book_to_home(request):
# def remove_book_from_home(request):
# def change_rating(request):
# def add_comment(request):
#
# Path: api/views/read_book_views.py
# def open_book(request):
# def set_current_page(request):
#
# Path: api/views/upload_book_views.py
# def upload_book(request):
# def generate_authors(request):
# def generate_books(request):
# def generate_languages(request):
#
# Path: api/views/additional_views.py
# def save_support_message(request):
#
# Path: api/views/reminder_views.py
# def get_reminders(request):
# def update_reminder(request):
. Output only the next line. | ] |
Here is a snippet: <|code_start|> url(r'read-book', read_book_views.open_book),
url(r'set-current-page', read_book_views.set_current_page),
# Add book urls.
url(r'generate-authors', upload_book_views.generate_authors),
url(r'generate-books', upload_book_views.generate_books),
url(r'generate-languages', upload_book_views.generate_languages),
url(r'^upload-book', upload_book_views.upload_book),
# Library urls.
url(r'categories', library_views.all_categories),
url(r'^category', library_views.selected_category, name='category_api'),
url(r'search-book', library_views.find_book),
# Selected book urls.
url(r'^book', selected_book_views.selected_book, name='book_api'),
url(r'^add-book-home', selected_book_views.add_book_to_home, name='add_book_home_api'),
url(r'^remove-book-home', selected_book_views.remove_book_from_home),
url(r'change-rating', selected_book_views.change_rating),
url(r'comment-add', selected_book_views.add_comment),
# Profile urls.
url(r'my-profile', profile_views.my_profile),
url(r'change-password', profile_views.change_password),
url(r'^upload-avatar', profile_views.upload_avatar),
# Other urls.
url(r'send-support-message', additional_views.save_support_message),
url(r'^get-reminders', reminder_views.get_reminders),
url(r'^update-reminder', reminder_views.update_reminder)
<|code_end|>
. Write the next line using the current file imports:
from django.conf.urls import url
from .views import (index_views,
home_views,
library_views,
profile_views,
selected_book_views,
read_book_views,
upload_book_views,
additional_views,
reminder_views)
and context from other files:
# Path: api/views/index_views.py
# def login_response(request, username):
# def user_login(request):
# def restore_data(request):
# def is_user_exists(request):
# def is_mail_exists(request):
# def sign_in(request):
#
# Path: api/views/home_views.py
# RANDOM_BOOKS_COUNT = 6
# def home(request):
# def recommendations(request):
# def uploaded_books(request):
#
# Path: api/views/library_views.py
# OUTPUT_BOOKS_PER_PAGE = 20
# def all_categories(request):
# def selected_category(request):
# def find_book(request):
#
# Path: api/views/profile_views.py
# AVATAR_WIDTH = 250
# def my_profile(request):
# def change_password(request):
# def upload_avatar(request):
#
# Path: api/views/selected_book_views.py
# def selected_book(request):
# def add_book_to_home(request):
# def remove_book_from_home(request):
# def change_rating(request):
# def add_comment(request):
#
# Path: api/views/read_book_views.py
# def open_book(request):
# def set_current_page(request):
#
# Path: api/views/upload_book_views.py
# def upload_book(request):
# def generate_authors(request):
# def generate_books(request):
# def generate_languages(request):
#
# Path: api/views/additional_views.py
# def save_support_message(request):
#
# Path: api/views/reminder_views.py
# def get_reminders(request):
# def update_reminder(request):
, which may include functions, classes, or code. Output only the next line. | ] |
Given snippet: <|code_start|># -*- coding: utf-8 -*-
AVATAR_WIDTH = 250
logger = logging.getLogger('changes')
# ----------------------------------------------------------------------------------------------------------------------
@api_view(['POST'])
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import logging
import random
from django.db import transaction
from django.core.exceptions import ValidationError
from django.shortcuts import get_object_or_404
from rest_framework import status
from rest_framework.decorators import api_view, parser_classes
from rest_framework.parsers import MultiPartParser
from rest_framework.response import Response
from ..serializers.model_serializers import ProfileSerializer
from ..serializers.request_serializers import ProfileRequest, ChangePasswordRequest, UploadAvatarRequest
from ..utils import invalid_data_response, validate_api_secret_key
from app.constants import Queues
from app.models import TheUser
from app.tasks import changed_password
from app.utils import resize_image
and context:
# Path: api/serializers/model_serializers.py
# class ProfileSerializer(serializers.Serializer):
# id = serializers.IntegerField()
# username = serializers.ReadOnlyField(source='id_user.username')
# email = serializers.ReadOnlyField(source='id_user.email')
# user_photo = serializers.SerializerMethodField('get_user_photo_url')
#
# def get_user_photo_url(self, obj):
# return obj.user_photo.url if obj.user_photo else static('/app/images/user.png')
#
# Path: api/serializers/request_serializers.py
# class ProfileRequest(TokenSerializer):
# pass
#
# class ChangePasswordRequest(TokenSerializer):
# prev_password = serializers.CharField(min_length=6,
# max_length=16)
# new_password = serializers.CharField(min_length=6,
# max_length=16)
#
# class UploadAvatarRequest(TokenSerializer):
# pass
#
# Path: api/utils.py
# def invalid_data_response(request_serializer):
# """
# Returns the error message depending on missing/invalid data in serializer.
# """
# return Response({'detail': request_serializer.errors,
# 'data': {}}, status=status.HTTP_400_BAD_REQUEST)
#
# def validate_api_secret_key(secret_key):
# """
# Checks if request received from known origin Application. If not returns 404 (not found) status
# """
# if secret_key != settings.API_SECRET_KEY:
# logger.info('Incorrect API key: "{}"'.format(secret_key))
# raise Http404('The API key isn\t correct!')
#
# Path: app/constants.py
# class Queues:
# default = 'default'
# high_priority = 'high_priority'
#
# Path: app/models.py
# class TheUser(models.Model):
# """
# Class for user objects in database.
# """
# REMINDER_TEMPLATE = json.dumps({
# "common": {
# "fb_page": True,
# "fb_group": True,
# "twitter": True,
# "vk": True,
# "disabled_all": False
# },
# "api": {
# "app_rate": True
# },
# "web": {
# "app_download": True,
# },
# })
#
# id_user = models.OneToOneField(User)
# user_photo = models.ImageField(blank=True, upload_to='user', storage=OverwriteStorage())
# auth_token = models.CharField(max_length=50, null=True, blank=True)
# subscription = models.BooleanField(default=True)
# reminder = models.CharField(max_length=256, null=False, default=REMINDER_TEMPLATE)
#
# # ------------------------------------------------------------------------------------------------------------------
# def __str__(self):
# return str(self.id_user)
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_api_reminders(self):
# """
# Returns the reminders only necessary for API endpoints.
# """
# data = json.loads(self.reminder)
#
# mobile_data = dict(data['common'])
# mobile_data.update(data['api'])
#
# return mobile_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_web_reminders(self):
# """
# Returns the reminders only necessary for web part.
# """
# data = json.loads(self.reminder)
#
# web_data = dict(data['common'])
# web_data.update(data['web'])
#
# return web_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def update_reminder(self, field, value):
# """
# Updates the reminder status.
# """
# data = json.loads(self.reminder)
#
# for key in data:
# if field in data[key]:
# data[key][field] = value
#
# self.reminder = json.dumps(data)
# self.save()
#
# Path: app/tasks.py
# @shared_task
# def changed_password(username, recipient):
# """
# Celery task for sending mail, to notify user about password changed.
#
# :param str username: The restored username.
# :param str recipient: The mail recipient.
# """
# html_content = render_to_string(
# 'mails/password_changed.html',
# {'username': username, 'email_host_user': settings.EMAIL_HOST_USER}
# )
# text_content = strip_tags(html_content)
# subject = 'Изменение пароля аккаунта - plamber.com.ua'
#
# email = EmailMultiAlternatives(subject, text_content, to=[recipient])
# email.attach_alternative(html_content, 'text/html')
# email.send()
#
# logger.info("Sent changed password message to '{}'.".format(recipient))
#
# Path: app/utils.py
# def resize_image(path, width):
# """
# Resizes the image.
#
# :param str path: The path to the image file.
# :param int width: The width of the output image.
# """
# try:
# img = Image.open(path)
#
# ratio = width / float(img.width)
# height = int(float(img.height) * float(ratio))
#
# new_img = img.resize((width, height), Image.ANTIALIAS)
# new_img.save(path)
#
# except IOError:
# pass
which might include code, classes, or functions. Output only the next line. | def my_profile(request): |
Predict the next line for this snippet: <|code_start|># -*- coding: utf-8 -*-
AVATAR_WIDTH = 250
logger = logging.getLogger('changes')
# ----------------------------------------------------------------------------------------------------------------------
@api_view(['POST'])
<|code_end|>
with the help of current file imports:
import logging
import random
from django.db import transaction
from django.core.exceptions import ValidationError
from django.shortcuts import get_object_or_404
from rest_framework import status
from rest_framework.decorators import api_view, parser_classes
from rest_framework.parsers import MultiPartParser
from rest_framework.response import Response
from ..serializers.model_serializers import ProfileSerializer
from ..serializers.request_serializers import ProfileRequest, ChangePasswordRequest, UploadAvatarRequest
from ..utils import invalid_data_response, validate_api_secret_key
from app.constants import Queues
from app.models import TheUser
from app.tasks import changed_password
from app.utils import resize_image
and context from other files:
# Path: api/serializers/model_serializers.py
# class ProfileSerializer(serializers.Serializer):
# id = serializers.IntegerField()
# username = serializers.ReadOnlyField(source='id_user.username')
# email = serializers.ReadOnlyField(source='id_user.email')
# user_photo = serializers.SerializerMethodField('get_user_photo_url')
#
# def get_user_photo_url(self, obj):
# return obj.user_photo.url if obj.user_photo else static('/app/images/user.png')
#
# Path: api/serializers/request_serializers.py
# class ProfileRequest(TokenSerializer):
# pass
#
# class ChangePasswordRequest(TokenSerializer):
# prev_password = serializers.CharField(min_length=6,
# max_length=16)
# new_password = serializers.CharField(min_length=6,
# max_length=16)
#
# class UploadAvatarRequest(TokenSerializer):
# pass
#
# Path: api/utils.py
# def invalid_data_response(request_serializer):
# """
# Returns the error message depending on missing/invalid data in serializer.
# """
# return Response({'detail': request_serializer.errors,
# 'data': {}}, status=status.HTTP_400_BAD_REQUEST)
#
# def validate_api_secret_key(secret_key):
# """
# Checks if request received from known origin Application. If not returns 404 (not found) status
# """
# if secret_key != settings.API_SECRET_KEY:
# logger.info('Incorrect API key: "{}"'.format(secret_key))
# raise Http404('The API key isn\t correct!')
#
# Path: app/constants.py
# class Queues:
# default = 'default'
# high_priority = 'high_priority'
#
# Path: app/models.py
# class TheUser(models.Model):
# """
# Class for user objects in database.
# """
# REMINDER_TEMPLATE = json.dumps({
# "common": {
# "fb_page": True,
# "fb_group": True,
# "twitter": True,
# "vk": True,
# "disabled_all": False
# },
# "api": {
# "app_rate": True
# },
# "web": {
# "app_download": True,
# },
# })
#
# id_user = models.OneToOneField(User)
# user_photo = models.ImageField(blank=True, upload_to='user', storage=OverwriteStorage())
# auth_token = models.CharField(max_length=50, null=True, blank=True)
# subscription = models.BooleanField(default=True)
# reminder = models.CharField(max_length=256, null=False, default=REMINDER_TEMPLATE)
#
# # ------------------------------------------------------------------------------------------------------------------
# def __str__(self):
# return str(self.id_user)
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_api_reminders(self):
# """
# Returns the reminders only necessary for API endpoints.
# """
# data = json.loads(self.reminder)
#
# mobile_data = dict(data['common'])
# mobile_data.update(data['api'])
#
# return mobile_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_web_reminders(self):
# """
# Returns the reminders only necessary for web part.
# """
# data = json.loads(self.reminder)
#
# web_data = dict(data['common'])
# web_data.update(data['web'])
#
# return web_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def update_reminder(self, field, value):
# """
# Updates the reminder status.
# """
# data = json.loads(self.reminder)
#
# for key in data:
# if field in data[key]:
# data[key][field] = value
#
# self.reminder = json.dumps(data)
# self.save()
#
# Path: app/tasks.py
# @shared_task
# def changed_password(username, recipient):
# """
# Celery task for sending mail, to notify user about password changed.
#
# :param str username: The restored username.
# :param str recipient: The mail recipient.
# """
# html_content = render_to_string(
# 'mails/password_changed.html',
# {'username': username, 'email_host_user': settings.EMAIL_HOST_USER}
# )
# text_content = strip_tags(html_content)
# subject = 'Изменение пароля аккаунта - plamber.com.ua'
#
# email = EmailMultiAlternatives(subject, text_content, to=[recipient])
# email.attach_alternative(html_content, 'text/html')
# email.send()
#
# logger.info("Sent changed password message to '{}'.".format(recipient))
#
# Path: app/utils.py
# def resize_image(path, width):
# """
# Resizes the image.
#
# :param str path: The path to the image file.
# :param int width: The width of the output image.
# """
# try:
# img = Image.open(path)
#
# ratio = width / float(img.width)
# height = int(float(img.height) * float(ratio))
#
# new_img = img.resize((width, height), Image.ANTIALIAS)
# new_img.save(path)
#
# except IOError:
# pass
, which may contain function names, class names, or code. Output only the next line. | def my_profile(request): |
Based on the snippet: <|code_start|># -*- coding: utf-8 -*-
AVATAR_WIDTH = 250
logger = logging.getLogger('changes')
# ----------------------------------------------------------------------------------------------------------------------
@api_view(['POST'])
<|code_end|>
, predict the immediate next line with the help of imports:
import logging
import random
from django.db import transaction
from django.core.exceptions import ValidationError
from django.shortcuts import get_object_or_404
from rest_framework import status
from rest_framework.decorators import api_view, parser_classes
from rest_framework.parsers import MultiPartParser
from rest_framework.response import Response
from ..serializers.model_serializers import ProfileSerializer
from ..serializers.request_serializers import ProfileRequest, ChangePasswordRequest, UploadAvatarRequest
from ..utils import invalid_data_response, validate_api_secret_key
from app.constants import Queues
from app.models import TheUser
from app.tasks import changed_password
from app.utils import resize_image
and context (classes, functions, sometimes code) from other files:
# Path: api/serializers/model_serializers.py
# class ProfileSerializer(serializers.Serializer):
# id = serializers.IntegerField()
# username = serializers.ReadOnlyField(source='id_user.username')
# email = serializers.ReadOnlyField(source='id_user.email')
# user_photo = serializers.SerializerMethodField('get_user_photo_url')
#
# def get_user_photo_url(self, obj):
# return obj.user_photo.url if obj.user_photo else static('/app/images/user.png')
#
# Path: api/serializers/request_serializers.py
# class ProfileRequest(TokenSerializer):
# pass
#
# class ChangePasswordRequest(TokenSerializer):
# prev_password = serializers.CharField(min_length=6,
# max_length=16)
# new_password = serializers.CharField(min_length=6,
# max_length=16)
#
# class UploadAvatarRequest(TokenSerializer):
# pass
#
# Path: api/utils.py
# def invalid_data_response(request_serializer):
# """
# Returns the error message depending on missing/invalid data in serializer.
# """
# return Response({'detail': request_serializer.errors,
# 'data': {}}, status=status.HTTP_400_BAD_REQUEST)
#
# def validate_api_secret_key(secret_key):
# """
# Checks if request received from known origin Application. If not returns 404 (not found) status
# """
# if secret_key != settings.API_SECRET_KEY:
# logger.info('Incorrect API key: "{}"'.format(secret_key))
# raise Http404('The API key isn\t correct!')
#
# Path: app/constants.py
# class Queues:
# default = 'default'
# high_priority = 'high_priority'
#
# Path: app/models.py
# class TheUser(models.Model):
# """
# Class for user objects in database.
# """
# REMINDER_TEMPLATE = json.dumps({
# "common": {
# "fb_page": True,
# "fb_group": True,
# "twitter": True,
# "vk": True,
# "disabled_all": False
# },
# "api": {
# "app_rate": True
# },
# "web": {
# "app_download": True,
# },
# })
#
# id_user = models.OneToOneField(User)
# user_photo = models.ImageField(blank=True, upload_to='user', storage=OverwriteStorage())
# auth_token = models.CharField(max_length=50, null=True, blank=True)
# subscription = models.BooleanField(default=True)
# reminder = models.CharField(max_length=256, null=False, default=REMINDER_TEMPLATE)
#
# # ------------------------------------------------------------------------------------------------------------------
# def __str__(self):
# return str(self.id_user)
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_api_reminders(self):
# """
# Returns the reminders only necessary for API endpoints.
# """
# data = json.loads(self.reminder)
#
# mobile_data = dict(data['common'])
# mobile_data.update(data['api'])
#
# return mobile_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_web_reminders(self):
# """
# Returns the reminders only necessary for web part.
# """
# data = json.loads(self.reminder)
#
# web_data = dict(data['common'])
# web_data.update(data['web'])
#
# return web_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def update_reminder(self, field, value):
# """
# Updates the reminder status.
# """
# data = json.loads(self.reminder)
#
# for key in data:
# if field in data[key]:
# data[key][field] = value
#
# self.reminder = json.dumps(data)
# self.save()
#
# Path: app/tasks.py
# @shared_task
# def changed_password(username, recipient):
# """
# Celery task for sending mail, to notify user about password changed.
#
# :param str username: The restored username.
# :param str recipient: The mail recipient.
# """
# html_content = render_to_string(
# 'mails/password_changed.html',
# {'username': username, 'email_host_user': settings.EMAIL_HOST_USER}
# )
# text_content = strip_tags(html_content)
# subject = 'Изменение пароля аккаунта - plamber.com.ua'
#
# email = EmailMultiAlternatives(subject, text_content, to=[recipient])
# email.attach_alternative(html_content, 'text/html')
# email.send()
#
# logger.info("Sent changed password message to '{}'.".format(recipient))
#
# Path: app/utils.py
# def resize_image(path, width):
# """
# Resizes the image.
#
# :param str path: The path to the image file.
# :param int width: The width of the output image.
# """
# try:
# img = Image.open(path)
#
# ratio = width / float(img.width)
# height = int(float(img.height) * float(ratio))
#
# new_img = img.resize((width, height), Image.ANTIALIAS)
# new_img.save(path)
#
# except IOError:
# pass
. Output only the next line. | def my_profile(request): |
Predict the next line for this snippet: <|code_start|># -*- coding: utf-8 -*-
AVATAR_WIDTH = 250
logger = logging.getLogger('changes')
# ----------------------------------------------------------------------------------------------------------------------
@api_view(['POST'])
<|code_end|>
with the help of current file imports:
import logging
import random
from django.db import transaction
from django.core.exceptions import ValidationError
from django.shortcuts import get_object_or_404
from rest_framework import status
from rest_framework.decorators import api_view, parser_classes
from rest_framework.parsers import MultiPartParser
from rest_framework.response import Response
from ..serializers.model_serializers import ProfileSerializer
from ..serializers.request_serializers import ProfileRequest, ChangePasswordRequest, UploadAvatarRequest
from ..utils import invalid_data_response, validate_api_secret_key
from app.constants import Queues
from app.models import TheUser
from app.tasks import changed_password
from app.utils import resize_image
and context from other files:
# Path: api/serializers/model_serializers.py
# class ProfileSerializer(serializers.Serializer):
# id = serializers.IntegerField()
# username = serializers.ReadOnlyField(source='id_user.username')
# email = serializers.ReadOnlyField(source='id_user.email')
# user_photo = serializers.SerializerMethodField('get_user_photo_url')
#
# def get_user_photo_url(self, obj):
# return obj.user_photo.url if obj.user_photo else static('/app/images/user.png')
#
# Path: api/serializers/request_serializers.py
# class ProfileRequest(TokenSerializer):
# pass
#
# class ChangePasswordRequest(TokenSerializer):
# prev_password = serializers.CharField(min_length=6,
# max_length=16)
# new_password = serializers.CharField(min_length=6,
# max_length=16)
#
# class UploadAvatarRequest(TokenSerializer):
# pass
#
# Path: api/utils.py
# def invalid_data_response(request_serializer):
# """
# Returns the error message depending on missing/invalid data in serializer.
# """
# return Response({'detail': request_serializer.errors,
# 'data': {}}, status=status.HTTP_400_BAD_REQUEST)
#
# def validate_api_secret_key(secret_key):
# """
# Checks if request received from known origin Application. If not returns 404 (not found) status
# """
# if secret_key != settings.API_SECRET_KEY:
# logger.info('Incorrect API key: "{}"'.format(secret_key))
# raise Http404('The API key isn\t correct!')
#
# Path: app/constants.py
# class Queues:
# default = 'default'
# high_priority = 'high_priority'
#
# Path: app/models.py
# class TheUser(models.Model):
# """
# Class for user objects in database.
# """
# REMINDER_TEMPLATE = json.dumps({
# "common": {
# "fb_page": True,
# "fb_group": True,
# "twitter": True,
# "vk": True,
# "disabled_all": False
# },
# "api": {
# "app_rate": True
# },
# "web": {
# "app_download": True,
# },
# })
#
# id_user = models.OneToOneField(User)
# user_photo = models.ImageField(blank=True, upload_to='user', storage=OverwriteStorage())
# auth_token = models.CharField(max_length=50, null=True, blank=True)
# subscription = models.BooleanField(default=True)
# reminder = models.CharField(max_length=256, null=False, default=REMINDER_TEMPLATE)
#
# # ------------------------------------------------------------------------------------------------------------------
# def __str__(self):
# return str(self.id_user)
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_api_reminders(self):
# """
# Returns the reminders only necessary for API endpoints.
# """
# data = json.loads(self.reminder)
#
# mobile_data = dict(data['common'])
# mobile_data.update(data['api'])
#
# return mobile_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_web_reminders(self):
# """
# Returns the reminders only necessary for web part.
# """
# data = json.loads(self.reminder)
#
# web_data = dict(data['common'])
# web_data.update(data['web'])
#
# return web_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def update_reminder(self, field, value):
# """
# Updates the reminder status.
# """
# data = json.loads(self.reminder)
#
# for key in data:
# if field in data[key]:
# data[key][field] = value
#
# self.reminder = json.dumps(data)
# self.save()
#
# Path: app/tasks.py
# @shared_task
# def changed_password(username, recipient):
# """
# Celery task for sending mail, to notify user about password changed.
#
# :param str username: The restored username.
# :param str recipient: The mail recipient.
# """
# html_content = render_to_string(
# 'mails/password_changed.html',
# {'username': username, 'email_host_user': settings.EMAIL_HOST_USER}
# )
# text_content = strip_tags(html_content)
# subject = 'Изменение пароля аккаунта - plamber.com.ua'
#
# email = EmailMultiAlternatives(subject, text_content, to=[recipient])
# email.attach_alternative(html_content, 'text/html')
# email.send()
#
# logger.info("Sent changed password message to '{}'.".format(recipient))
#
# Path: app/utils.py
# def resize_image(path, width):
# """
# Resizes the image.
#
# :param str path: The path to the image file.
# :param int width: The width of the output image.
# """
# try:
# img = Image.open(path)
#
# ratio = width / float(img.width)
# height = int(float(img.height) * float(ratio))
#
# new_img = img.resize((width, height), Image.ANTIALIAS)
# new_img.save(path)
#
# except IOError:
# pass
, which may contain function names, class names, or code. Output only the next line. | def my_profile(request): |
Using the snippet: <|code_start|># -*- coding: utf-8 -*-
AVATAR_WIDTH = 250
logger = logging.getLogger('changes')
# ----------------------------------------------------------------------------------------------------------------------
@api_view(['POST'])
<|code_end|>
, determine the next line of code. You have imports:
import logging
import random
from django.db import transaction
from django.core.exceptions import ValidationError
from django.shortcuts import get_object_or_404
from rest_framework import status
from rest_framework.decorators import api_view, parser_classes
from rest_framework.parsers import MultiPartParser
from rest_framework.response import Response
from ..serializers.model_serializers import ProfileSerializer
from ..serializers.request_serializers import ProfileRequest, ChangePasswordRequest, UploadAvatarRequest
from ..utils import invalid_data_response, validate_api_secret_key
from app.constants import Queues
from app.models import TheUser
from app.tasks import changed_password
from app.utils import resize_image
and context (class names, function names, or code) available:
# Path: api/serializers/model_serializers.py
# class ProfileSerializer(serializers.Serializer):
# id = serializers.IntegerField()
# username = serializers.ReadOnlyField(source='id_user.username')
# email = serializers.ReadOnlyField(source='id_user.email')
# user_photo = serializers.SerializerMethodField('get_user_photo_url')
#
# def get_user_photo_url(self, obj):
# return obj.user_photo.url if obj.user_photo else static('/app/images/user.png')
#
# Path: api/serializers/request_serializers.py
# class ProfileRequest(TokenSerializer):
# pass
#
# class ChangePasswordRequest(TokenSerializer):
# prev_password = serializers.CharField(min_length=6,
# max_length=16)
# new_password = serializers.CharField(min_length=6,
# max_length=16)
#
# class UploadAvatarRequest(TokenSerializer):
# pass
#
# Path: api/utils.py
# def invalid_data_response(request_serializer):
# """
# Returns the error message depending on missing/invalid data in serializer.
# """
# return Response({'detail': request_serializer.errors,
# 'data': {}}, status=status.HTTP_400_BAD_REQUEST)
#
# def validate_api_secret_key(secret_key):
# """
# Checks if request received from known origin Application. If not returns 404 (not found) status
# """
# if secret_key != settings.API_SECRET_KEY:
# logger.info('Incorrect API key: "{}"'.format(secret_key))
# raise Http404('The API key isn\t correct!')
#
# Path: app/constants.py
# class Queues:
# default = 'default'
# high_priority = 'high_priority'
#
# Path: app/models.py
# class TheUser(models.Model):
# """
# Class for user objects in database.
# """
# REMINDER_TEMPLATE = json.dumps({
# "common": {
# "fb_page": True,
# "fb_group": True,
# "twitter": True,
# "vk": True,
# "disabled_all": False
# },
# "api": {
# "app_rate": True
# },
# "web": {
# "app_download": True,
# },
# })
#
# id_user = models.OneToOneField(User)
# user_photo = models.ImageField(blank=True, upload_to='user', storage=OverwriteStorage())
# auth_token = models.CharField(max_length=50, null=True, blank=True)
# subscription = models.BooleanField(default=True)
# reminder = models.CharField(max_length=256, null=False, default=REMINDER_TEMPLATE)
#
# # ------------------------------------------------------------------------------------------------------------------
# def __str__(self):
# return str(self.id_user)
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_api_reminders(self):
# """
# Returns the reminders only necessary for API endpoints.
# """
# data = json.loads(self.reminder)
#
# mobile_data = dict(data['common'])
# mobile_data.update(data['api'])
#
# return mobile_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_web_reminders(self):
# """
# Returns the reminders only necessary for web part.
# """
# data = json.loads(self.reminder)
#
# web_data = dict(data['common'])
# web_data.update(data['web'])
#
# return web_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def update_reminder(self, field, value):
# """
# Updates the reminder status.
# """
# data = json.loads(self.reminder)
#
# for key in data:
# if field in data[key]:
# data[key][field] = value
#
# self.reminder = json.dumps(data)
# self.save()
#
# Path: app/tasks.py
# @shared_task
# def changed_password(username, recipient):
# """
# Celery task for sending mail, to notify user about password changed.
#
# :param str username: The restored username.
# :param str recipient: The mail recipient.
# """
# html_content = render_to_string(
# 'mails/password_changed.html',
# {'username': username, 'email_host_user': settings.EMAIL_HOST_USER}
# )
# text_content = strip_tags(html_content)
# subject = 'Изменение пароля аккаунта - plamber.com.ua'
#
# email = EmailMultiAlternatives(subject, text_content, to=[recipient])
# email.attach_alternative(html_content, 'text/html')
# email.send()
#
# logger.info("Sent changed password message to '{}'.".format(recipient))
#
# Path: app/utils.py
# def resize_image(path, width):
# """
# Resizes the image.
#
# :param str path: The path to the image file.
# :param int width: The width of the output image.
# """
# try:
# img = Image.open(path)
#
# ratio = width / float(img.width)
# height = int(float(img.height) * float(ratio))
#
# new_img = img.resize((width, height), Image.ANTIALIAS)
# new_img.save(path)
#
# except IOError:
# pass
. Output only the next line. | def my_profile(request): |
Next line prediction: <|code_start|># -*- coding: utf-8 -*-
AVATAR_WIDTH = 250
logger = logging.getLogger('changes')
# ----------------------------------------------------------------------------------------------------------------------
@api_view(['POST'])
<|code_end|>
. Use current file imports:
(import logging
import random
from django.db import transaction
from django.core.exceptions import ValidationError
from django.shortcuts import get_object_or_404
from rest_framework import status
from rest_framework.decorators import api_view, parser_classes
from rest_framework.parsers import MultiPartParser
from rest_framework.response import Response
from ..serializers.model_serializers import ProfileSerializer
from ..serializers.request_serializers import ProfileRequest, ChangePasswordRequest, UploadAvatarRequest
from ..utils import invalid_data_response, validate_api_secret_key
from app.constants import Queues
from app.models import TheUser
from app.tasks import changed_password
from app.utils import resize_image)
and context including class names, function names, or small code snippets from other files:
# Path: api/serializers/model_serializers.py
# class ProfileSerializer(serializers.Serializer):
# id = serializers.IntegerField()
# username = serializers.ReadOnlyField(source='id_user.username')
# email = serializers.ReadOnlyField(source='id_user.email')
# user_photo = serializers.SerializerMethodField('get_user_photo_url')
#
# def get_user_photo_url(self, obj):
# return obj.user_photo.url if obj.user_photo else static('/app/images/user.png')
#
# Path: api/serializers/request_serializers.py
# class ProfileRequest(TokenSerializer):
# pass
#
# class ChangePasswordRequest(TokenSerializer):
# prev_password = serializers.CharField(min_length=6,
# max_length=16)
# new_password = serializers.CharField(min_length=6,
# max_length=16)
#
# class UploadAvatarRequest(TokenSerializer):
# pass
#
# Path: api/utils.py
# def invalid_data_response(request_serializer):
# """
# Returns the error message depending on missing/invalid data in serializer.
# """
# return Response({'detail': request_serializer.errors,
# 'data': {}}, status=status.HTTP_400_BAD_REQUEST)
#
# def validate_api_secret_key(secret_key):
# """
# Checks if request received from known origin Application. If not returns 404 (not found) status
# """
# if secret_key != settings.API_SECRET_KEY:
# logger.info('Incorrect API key: "{}"'.format(secret_key))
# raise Http404('The API key isn\t correct!')
#
# Path: app/constants.py
# class Queues:
# default = 'default'
# high_priority = 'high_priority'
#
# Path: app/models.py
# class TheUser(models.Model):
# """
# Class for user objects in database.
# """
# REMINDER_TEMPLATE = json.dumps({
# "common": {
# "fb_page": True,
# "fb_group": True,
# "twitter": True,
# "vk": True,
# "disabled_all": False
# },
# "api": {
# "app_rate": True
# },
# "web": {
# "app_download": True,
# },
# })
#
# id_user = models.OneToOneField(User)
# user_photo = models.ImageField(blank=True, upload_to='user', storage=OverwriteStorage())
# auth_token = models.CharField(max_length=50, null=True, blank=True)
# subscription = models.BooleanField(default=True)
# reminder = models.CharField(max_length=256, null=False, default=REMINDER_TEMPLATE)
#
# # ------------------------------------------------------------------------------------------------------------------
# def __str__(self):
# return str(self.id_user)
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_api_reminders(self):
# """
# Returns the reminders only necessary for API endpoints.
# """
# data = json.loads(self.reminder)
#
# mobile_data = dict(data['common'])
# mobile_data.update(data['api'])
#
# return mobile_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_web_reminders(self):
# """
# Returns the reminders only necessary for web part.
# """
# data = json.loads(self.reminder)
#
# web_data = dict(data['common'])
# web_data.update(data['web'])
#
# return web_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def update_reminder(self, field, value):
# """
# Updates the reminder status.
# """
# data = json.loads(self.reminder)
#
# for key in data:
# if field in data[key]:
# data[key][field] = value
#
# self.reminder = json.dumps(data)
# self.save()
#
# Path: app/tasks.py
# @shared_task
# def changed_password(username, recipient):
# """
# Celery task for sending mail, to notify user about password changed.
#
# :param str username: The restored username.
# :param str recipient: The mail recipient.
# """
# html_content = render_to_string(
# 'mails/password_changed.html',
# {'username': username, 'email_host_user': settings.EMAIL_HOST_USER}
# )
# text_content = strip_tags(html_content)
# subject = 'Изменение пароля аккаунта - plamber.com.ua'
#
# email = EmailMultiAlternatives(subject, text_content, to=[recipient])
# email.attach_alternative(html_content, 'text/html')
# email.send()
#
# logger.info("Sent changed password message to '{}'.".format(recipient))
#
# Path: app/utils.py
# def resize_image(path, width):
# """
# Resizes the image.
#
# :param str path: The path to the image file.
# :param int width: The width of the output image.
# """
# try:
# img = Image.open(path)
#
# ratio = width / float(img.width)
# height = int(float(img.height) * float(ratio))
#
# new_img = img.resize((width, height), Image.ANTIALIAS)
# new_img.save(path)
#
# except IOError:
# pass
. Output only the next line. | def my_profile(request): |
Given snippet: <|code_start|> def setUpTestData(cls):
shutil.copy(os.path.join(TEST_DATA_DIR, 'test.txt'), DESTINATION_DIR.format('test.txt'))
shutil.copy(os.path.join(TEST_DATA_DIR, 'test.xml'), DESTINATION_DIR.format('test.xml'))
cls.user = User.objects.create_user(username='additional', email='logout@user.com', password='Dummy#password')
cls.user.date_joined = cls.user.date_joined.replace(microsecond=0)
cls.user.save()
cls.anonymous_client = Client()
cls.logged_client = Client()
cls.logged_client.login(username='additional', password='Dummy#password')
# ------------------------------------------------------------------------------------------------------------------
@classmethod
def tearDownClass(cls):
os.remove(DESTINATION_DIR.format('test.txt'))
os.remove(DESTINATION_DIR.format('test.xml'))
# ------------------------------------------------------------------------------------------------------------------
def test_user_logout_not_post(self):
response = self.logged_client.get(reverse('logout'))
self.assertEqual(response.resolver_match.func, user_logout)
self.assertEqual(response.status_code, 404)
# ------------------------------------------------------------------------------------------------------------------
def test_user_logout_success(self):
logged_user = auth.get_user(self.logged_client)
self.assertEqual(logged_user, self.user)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import shutil
from django.conf import settings
from django.contrib import auth
from django.contrib.auth.models import User, AnonymousUser
from django.shortcuts import reverse
from django.test import TestCase, Client
from ...models import TheUser
from ...views.additional_views import user_logout, share_txt, share_xml, unsubscribe
and context:
# Path: app/models.py
# class TheUser(models.Model):
# """
# Class for user objects in database.
# """
# REMINDER_TEMPLATE = json.dumps({
# "common": {
# "fb_page": True,
# "fb_group": True,
# "twitter": True,
# "vk": True,
# "disabled_all": False
# },
# "api": {
# "app_rate": True
# },
# "web": {
# "app_download": True,
# },
# })
#
# id_user = models.OneToOneField(User)
# user_photo = models.ImageField(blank=True, upload_to='user', storage=OverwriteStorage())
# auth_token = models.CharField(max_length=50, null=True, blank=True)
# subscription = models.BooleanField(default=True)
# reminder = models.CharField(max_length=256, null=False, default=REMINDER_TEMPLATE)
#
# # ------------------------------------------------------------------------------------------------------------------
# def __str__(self):
# return str(self.id_user)
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_api_reminders(self):
# """
# Returns the reminders only necessary for API endpoints.
# """
# data = json.loads(self.reminder)
#
# mobile_data = dict(data['common'])
# mobile_data.update(data['api'])
#
# return mobile_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_web_reminders(self):
# """
# Returns the reminders only necessary for web part.
# """
# data = json.loads(self.reminder)
#
# web_data = dict(data['common'])
# web_data.update(data['web'])
#
# return web_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def update_reminder(self, field, value):
# """
# Updates the reminder status.
# """
# data = json.loads(self.reminder)
#
# for key in data:
# if field in data[key]:
# data[key][field] = value
#
# self.reminder = json.dumps(data)
# self.save()
#
# Path: app/views/additional_views.py
# @process_method('POST', 404)
# def user_logout(request):
# """
# Closes session, returns index page.
# """
# logger.info("User '{}' logged out.".format(request.user))
# logout(request)
# return redirect('index')
#
# def share_txt(request, file):
# """
# Returns the shared .txt files.
# """
# path = settings.BASE_DIR + '/Plamber/additional/{}'.format(file)
#
# if os.path.exists(path):
# with open(path, 'r', encoding='utf-8') as data:
# return HttpResponse(data.read(), content_type='text/plain')
#
# return HttpResponse(status=404)
#
# def share_xml(request, file):
# """
# Returns the shared .xml files.
# """
# path = settings.BASE_DIR + '/Plamber/additional/{}'.format(file)
#
# if os.path.exists(path):
# with open(path, 'r', encoding='utf-8') as data:
# return HttpResponse(data.read(), content_type='application/xml')
#
# return HttpResponse(status=404)
#
# def unsubscribe(request, token):
# """
# Removes the user from the list of blog subscribers.
# """
# username, date = token.split('-')
# user = get_object_or_404(TheUser, id_user__username=username,
# id_user__date_joined=datetime.fromtimestamp(float(date)))
# user.subscription = False
# user.save()
#
# return render(request, 'additional/unsubscribe.html', context={'user': user})
which might include code, classes, or functions. Output only the next line. | self.assertTrue(logged_user.is_authenticated()) |
Given snippet: <|code_start|># -*- coding: utf-8 -*-
TEST_DIR = os.path.dirname(os.path.abspath(__file__))
TEST_DATA_DIR = os.path.join(TEST_DIR, '../fixtures')
DESTINATION_DIR = os.path.join(settings.BASE_DIR, 'Plamber/additional/{}')
# ----------------------------------------------------------------------------------------------------------------------
class AdditionalViewsTest(TestCase):
# ------------------------------------------------------------------------------------------------------------------
@classmethod
def setUpTestData(cls):
shutil.copy(os.path.join(TEST_DATA_DIR, 'test.txt'), DESTINATION_DIR.format('test.txt'))
shutil.copy(os.path.join(TEST_DATA_DIR, 'test.xml'), DESTINATION_DIR.format('test.xml'))
cls.user = User.objects.create_user(username='additional', email='logout@user.com', password='Dummy#password')
cls.user.date_joined = cls.user.date_joined.replace(microsecond=0)
cls.user.save()
cls.anonymous_client = Client()
cls.logged_client = Client()
cls.logged_client.login(username='additional', password='Dummy#password')
# ------------------------------------------------------------------------------------------------------------------
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import shutil
from django.conf import settings
from django.contrib import auth
from django.contrib.auth.models import User, AnonymousUser
from django.shortcuts import reverse
from django.test import TestCase, Client
from ...models import TheUser
from ...views.additional_views import user_logout, share_txt, share_xml, unsubscribe
and context:
# Path: app/models.py
# class TheUser(models.Model):
# """
# Class for user objects in database.
# """
# REMINDER_TEMPLATE = json.dumps({
# "common": {
# "fb_page": True,
# "fb_group": True,
# "twitter": True,
# "vk": True,
# "disabled_all": False
# },
# "api": {
# "app_rate": True
# },
# "web": {
# "app_download": True,
# },
# })
#
# id_user = models.OneToOneField(User)
# user_photo = models.ImageField(blank=True, upload_to='user', storage=OverwriteStorage())
# auth_token = models.CharField(max_length=50, null=True, blank=True)
# subscription = models.BooleanField(default=True)
# reminder = models.CharField(max_length=256, null=False, default=REMINDER_TEMPLATE)
#
# # ------------------------------------------------------------------------------------------------------------------
# def __str__(self):
# return str(self.id_user)
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_api_reminders(self):
# """
# Returns the reminders only necessary for API endpoints.
# """
# data = json.loads(self.reminder)
#
# mobile_data = dict(data['common'])
# mobile_data.update(data['api'])
#
# return mobile_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_web_reminders(self):
# """
# Returns the reminders only necessary for web part.
# """
# data = json.loads(self.reminder)
#
# web_data = dict(data['common'])
# web_data.update(data['web'])
#
# return web_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def update_reminder(self, field, value):
# """
# Updates the reminder status.
# """
# data = json.loads(self.reminder)
#
# for key in data:
# if field in data[key]:
# data[key][field] = value
#
# self.reminder = json.dumps(data)
# self.save()
#
# Path: app/views/additional_views.py
# @process_method('POST', 404)
# def user_logout(request):
# """
# Closes session, returns index page.
# """
# logger.info("User '{}' logged out.".format(request.user))
# logout(request)
# return redirect('index')
#
# def share_txt(request, file):
# """
# Returns the shared .txt files.
# """
# path = settings.BASE_DIR + '/Plamber/additional/{}'.format(file)
#
# if os.path.exists(path):
# with open(path, 'r', encoding='utf-8') as data:
# return HttpResponse(data.read(), content_type='text/plain')
#
# return HttpResponse(status=404)
#
# def share_xml(request, file):
# """
# Returns the shared .xml files.
# """
# path = settings.BASE_DIR + '/Plamber/additional/{}'.format(file)
#
# if os.path.exists(path):
# with open(path, 'r', encoding='utf-8') as data:
# return HttpResponse(data.read(), content_type='application/xml')
#
# return HttpResponse(status=404)
#
# def unsubscribe(request, token):
# """
# Removes the user from the list of blog subscribers.
# """
# username, date = token.split('-')
# user = get_object_or_404(TheUser, id_user__username=username,
# id_user__date_joined=datetime.fromtimestamp(float(date)))
# user.subscription = False
# user.save()
#
# return render(request, 'additional/unsubscribe.html', context={'user': user})
which might include code, classes, or functions. Output only the next line. | @classmethod |
Given snippet: <|code_start|> cls.anonymous_client = Client()
cls.logged_client = Client()
cls.logged_client.login(username='additional', password='Dummy#password')
# ------------------------------------------------------------------------------------------------------------------
@classmethod
def tearDownClass(cls):
os.remove(DESTINATION_DIR.format('test.txt'))
os.remove(DESTINATION_DIR.format('test.xml'))
# ------------------------------------------------------------------------------------------------------------------
def test_user_logout_not_post(self):
response = self.logged_client.get(reverse('logout'))
self.assertEqual(response.resolver_match.func, user_logout)
self.assertEqual(response.status_code, 404)
# ------------------------------------------------------------------------------------------------------------------
def test_user_logout_success(self):
logged_user = auth.get_user(self.logged_client)
self.assertEqual(logged_user, self.user)
self.assertTrue(logged_user.is_authenticated())
response = self.logged_client.post(reverse('logout'))
logged_user = auth.get_user(self.logged_client)
self.assertTrue(isinstance(logged_user, AnonymousUser))
self.assertFalse(logged_user.is_authenticated())
self.assertEqual(response.resolver_match.func, user_logout)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import shutil
from django.conf import settings
from django.contrib import auth
from django.contrib.auth.models import User, AnonymousUser
from django.shortcuts import reverse
from django.test import TestCase, Client
from ...models import TheUser
from ...views.additional_views import user_logout, share_txt, share_xml, unsubscribe
and context:
# Path: app/models.py
# class TheUser(models.Model):
# """
# Class for user objects in database.
# """
# REMINDER_TEMPLATE = json.dumps({
# "common": {
# "fb_page": True,
# "fb_group": True,
# "twitter": True,
# "vk": True,
# "disabled_all": False
# },
# "api": {
# "app_rate": True
# },
# "web": {
# "app_download": True,
# },
# })
#
# id_user = models.OneToOneField(User)
# user_photo = models.ImageField(blank=True, upload_to='user', storage=OverwriteStorage())
# auth_token = models.CharField(max_length=50, null=True, blank=True)
# subscription = models.BooleanField(default=True)
# reminder = models.CharField(max_length=256, null=False, default=REMINDER_TEMPLATE)
#
# # ------------------------------------------------------------------------------------------------------------------
# def __str__(self):
# return str(self.id_user)
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_api_reminders(self):
# """
# Returns the reminders only necessary for API endpoints.
# """
# data = json.loads(self.reminder)
#
# mobile_data = dict(data['common'])
# mobile_data.update(data['api'])
#
# return mobile_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_web_reminders(self):
# """
# Returns the reminders only necessary for web part.
# """
# data = json.loads(self.reminder)
#
# web_data = dict(data['common'])
# web_data.update(data['web'])
#
# return web_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def update_reminder(self, field, value):
# """
# Updates the reminder status.
# """
# data = json.loads(self.reminder)
#
# for key in data:
# if field in data[key]:
# data[key][field] = value
#
# self.reminder = json.dumps(data)
# self.save()
#
# Path: app/views/additional_views.py
# @process_method('POST', 404)
# def user_logout(request):
# """
# Closes session, returns index page.
# """
# logger.info("User '{}' logged out.".format(request.user))
# logout(request)
# return redirect('index')
#
# def share_txt(request, file):
# """
# Returns the shared .txt files.
# """
# path = settings.BASE_DIR + '/Plamber/additional/{}'.format(file)
#
# if os.path.exists(path):
# with open(path, 'r', encoding='utf-8') as data:
# return HttpResponse(data.read(), content_type='text/plain')
#
# return HttpResponse(status=404)
#
# def share_xml(request, file):
# """
# Returns the shared .xml files.
# """
# path = settings.BASE_DIR + '/Plamber/additional/{}'.format(file)
#
# if os.path.exists(path):
# with open(path, 'r', encoding='utf-8') as data:
# return HttpResponse(data.read(), content_type='application/xml')
#
# return HttpResponse(status=404)
#
# def unsubscribe(request, token):
# """
# Removes the user from the list of blog subscribers.
# """
# username, date = token.split('-')
# user = get_object_or_404(TheUser, id_user__username=username,
# id_user__date_joined=datetime.fromtimestamp(float(date)))
# user.subscription = False
# user.save()
#
# return render(request, 'additional/unsubscribe.html', context={'user': user})
which might include code, classes, or functions. Output only the next line. | self.assertRedirects(response, reverse('index'), status_code=302, target_status_code=200) |
Here is a snippet: <|code_start|> response = self.logged_client.get(reverse('logout'))
self.assertEqual(response.resolver_match.func, user_logout)
self.assertEqual(response.status_code, 404)
# ------------------------------------------------------------------------------------------------------------------
def test_user_logout_success(self):
logged_user = auth.get_user(self.logged_client)
self.assertEqual(logged_user, self.user)
self.assertTrue(logged_user.is_authenticated())
response = self.logged_client.post(reverse('logout'))
logged_user = auth.get_user(self.logged_client)
self.assertTrue(isinstance(logged_user, AnonymousUser))
self.assertFalse(logged_user.is_authenticated())
self.assertEqual(response.resolver_match.func, user_logout)
self.assertRedirects(response, reverse('index'), status_code=302, target_status_code=200)
# ------------------------------------------------------------------------------------------------------------------
def test_share_txt_not_existing_file(self):
response = self.logged_client.get(reverse('share_txt', kwargs={'file': 'not_existing.txt'}))
self.assertEqual(response.resolver_match.func, share_txt)
self.assertEqual(response.status_code, 404)
# ------------------------------------------------------------------------------------------------------------------
def test_share_txt_existing_file(self):
response = self.logged_client.get(reverse('share_txt', kwargs={'file': 'test.txt'}))
<|code_end|>
. Write the next line using the current file imports:
import os
import shutil
from django.conf import settings
from django.contrib import auth
from django.contrib.auth.models import User, AnonymousUser
from django.shortcuts import reverse
from django.test import TestCase, Client
from ...models import TheUser
from ...views.additional_views import user_logout, share_txt, share_xml, unsubscribe
and context from other files:
# Path: app/models.py
# class TheUser(models.Model):
# """
# Class for user objects in database.
# """
# REMINDER_TEMPLATE = json.dumps({
# "common": {
# "fb_page": True,
# "fb_group": True,
# "twitter": True,
# "vk": True,
# "disabled_all": False
# },
# "api": {
# "app_rate": True
# },
# "web": {
# "app_download": True,
# },
# })
#
# id_user = models.OneToOneField(User)
# user_photo = models.ImageField(blank=True, upload_to='user', storage=OverwriteStorage())
# auth_token = models.CharField(max_length=50, null=True, blank=True)
# subscription = models.BooleanField(default=True)
# reminder = models.CharField(max_length=256, null=False, default=REMINDER_TEMPLATE)
#
# # ------------------------------------------------------------------------------------------------------------------
# def __str__(self):
# return str(self.id_user)
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_api_reminders(self):
# """
# Returns the reminders only necessary for API endpoints.
# """
# data = json.loads(self.reminder)
#
# mobile_data = dict(data['common'])
# mobile_data.update(data['api'])
#
# return mobile_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_web_reminders(self):
# """
# Returns the reminders only necessary for web part.
# """
# data = json.loads(self.reminder)
#
# web_data = dict(data['common'])
# web_data.update(data['web'])
#
# return web_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def update_reminder(self, field, value):
# """
# Updates the reminder status.
# """
# data = json.loads(self.reminder)
#
# for key in data:
# if field in data[key]:
# data[key][field] = value
#
# self.reminder = json.dumps(data)
# self.save()
#
# Path: app/views/additional_views.py
# @process_method('POST', 404)
# def user_logout(request):
# """
# Closes session, returns index page.
# """
# logger.info("User '{}' logged out.".format(request.user))
# logout(request)
# return redirect('index')
#
# def share_txt(request, file):
# """
# Returns the shared .txt files.
# """
# path = settings.BASE_DIR + '/Plamber/additional/{}'.format(file)
#
# if os.path.exists(path):
# with open(path, 'r', encoding='utf-8') as data:
# return HttpResponse(data.read(), content_type='text/plain')
#
# return HttpResponse(status=404)
#
# def share_xml(request, file):
# """
# Returns the shared .xml files.
# """
# path = settings.BASE_DIR + '/Plamber/additional/{}'.format(file)
#
# if os.path.exists(path):
# with open(path, 'r', encoding='utf-8') as data:
# return HttpResponse(data.read(), content_type='application/xml')
#
# return HttpResponse(status=404)
#
# def unsubscribe(request, token):
# """
# Removes the user from the list of blog subscribers.
# """
# username, date = token.split('-')
# user = get_object_or_404(TheUser, id_user__username=username,
# id_user__date_joined=datetime.fromtimestamp(float(date)))
# user.subscription = False
# user.save()
#
# return render(request, 'additional/unsubscribe.html', context={'user': user})
, which may include functions, classes, or code. Output only the next line. | response_data = response.content.decode('utf-8') |
Predict the next line for this snippet: <|code_start|>TEST_DIR = os.path.dirname(os.path.abspath(__file__))
TEST_DATA_DIR = os.path.join(TEST_DIR, '../fixtures')
DESTINATION_DIR = os.path.join(settings.BASE_DIR, 'Plamber/additional/{}')
# ----------------------------------------------------------------------------------------------------------------------
class AdditionalViewsTest(TestCase):
# ------------------------------------------------------------------------------------------------------------------
@classmethod
def setUpTestData(cls):
shutil.copy(os.path.join(TEST_DATA_DIR, 'test.txt'), DESTINATION_DIR.format('test.txt'))
shutil.copy(os.path.join(TEST_DATA_DIR, 'test.xml'), DESTINATION_DIR.format('test.xml'))
cls.user = User.objects.create_user(username='additional', email='logout@user.com', password='Dummy#password')
cls.user.date_joined = cls.user.date_joined.replace(microsecond=0)
cls.user.save()
cls.anonymous_client = Client()
cls.logged_client = Client()
cls.logged_client.login(username='additional', password='Dummy#password')
# ------------------------------------------------------------------------------------------------------------------
@classmethod
def tearDownClass(cls):
os.remove(DESTINATION_DIR.format('test.txt'))
os.remove(DESTINATION_DIR.format('test.xml'))
# ------------------------------------------------------------------------------------------------------------------
<|code_end|>
with the help of current file imports:
import os
import shutil
from django.conf import settings
from django.contrib import auth
from django.contrib.auth.models import User, AnonymousUser
from django.shortcuts import reverse
from django.test import TestCase, Client
from ...models import TheUser
from ...views.additional_views import user_logout, share_txt, share_xml, unsubscribe
and context from other files:
# Path: app/models.py
# class TheUser(models.Model):
# """
# Class for user objects in database.
# """
# REMINDER_TEMPLATE = json.dumps({
# "common": {
# "fb_page": True,
# "fb_group": True,
# "twitter": True,
# "vk": True,
# "disabled_all": False
# },
# "api": {
# "app_rate": True
# },
# "web": {
# "app_download": True,
# },
# })
#
# id_user = models.OneToOneField(User)
# user_photo = models.ImageField(blank=True, upload_to='user', storage=OverwriteStorage())
# auth_token = models.CharField(max_length=50, null=True, blank=True)
# subscription = models.BooleanField(default=True)
# reminder = models.CharField(max_length=256, null=False, default=REMINDER_TEMPLATE)
#
# # ------------------------------------------------------------------------------------------------------------------
# def __str__(self):
# return str(self.id_user)
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_api_reminders(self):
# """
# Returns the reminders only necessary for API endpoints.
# """
# data = json.loads(self.reminder)
#
# mobile_data = dict(data['common'])
# mobile_data.update(data['api'])
#
# return mobile_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def get_web_reminders(self):
# """
# Returns the reminders only necessary for web part.
# """
# data = json.loads(self.reminder)
#
# web_data = dict(data['common'])
# web_data.update(data['web'])
#
# return web_data
#
# # ------------------------------------------------------------------------------------------------------------------
# def update_reminder(self, field, value):
# """
# Updates the reminder status.
# """
# data = json.loads(self.reminder)
#
# for key in data:
# if field in data[key]:
# data[key][field] = value
#
# self.reminder = json.dumps(data)
# self.save()
#
# Path: app/views/additional_views.py
# @process_method('POST', 404)
# def user_logout(request):
# """
# Closes session, returns index page.
# """
# logger.info("User '{}' logged out.".format(request.user))
# logout(request)
# return redirect('index')
#
# def share_txt(request, file):
# """
# Returns the shared .txt files.
# """
# path = settings.BASE_DIR + '/Plamber/additional/{}'.format(file)
#
# if os.path.exists(path):
# with open(path, 'r', encoding='utf-8') as data:
# return HttpResponse(data.read(), content_type='text/plain')
#
# return HttpResponse(status=404)
#
# def share_xml(request, file):
# """
# Returns the shared .xml files.
# """
# path = settings.BASE_DIR + '/Plamber/additional/{}'.format(file)
#
# if os.path.exists(path):
# with open(path, 'r', encoding='utf-8') as data:
# return HttpResponse(data.read(), content_type='application/xml')
#
# return HttpResponse(status=404)
#
# def unsubscribe(request, token):
# """
# Removes the user from the list of blog subscribers.
# """
# username, date = token.split('-')
# user = get_object_or_404(TheUser, id_user__username=username,
# id_user__date_joined=datetime.fromtimestamp(float(date)))
# user.subscription = False
# user.save()
#
# return render(request, 'additional/unsubscribe.html', context={'user': user})
, which may contain function names, class names, or code. Output only the next line. | def test_user_logout_not_post(self): |
Here is a snippet: <|code_start|> if query_params:
query_params = json.loads(query_params)
results = self.qmanager.execute_aql_query(aql_query, query_params, count_only)
return results
@exception_handler
def execute_query(self):
params = request.forms
results = self._execute_query(params, count_only=False)
response_body = {
'SUCCESS': True,
'RESULTS_SET': results.to_json()
}
return self._success(response_body)
@exception_handler
def execute_count_query(self):
params = request.forms
results = self._execute_query(params, count_only=True)
response_body = {
'SUCCESS': True,
'RESULTS_COUNTER': results
}
return self._success(response_body)
def start_service(self, host, port, engine, debug=False):
self.logger.info('Starting QueryService daemon with DEBUG set to %s', debug)
try:
run(host=host, port=port, server=engine, debug=debug)
except Exception, e:
<|code_end|>
. Write the next line using the current file imports:
import sys, argparse
import simplejson as json
import json
import pyehr.ehr.services.dbmanager.errors as pyehr_errors
import traceback
from functools import wraps
from bottle import post, get, run, response, request, abort, HTTPError
from pyehr.ehr.services.dbmanager.querymanager import QueryManager
from pyehr.utils import get_logger
from pyehr.utils.services import get_service_configuration, check_pid_file,\
create_pid, destroy_pid, get_rotating_file_logger
and context from other files:
# Path: pyehr/utils/services.py
# def get_service_configuration(configuration_file, logger=None):
# if not logger:
# logger = get_logger('service_configuration')
# parser = SafeConfigParser(allow_no_value=True)
# parser.read(configuration_file)
# try:
# conf = ServiceConfig(
# parser.get('db', 'driver'),
# parser.get('db', 'host'),
# parser.get('db', 'database'),
# parser.get('db', 'versioning_database'),
# parser.get('db', 'port'),
# parser.get('db', 'user'),
# parser.get('db', 'passwd'),
# parser.get('db', 'patients_repository'),
# parser.get('db', 'ehr_repository'),
# parser.get('db', 'ehr_versioning_repository'),
# parser.get('index', 'url'),
# parser.get('index', 'database'),
# parser.get('index', 'user'),
# parser.get('index', 'passwd'),
# parser.get('db_service', 'host'),
# parser.get('db_service', 'port'),
# parser.get('db_service', 'server_engine'),
# parser.get('query_service', 'host'),
# parser.get('query_service', 'port'),
# parser.get('query_service', 'server_engine')
# )
# return conf
# except NoOptionError, nopt:
# logger.critical('Missing option %s in configuration file', nopt)
# return None
#
# def check_pid_file(pid_file, logger):
# if os.path.isfile(pid_file):
# logger.info('Another dbservice daemon is running, exit')
# sys.exit(0)
#
# def create_pid(pid_file):
# pid = str(os.getpid())
# with open(pid_file, 'w') as ofile:
# ofile.write(pid)
#
# def destroy_pid(pid_file):
# os.remove(pid_file)
#
# def get_rotating_file_logger(logger_label, log_file, log_level='INFO',
# max_bytes=100*1024*1024, backup_count=3):
# logger = logging.getLogger(logger_label)
# if not isinstance(log_level, int):
# try:
# log_level = getattr(logging, log_level)
# except AttributeError:
# raise ValueError('unsupported literal log level: %s' % log_level)
# logger.setLevel(log_level)
# # clear existing handlers
# logger.handlers = []
# handler = RotatingFileHandler(log_file, max_bytes, backup_count)
# formatter = logging.Formatter(LOG_FORMAT, datefmt=LOG_DATEFMT)
# handler.setFormatter(formatter)
# logger.addHandler(handler)
# return logger
, which may include functions, classes, or code. Output only the next line. | self.logger.critical('An error has occurred: %s', e) |
Next line prediction: <|code_start|> log_level=log_level)
self.qmanager = QueryManager(driver, host, database, versioning_database,
patients_repository, ehr_repository,
ehr_versioning_repository,
port, user, passwd, self.logger)
###############################################
# Web Service methods
###############################################
post('/query/execute')(self.execute_query)
post('/query/execute_count')(self.execute_count_query)
# utilities
post('/check/status/querymanager')(self.test_server)
get('/check/status/querymanager')(self.test_server)
def add_index_service(self, url, database, user, passwd):
self.qmanager.set_index_service(url, database, user, passwd)
def exception_handler(f):
@wraps(f)
def wrapper(inst, *args, **kwargs):
try:
return f(inst, *args, **kwargs)
except pyehr_errors.UnknownDriverError, ude:
inst._error(str(ude), 500)
except HTTPError:
#if an abort was called in wrapped function, raise the generated HTTPError
raise
except Exception, e:
inst.logger.error(traceback.print_stack())
msg = 'Unexpected error: %s' % e.message
<|code_end|>
. Use current file imports:
(import sys, argparse
import simplejson as json
import json
import pyehr.ehr.services.dbmanager.errors as pyehr_errors
import traceback
from functools import wraps
from bottle import post, get, run, response, request, abort, HTTPError
from pyehr.ehr.services.dbmanager.querymanager import QueryManager
from pyehr.utils import get_logger
from pyehr.utils.services import get_service_configuration, check_pid_file,\
create_pid, destroy_pid, get_rotating_file_logger)
and context including class names, function names, or small code snippets from other files:
# Path: pyehr/utils/services.py
# def get_service_configuration(configuration_file, logger=None):
# if not logger:
# logger = get_logger('service_configuration')
# parser = SafeConfigParser(allow_no_value=True)
# parser.read(configuration_file)
# try:
# conf = ServiceConfig(
# parser.get('db', 'driver'),
# parser.get('db', 'host'),
# parser.get('db', 'database'),
# parser.get('db', 'versioning_database'),
# parser.get('db', 'port'),
# parser.get('db', 'user'),
# parser.get('db', 'passwd'),
# parser.get('db', 'patients_repository'),
# parser.get('db', 'ehr_repository'),
# parser.get('db', 'ehr_versioning_repository'),
# parser.get('index', 'url'),
# parser.get('index', 'database'),
# parser.get('index', 'user'),
# parser.get('index', 'passwd'),
# parser.get('db_service', 'host'),
# parser.get('db_service', 'port'),
# parser.get('db_service', 'server_engine'),
# parser.get('query_service', 'host'),
# parser.get('query_service', 'port'),
# parser.get('query_service', 'server_engine')
# )
# return conf
# except NoOptionError, nopt:
# logger.critical('Missing option %s in configuration file', nopt)
# return None
#
# def check_pid_file(pid_file, logger):
# if os.path.isfile(pid_file):
# logger.info('Another dbservice daemon is running, exit')
# sys.exit(0)
#
# def create_pid(pid_file):
# pid = str(os.getpid())
# with open(pid_file, 'w') as ofile:
# ofile.write(pid)
#
# def destroy_pid(pid_file):
# os.remove(pid_file)
#
# def get_rotating_file_logger(logger_label, log_file, log_level='INFO',
# max_bytes=100*1024*1024, backup_count=3):
# logger = logging.getLogger(logger_label)
# if not isinstance(log_level, int):
# try:
# log_level = getattr(logging, log_level)
# except AttributeError:
# raise ValueError('unsupported literal log level: %s' % log_level)
# logger.setLevel(log_level)
# # clear existing handlers
# logger.handlers = []
# handler = RotatingFileHandler(log_file, max_bytes, backup_count)
# formatter = logging.Formatter(LOG_FORMAT, datefmt=LOG_DATEFMT)
# handler.setFormatter(formatter)
# logger.addHandler(handler)
# return logger
. Output only the next line. | inst._error(msg, 500) |
Given the following code snippet before the placeholder: <|code_start|> def _execute_query(self, params, count_only):
aql_query = params.get('query')
if not aql_query:
self._missing_mandatory_field('query')
query_params = params.get('query_params')
if query_params:
query_params = json.loads(query_params)
results = self.qmanager.execute_aql_query(aql_query, query_params, count_only)
return results
@exception_handler
def execute_query(self):
params = request.forms
results = self._execute_query(params, count_only=False)
response_body = {
'SUCCESS': True,
'RESULTS_SET': results.to_json()
}
return self._success(response_body)
@exception_handler
def execute_count_query(self):
params = request.forms
results = self._execute_query(params, count_only=True)
response_body = {
'SUCCESS': True,
'RESULTS_COUNTER': results
}
return self._success(response_body)
<|code_end|>
, predict the next line using imports from the current file:
import sys, argparse
import simplejson as json
import json
import pyehr.ehr.services.dbmanager.errors as pyehr_errors
import traceback
from functools import wraps
from bottle import post, get, run, response, request, abort, HTTPError
from pyehr.ehr.services.dbmanager.querymanager import QueryManager
from pyehr.utils import get_logger
from pyehr.utils.services import get_service_configuration, check_pid_file,\
create_pid, destroy_pid, get_rotating_file_logger
and context including class names, function names, and sometimes code from other files:
# Path: pyehr/utils/services.py
# def get_service_configuration(configuration_file, logger=None):
# if not logger:
# logger = get_logger('service_configuration')
# parser = SafeConfigParser(allow_no_value=True)
# parser.read(configuration_file)
# try:
# conf = ServiceConfig(
# parser.get('db', 'driver'),
# parser.get('db', 'host'),
# parser.get('db', 'database'),
# parser.get('db', 'versioning_database'),
# parser.get('db', 'port'),
# parser.get('db', 'user'),
# parser.get('db', 'passwd'),
# parser.get('db', 'patients_repository'),
# parser.get('db', 'ehr_repository'),
# parser.get('db', 'ehr_versioning_repository'),
# parser.get('index', 'url'),
# parser.get('index', 'database'),
# parser.get('index', 'user'),
# parser.get('index', 'passwd'),
# parser.get('db_service', 'host'),
# parser.get('db_service', 'port'),
# parser.get('db_service', 'server_engine'),
# parser.get('query_service', 'host'),
# parser.get('query_service', 'port'),
# parser.get('query_service', 'server_engine')
# )
# return conf
# except NoOptionError, nopt:
# logger.critical('Missing option %s in configuration file', nopt)
# return None
#
# def check_pid_file(pid_file, logger):
# if os.path.isfile(pid_file):
# logger.info('Another dbservice daemon is running, exit')
# sys.exit(0)
#
# def create_pid(pid_file):
# pid = str(os.getpid())
# with open(pid_file, 'w') as ofile:
# ofile.write(pid)
#
# def destroy_pid(pid_file):
# os.remove(pid_file)
#
# def get_rotating_file_logger(logger_label, log_file, log_level='INFO',
# max_bytes=100*1024*1024, backup_count=3):
# logger = logging.getLogger(logger_label)
# if not isinstance(log_level, int):
# try:
# log_level = getattr(logging, log_level)
# except AttributeError:
# raise ValueError('unsupported literal log level: %s' % log_level)
# logger.setLevel(log_level)
# # clear existing handlers
# logger.handlers = []
# handler = RotatingFileHandler(log_file, max_bytes, backup_count)
# formatter = logging.Formatter(LOG_FORMAT, datefmt=LOG_DATEFMT)
# handler.setFormatter(formatter)
# logger.addHandler(handler)
# return logger
. Output only the next line. | def start_service(self, host, port, engine, debug=False): |
Given the code snippet: <|code_start|> return f(inst, *args, **kwargs)
except pyehr_errors.UnknownDriverError, ude:
inst._error(str(ude), 500)
except HTTPError:
#if an abort was called in wrapped function, raise the generated HTTPError
raise
except Exception, e:
inst.logger.error(traceback.print_stack())
msg = 'Unexpected error: %s' % e.message
inst._error(msg, 500)
return wrapper
def _error(self, msg, error_code):
self.logger.error(msg)
body = {
'SUCCESS': False,
'ERROR': msg
}
abort(error_code, json.dumps(body))
def _missing_mandatory_field(self, field_label):
msg = 'Missing mandatory field %s, can\'t continue with the request' % field_label
self._error(msg, 400)
def _success(self, body, return_code=200):
response.content_type = 'application/json'
response.status = return_code
return body
def _execute_query(self, params, count_only):
<|code_end|>
, generate the next line using the imports in this file:
import sys, argparse
import simplejson as json
import json
import pyehr.ehr.services.dbmanager.errors as pyehr_errors
import traceback
from functools import wraps
from bottle import post, get, run, response, request, abort, HTTPError
from pyehr.ehr.services.dbmanager.querymanager import QueryManager
from pyehr.utils import get_logger
from pyehr.utils.services import get_service_configuration, check_pid_file,\
create_pid, destroy_pid, get_rotating_file_logger
and context (functions, classes, or occasionally code) from other files:
# Path: pyehr/utils/services.py
# def get_service_configuration(configuration_file, logger=None):
# if not logger:
# logger = get_logger('service_configuration')
# parser = SafeConfigParser(allow_no_value=True)
# parser.read(configuration_file)
# try:
# conf = ServiceConfig(
# parser.get('db', 'driver'),
# parser.get('db', 'host'),
# parser.get('db', 'database'),
# parser.get('db', 'versioning_database'),
# parser.get('db', 'port'),
# parser.get('db', 'user'),
# parser.get('db', 'passwd'),
# parser.get('db', 'patients_repository'),
# parser.get('db', 'ehr_repository'),
# parser.get('db', 'ehr_versioning_repository'),
# parser.get('index', 'url'),
# parser.get('index', 'database'),
# parser.get('index', 'user'),
# parser.get('index', 'passwd'),
# parser.get('db_service', 'host'),
# parser.get('db_service', 'port'),
# parser.get('db_service', 'server_engine'),
# parser.get('query_service', 'host'),
# parser.get('query_service', 'port'),
# parser.get('query_service', 'server_engine')
# )
# return conf
# except NoOptionError, nopt:
# logger.critical('Missing option %s in configuration file', nopt)
# return None
#
# def check_pid_file(pid_file, logger):
# if os.path.isfile(pid_file):
# logger.info('Another dbservice daemon is running, exit')
# sys.exit(0)
#
# def create_pid(pid_file):
# pid = str(os.getpid())
# with open(pid_file, 'w') as ofile:
# ofile.write(pid)
#
# def destroy_pid(pid_file):
# os.remove(pid_file)
#
# def get_rotating_file_logger(logger_label, log_file, log_level='INFO',
# max_bytes=100*1024*1024, backup_count=3):
# logger = logging.getLogger(logger_label)
# if not isinstance(log_level, int):
# try:
# log_level = getattr(logging, log_level)
# except AttributeError:
# raise ValueError('unsupported literal log level: %s' % log_level)
# logger.setLevel(log_level)
# # clear existing handlers
# logger.handlers = []
# handler = RotatingFileHandler(log_file, max_bytes, backup_count)
# formatter = logging.Formatter(LOG_FORMAT, datefmt=LOG_DATEFMT)
# handler.setFormatter(formatter)
# logger.addHandler(handler)
# return logger
. Output only the next line. | aql_query = params.get('query') |
Given snippet: <|code_start|> inst.logger.error(traceback.print_stack())
msg = 'Unexpected error: %s' % e.message
inst._error(msg, 500)
return wrapper
def _error(self, msg, error_code):
self.logger.error(msg)
body = {
'SUCCESS': False,
'ERROR': msg
}
abort(error_code, json.dumps(body))
def _missing_mandatory_field(self, field_label):
msg = 'Missing mandatory field %s, can\'t continue with the request' % field_label
self._error(msg, 400)
def _success(self, body, return_code=200):
response.content_type = 'application/json'
response.status = return_code
return body
def _execute_query(self, params, count_only):
aql_query = params.get('query')
if not aql_query:
self._missing_mandatory_field('query')
query_params = params.get('query_params')
if query_params:
query_params = json.loads(query_params)
results = self.qmanager.execute_aql_query(aql_query, query_params, count_only)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import sys, argparse
import simplejson as json
import json
import pyehr.ehr.services.dbmanager.errors as pyehr_errors
import traceback
from functools import wraps
from bottle import post, get, run, response, request, abort, HTTPError
from pyehr.ehr.services.dbmanager.querymanager import QueryManager
from pyehr.utils import get_logger
from pyehr.utils.services import get_service_configuration, check_pid_file,\
create_pid, destroy_pid, get_rotating_file_logger
and context:
# Path: pyehr/utils/services.py
# def get_service_configuration(configuration_file, logger=None):
# if not logger:
# logger = get_logger('service_configuration')
# parser = SafeConfigParser(allow_no_value=True)
# parser.read(configuration_file)
# try:
# conf = ServiceConfig(
# parser.get('db', 'driver'),
# parser.get('db', 'host'),
# parser.get('db', 'database'),
# parser.get('db', 'versioning_database'),
# parser.get('db', 'port'),
# parser.get('db', 'user'),
# parser.get('db', 'passwd'),
# parser.get('db', 'patients_repository'),
# parser.get('db', 'ehr_repository'),
# parser.get('db', 'ehr_versioning_repository'),
# parser.get('index', 'url'),
# parser.get('index', 'database'),
# parser.get('index', 'user'),
# parser.get('index', 'passwd'),
# parser.get('db_service', 'host'),
# parser.get('db_service', 'port'),
# parser.get('db_service', 'server_engine'),
# parser.get('query_service', 'host'),
# parser.get('query_service', 'port'),
# parser.get('query_service', 'server_engine')
# )
# return conf
# except NoOptionError, nopt:
# logger.critical('Missing option %s in configuration file', nopt)
# return None
#
# def check_pid_file(pid_file, logger):
# if os.path.isfile(pid_file):
# logger.info('Another dbservice daemon is running, exit')
# sys.exit(0)
#
# def create_pid(pid_file):
# pid = str(os.getpid())
# with open(pid_file, 'w') as ofile:
# ofile.write(pid)
#
# def destroy_pid(pid_file):
# os.remove(pid_file)
#
# def get_rotating_file_logger(logger_label, log_file, log_level='INFO',
# max_bytes=100*1024*1024, backup_count=3):
# logger = logging.getLogger(logger_label)
# if not isinstance(log_level, int):
# try:
# log_level = getattr(logging, log_level)
# except AttributeError:
# raise ValueError('unsupported literal log level: %s' % log_level)
# logger.setLevel(log_level)
# # clear existing handlers
# logger.handlers = []
# handler = RotatingFileHandler(log_file, max_bytes, backup_count)
# formatter = logging.Formatter(LOG_FORMAT, datefmt=LOG_DATEFMT)
# handler.setFormatter(formatter)
# logger.addHandler(handler)
# return logger
which might include code, classes, or functions. Output only the next line. | return results |
Using the snippet: <|code_start|>
try:
except ImportError:
class MultiprocessQueryRunnerPM3(object):
def __init__(self, host, database, collection,
port, user, passwd):
self.host = host
self.database = database
self.collection_name = collection
self.port = port
self.user = user
self.passwd = passwd
def __call__(self, query_description):
driver_instance = MongoDriverPM3(
self.host, self.database, self.collection_name,
self.port, self.user, self.passwd
<|code_end|>
, determine the next line of code. You have imports:
from mongo_pm2 import MongoDriverPM2
from multiprocessing import Pool
from pyehr.ehr.services.dbmanager.querymanager.results_wrappers import ResultSet,\
ResultColumnDef, ResultRow
from pyehr.ehr.services.dbmanager.errors import *
import pymongo
import pymongo.errors
import time
import simplejson as json
import json
and context (class names, function names, or code) available:
# Path: pyehr/ehr/services/dbmanager/querymanager/results_wrappers.py
# class ResultSet(object):
#
# def __init__(self):
# self.name = None
# self.total_results = 0
# self.columns = []
# self.rows = []
#
# def to_json(self, add_columns_json=False):
# json_res = {
# 'results_count': self.total_results,
# 'results': list(self.results)
# }
# if add_columns_json:
# json_res['columns'] = [c.to_json() for c in self.columns]
# return json_res
#
# def _get_alias(self, key):
# for col in self.columns:
# if col.path == key:
# return col.alias
# raise KeyError('Can\'t map key %s' % key)
#
# def __str__(self):
# return str(self.to_json())
#
# def extend(self, result_set):
# self.total_results += result_set.total_results
# self.rows += result_set.rows
# for c in result_set.columns:
# if c not in self.columns:
# self.columns.append(c)
#
# def add_column_definition(self, colum_def):
# if colum_def not in self.columns:
# self.columns.append(colum_def)
#
# def add_row(self, row):
# self.rows.append(row)
# self.total_results += 1
#
# @property
# def results(self):
# for r in self.rows:
# yield {self._get_alias(k): v for k, v in r.record.iteritems()}
#
# def get_distinct_results(self, field):
# try:
# for x in set([r[field] for r in self.results]):
# yield x
# except KeyError:
# raise InvalidFieldError('There is no field "%s" in this results set' % field)
#
# class ResultColumnDef(object):
#
# def __init__(self, alias=None, path=None):
# self.path = path.strip()
# self.alias = alias.strip()
#
# def __eq__(self, other):
# if isinstance(other, ResultColumnDef):
# return self.to_json() == other.to_json()
# else:
# return False
#
# def to_json(self):
# return {'alias': self.alias, 'path': self.path}
#
# class ResultRow(object):
#
# def __init__(self, record):
# self.record = record
#
# def __eq__(self, other):
# if isinstance(other, ResultRow):
# return self.record == other.record
# else:
# return False
. Output only the next line. | ) |
Continue the code snippet: <|code_start|> sconf.get_db_service_configuration()['port'])
self.patient_paths = {
'add': 'patient',
'delete': 'patient'
}
self.ehr_paths = {
'add': 'ehr',
'delete': 'ehr',
'get': 'ehr',
'update': 'ehr/update'
}
self.batch_path = {
'save_patient': 'batch/save/patient',
'save_patients': 'batch/save/patients'
}
def _get_path(self, path, patient_id=None, ehr_record_id=None, action=None):
path_params = [self.dbservice_uri, path]
if patient_id:
path_params.append(patient_id)
if ehr_record_id:
path_params.append(ehr_record_id)
if action:
path_params.append(action)
return '/'.join(path_params)
def _build_add_patient_request(self, patient_id='JOHN_DOE', active=None,
creation_time=None):
request = {'patient_id': patient_id}
if active is not None:
<|code_end|>
. Use current file imports:
import os, unittest, requests, sys, time
import simplejson as json
import json
from copy import copy
from pyehr.utils.services import get_service_configuration
from uuid import uuid4
and context (classes, functions, or code) from other files:
# Path: pyehr/utils/services.py
# def get_service_configuration(configuration_file, logger=None):
# if not logger:
# logger = get_logger('service_configuration')
# parser = SafeConfigParser(allow_no_value=True)
# parser.read(configuration_file)
# try:
# conf = ServiceConfig(
# parser.get('db', 'driver'),
# parser.get('db', 'host'),
# parser.get('db', 'database'),
# parser.get('db', 'versioning_database'),
# parser.get('db', 'port'),
# parser.get('db', 'user'),
# parser.get('db', 'passwd'),
# parser.get('db', 'patients_repository'),
# parser.get('db', 'ehr_repository'),
# parser.get('db', 'ehr_versioning_repository'),
# parser.get('index', 'url'),
# parser.get('index', 'database'),
# parser.get('index', 'user'),
# parser.get('index', 'passwd'),
# parser.get('db_service', 'host'),
# parser.get('db_service', 'port'),
# parser.get('db_service', 'server_engine'),
# parser.get('query_service', 'host'),
# parser.get('query_service', 'port'),
# parser.get('query_service', 'server_engine')
# )
# return conf
# except NoOptionError, nopt:
# logger.critical('Missing option %s in configuration file', nopt)
# return None
. Output only the next line. | request['active'] = active |
Given the code snippet: <|code_start|> logger.info('Index time search took %f seconds' % index_time)
return index_time
def get_expected_results_count(qmanager, expected_results_percentage, logger):
drf = qmanager._get_drivers_factory(qmanager.ehr_repository)
with drf.get_driver() as driver:
total_records_count = driver.documents_count
logger.info('Collection %s contains %d records' % (qmanager.ehr_repository,
total_records_count))
return int(round((expected_results_percentage * total_records_count) / 100.))
def save_report(report_file, results_map):
with open(report_file, 'w') as f:
for query in sorted(results_map):
f.write(json.dumps({query: results_map[query]}) + os.linesep)
def main(argv):
parser = get_parser()
args = parser.parse_args(argv)
logger = get_logger('run_queries', log_level=args.log_level, log_file=args.log_file)
query_manager = get_query_manager(args.pyehr_config)
logger.info('Loading queries from file %s' % args.queries_file)
queries = load_queries(args.queries_file)
logger.info('Loaded %d queries' % len(queries))
results_map = dict()
<|code_end|>
, generate the next line using the imports in this file:
import argparse, sys, time, json, os
from pyehr.ehr.services.dbmanager.querymanager import QueryManager, Parser
from pyehr.utils.services import get_service_configuration
from pyehr.utils import get_logger, decode_dict
and context (functions, classes, or occasionally code) from other files:
# Path: pyehr/utils/services.py
# def get_service_configuration(configuration_file, logger=None):
# if not logger:
# logger = get_logger('service_configuration')
# parser = SafeConfigParser(allow_no_value=True)
# parser.read(configuration_file)
# try:
# conf = ServiceConfig(
# parser.get('db', 'driver'),
# parser.get('db', 'host'),
# parser.get('db', 'database'),
# parser.get('db', 'versioning_database'),
# parser.get('db', 'port'),
# parser.get('db', 'user'),
# parser.get('db', 'passwd'),
# parser.get('db', 'patients_repository'),
# parser.get('db', 'ehr_repository'),
# parser.get('db', 'ehr_versioning_repository'),
# parser.get('index', 'url'),
# parser.get('index', 'database'),
# parser.get('index', 'user'),
# parser.get('index', 'passwd'),
# parser.get('db_service', 'host'),
# parser.get('db_service', 'port'),
# parser.get('db_service', 'server_engine'),
# parser.get('query_service', 'host'),
# parser.get('query_service', 'port'),
# parser.get('query_service', 'server_engine')
# )
# return conf
# except NoOptionError, nopt:
# logger.critical('Missing option %s in configuration file', nopt)
# return None
. Output only the next line. | for query_label, query_conf in sorted(queries.iteritems()): |
Next line prediction: <|code_start|> def _build_new_record(self, record, record_id=None):
record_root = etree.Element('archetype_structure')
record_root.append(record)
record_hash = self._get_record_hash(record)
record_id = record_id or uuid4().hex
# new records are created with a reference counter set to 0, only when
# the reference counter will be increased only after the record will
# actually be saved on the DB
record_root.append(etree.Element('references_counter', {'hits': '0'}))
record_root.append(etree.Element('structure_id', {'str_hash': record_hash,
'uid': record_id}))
return record_root, record_id
def create_entry(self, record, record_id=None):
record, structure_key = self._build_new_record(record, record_id)
if not self.basex_client:
self.connect()
self.basex_client.add_document(record, structure_key)
return structure_key
def _get_structure_by_id(self, structure_id):
if not self.basex_client:
self.connect()
return self.basex_client.get_document(structure_id)
def _extract_structure_id_from_xml(self, xml_doc):
return xml_doc.find('structure_id').get('uid')
def _get_structure_id(self, xml_doc):
if not self.basex_client:
<|code_end|>
. Use current file imports:
(from lxml import etree
from hashlib import md5
from uuid import uuid4
from copy import copy
from pyehr.utils.services import get_logger
from pybasex import BaseXClient
import pybasex.errors as pbx_errors)
and context including class names, function names, or small code snippets from other files:
# Path: pyehr/utils/services.py
# class ServiceConfig(object):
# def __init__(self, db_driver, db_host, db_database, db_versioning_database,
# db_port, db_user, db_passwd, db_patients_repository,
# db_ehr_repository, db_ehr_versioning_repository,
# index_url, index_database, index_user, index_passwd,
# db_service_host, db_service_port, db_service_server_engine,
# query_service_host, query_service_port, query_service_server_engine):
# def get_db_configuration(self):
# def get_index_configuration(self):
# def get_db_service_configuration(self):
# def get_query_service_configuration(self):
# def get_service_configuration(configuration_file, logger=None):
# def get_rotating_file_logger(logger_label, log_file, log_level='INFO',
# max_bytes=100*1024*1024, backup_count=3):
# def check_pid_file(pid_file, logger):
# def create_pid(pid_file):
# def destroy_pid(pid_file):
. Output only the next line. | self.connect() |
Using the snippet: <|code_start|> def add_query(self, query_label, aql_query):
if not query_label in self.queries:
self.queries[query_label] = aql_query
else:
raise KeyError('Query label %s already in use' % query_label)
def execute_queries(self):
results_queue = multiprocessing.Queue(len(self.queries))
query_threads = list()
self.logger.debug('Start processing queues')
for label, query in self.queries.iteritems():
qp = QueryProcess(self.qm_conf, self.idxs_conf, label, query,
results_queue, self.logger)
qp.start()
query_threads.append(qp)
for qp in query_threads:
qp.join()
self.logger.debug('Queries executed, collecting results')
while not results_queue.empty():
q_element = results_queue.get()
self.queries_results.update({q_element['query']: q_element['results']})
self.logger.debug('Results collected')
def cleanup(self):
self.queries = dict()
self.queries_results = dict()
def remove_query(self, query_label):
try:
del(self.queries[query_label])
<|code_end|>
, determine the next line of code. You have imports:
import multiprocessing
from pyehr.ehr.services.dbmanager.querymanager import QueryManager
from pyehr.utils.services import get_logger
and context (class names, function names, or code) available:
# Path: pyehr/utils/services.py
# class ServiceConfig(object):
# def __init__(self, db_driver, db_host, db_database, db_versioning_database,
# db_port, db_user, db_passwd, db_patients_repository,
# db_ehr_repository, db_ehr_versioning_repository,
# index_url, index_database, index_user, index_passwd,
# db_service_host, db_service_port, db_service_server_engine,
# query_service_host, query_service_port, query_service_server_engine):
# def get_db_configuration(self):
# def get_index_configuration(self):
# def get_db_service_configuration(self):
# def get_query_service_configuration(self):
# def get_service_configuration(configuration_file, logger=None):
# def get_rotating_file_logger(logger_label, log_file, log_level='INFO',
# max_bytes=100*1024*1024, backup_count=3):
# def check_pid_file(pid_file, logger):
# def create_pid(pid_file):
# def destroy_pid(pid_file):
. Output only the next line. | except KeyError: |
Predict the next line after this snippet: <|code_start|> def to_json(self, add_columns_json=False):
json_res = {
'results_count': self.total_results,
'results': list(self.results)
}
if add_columns_json:
json_res['columns'] = [c.to_json() for c in self.columns]
return json_res
def _get_alias(self, key):
for col in self.columns:
if col.path == key:
return col.alias
raise KeyError('Can\'t map key %s' % key)
def __str__(self):
return str(self.to_json())
def extend(self, result_set):
self.total_results += result_set.total_results
self.rows += result_set.rows
for c in result_set.columns:
if c not in self.columns:
self.columns.append(c)
def add_column_definition(self, colum_def):
if colum_def not in self.columns:
self.columns.append(colum_def)
def add_row(self, row):
<|code_end|>
using the current file's imports:
from pyehr.ehr.services.dbmanager.errors import InvalidFieldError
and any relevant context from other files:
# Path: pyehr/ehr/services/dbmanager/errors.py
# class InvalidFieldError(Exception):
# pass
. Output only the next line. | self.rows.append(row) |
Continue the code snippet: <|code_start|>
class DriversFactory(object):
def __init__(self, driver, host, database, repository=None,
port=None, user=None, passwd=None, index_service=None,
logger=None):
self.driver = driver
self.host = host
self.database = database
self.repository = repository
self.port = port
self.user = user
self.passwd = passwd
self.index_service = index_service
self.logger = logger or get_logger('drivers-factory')
def get_driver(self):
if self.driver == 'mongodb':
if int(vsn.split(".")[0]) < 3:
return MongoDriverPM2(self.host, self.database, self.repository,
self.port, self.user, self.passwd,
self.index_service, self.logger)
else:
<|code_end|>
. Use current file imports:
from pyehr.utils import get_logger
from pyehr.ehr.services.dbmanager.errors import UnknownDriverError
from pymongo import version as vsn
from mongo_pm2 import MongoDriverPM2
from mongo_pm3 import MongoDriverPM3
from elastic_search import ElasticSearchDriver
and context (classes, functions, or code) from other files:
# Path: pyehr/ehr/services/dbmanager/errors.py
# class UnknownDriverError(Exception):
# pass
. Output only the next line. | return MongoDriverPM3(self.host, self.database, self.repository, |
Continue the code snippet: <|code_start|> return self.num_params * _BYTES_FLOAT
@property
def num_params(self):
return self.cell.num_params
class RNNCell(object):
def __init__(self, inputs, outputs, cell_type):
self.inputs = list(inputs)
self.outputs = list(outputs)
self.input_dim = inputs[-1]
self.output_dim = outputs[-1]
self.cell_type = cell_type
@property
def num_params(self):
return 0
class SimpleRNNCell(RNNCell):
"""A simple RNN Cell:
y_t = f(x_t*W + h_{t-1}*U + b) """
def __init__(self, name, inputs, outputs):
super(SimpleRNNCell, self).__init__(name, 'simple')
# Hidden states
self.h = [self.inputs[0], self.output_dim]
self.W = [self.input_dim, self.output_dim]
<|code_end|>
. Use current file imports:
from paleo.layers import base
import numpy as np
and context (classes, functions, or code) from other files:
# Path: paleo/layers/base.py
# class BaseLayer(object):
# class Generic(BaseLayer):
# def __init__(self, name, layertype):
# def __repr__(self):
# def parents(self):
# def parents(self, val):
# def batch_size(self):
# def batch_size(self, batch_size):
# def name(self):
# def layertype(self):
# def additional_summary(self):
# def inputs(self):
# def outputs(self):
# def weights_in_bytes(self):
# def num_params(self):
# def __init__(self, name, inputs, type):
# def additional_summary(self):
# def memory_in_bytes(self):
. Output only the next line. | self.U = [self.output_dim, self.output_dim] |
Predict the next line after this snippet: <|code_start|>from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
class TimeMeasureTest(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_add(self):
# Time with sub items.
t1 = TimeMeasure(comp_time=1, comm_time=3)
t2 = TimeMeasure(comp_time=2, comm_time=2)
t_sum = t1 + t2
self.assertEqual(t_sum.comp_time, t1.comp_time + t2.comp_time)
self.assertEqual(t_sum.comm_time, t1.comm_time + t2.comm_time)
self.assertEqual(t_sum.total_time, t1.total_time + t2.total_time)
# Time without sub items.
t1 = TimeMeasure(total_time=10)
t2 = TimeMeasure(comp_time=1, comm_time=4)
t_sum = t1 + t2
<|code_end|>
using the current file's imports:
import unittest
from paleo.profilers.base import TimeMeasure
and any relevant context from other files:
# Path: paleo/profilers/base.py
# class TimeMeasure(object):
# def __init__(self, comp_time=0, comm_time=0, total_time=None):
# self._comp_time = comp_time
# self._comp_time_std = 0
# self._comm_time = comm_time
# self._comm_time_std = 0
# if not total_time:
# total_time = comp_time + comm_time
# self._total_time = total_time
# self._total_time_std = 0
#
# def __repr__(self):
# return '%f (comp=%f, comm=%f)' % (self.total_time, self.comp_time,
# self.comm_time)
#
# @property
# def comp_time(self):
# return self._comp_time
#
# @comp_time.setter
# def comp_time(self, val):
# self._comp_time = val
# self._total_time = self._comp_time + self._comm_time
#
# @property
# def comm_time(self):
# return self._comm_time
#
# @comm_time.setter
# def comm_time(self, val):
# self._comm_time = val
# self._total_time = self._comp_time + self._comm_time
#
# @property
# def total_time(self):
# return self._total_time
#
# @property
# def lowerbound(self):
# """A lowerbound under perfect pipelining."""
# return max(self._comp_time, self._comm_time)
#
# @total_time.setter
# def total_time(self, val):
# self._total_time = val
#
# def __radd__(self, other):
# if other == 0:
# return self
# else:
# return self.__add__(other)
#
# def __add__(self, other):
# if isinstance(other, int):
# return TimeMeasure(total_time=self.total_time + other)
# res = TimeMeasure(
# comp_time=self.comp_time + other.comp_time,
# comm_time=self.comm_time + other.comm_time,
# total_time=self.total_time + other.total_time)
# # Sometimes the time measure may not have detailed items,
# # in this case we set total time directly.
# # expected_total_time = self.total_time + other.total_time
# # if res.total_time != expected_total_time:
# # res.comm_time = 0
# # res.comp_time = 0
# # res.total_time = expected_total_time
# return res
#
# def __sub__(self, other):
# res = TimeMeasure(
# comp_time=self.comp_time - other.comp_time,
# comm_time=self.comm_time - other.comm_time,
# total_time=self.total_time - other.total_time)
# return res
. Output only the next line. | self.assertEqual(t_sum.total_time, t1.total_time + t2.total_time) |
Next line prediction: <|code_start|> del load_config.config
plugins = load_plugin_config()
if hasattr(load_config, 'config'):
del load_config.config
assert plugins == ['Dummy'], plugins
@patch('elodie.config.config_file', '%s/config.ini-load-plugin-config-one-with-invalid' % gettempdir())
def test_load_plugin_config_one_with_invalid():
with open('%s/config.ini-load-plugin-config-one' % gettempdir(), 'w') as f:
f.write("""
[Plugins]
plugins=DNE
""")
if hasattr(load_config, 'config'):
del load_config.config
plugins = load_plugin_config()
if hasattr(load_config, 'config'):
del load_config.config
assert plugins == [], plugins
@patch('elodie.config.config_file', '%s/config.ini-load-plugin-config-many' % gettempdir())
def test_load_plugin_config_many():
with open('%s/config.ini-load-plugin-config-many' % gettempdir(), 'w') as f:
f.write("""
<|code_end|>
. Use current file imports:
(import os
import sys
import unittest
from mock import patch
from tempfile import gettempdir
from elodie import constants
from elodie.config import load_config, load_plugin_config)
and context including class names, function names, or small code snippets from other files:
# Path: elodie/constants.py
#
# Path: elodie/config.py
# def load_config():
# if hasattr(load_config, "config"):
# return load_config.config
#
# if not path.exists(config_file):
# return {}
#
# load_config.config = RawConfigParser()
# load_config.config.read(config_file)
# return load_config.config
#
# def load_plugin_config():
# config = load_config()
#
# # If plugins are defined in the config we return them as a list
# # Else we return an empty list
# if 'Plugins' in config and 'plugins' in config['Plugins']:
# return config['Plugins']['plugins'].split(',')
#
# return []
. Output only the next line. | [Plugins] |
Using the snippet: <|code_start|> del load_config.config
plugins = load_plugin_config()
if hasattr(load_config, 'config'):
del load_config.config
assert plugins == [], plugins
@patch('elodie.config.config_file', '%s/config.ini-load-plugin-config-exists-not-set' % gettempdir())
def test_load_plugin_config_exists_not_set():
with open('%s/config.ini-load-plugin-config-exists-not-set' % gettempdir(), 'w') as f:
f.write("""
[Plugins]
""")
if hasattr(load_config, 'config'):
del load_config.config
plugins = load_plugin_config()
if hasattr(load_config, 'config'):
del load_config.config
assert plugins == [], plugins
@patch('elodie.config.config_file', '%s/config.ini-load-plugin-config-one' % gettempdir())
def test_load_plugin_config_one():
with open('%s/config.ini-load-plugin-config-one' % gettempdir(), 'w') as f:
f.write("""
[Plugins]
<|code_end|>
, determine the next line of code. You have imports:
import os
import sys
import unittest
from mock import patch
from tempfile import gettempdir
from elodie import constants
from elodie.config import load_config, load_plugin_config
and context (class names, function names, or code) available:
# Path: elodie/constants.py
#
# Path: elodie/config.py
# def load_config():
# if hasattr(load_config, "config"):
# return load_config.config
#
# if not path.exists(config_file):
# return {}
#
# load_config.config = RawConfigParser()
# load_config.config.read(config_file)
# return load_config.config
#
# def load_plugin_config():
# config = load_config()
#
# # If plugins are defined in the config we return them as a list
# # Else we return an empty list
# if 'Plugins' in config and 'plugins' in config['Plugins']:
# return config['Plugins']['plugins'].split(',')
#
# return []
. Output only the next line. | plugins=Dummy |
Predict the next line for this snippet: <|code_start|>
def test_lookup_with_invalid_location():
res = geolocation.lookup(location='foobar dne')
assert res is None, res
def test_lookup_with_invalid_location():
res = geolocation.lookup(location='foobar dne')
assert res is None, res
def test_lookup_with_valid_key():
res = geolocation.lookup(location='Sunnyvale, CA')
latLng = res['results'][0]['locations'][0]['latLng']
assert latLng['lat'] == 37.36883, latLng
assert latLng['lng'] == -122.03635, latLng
@mock.patch('elodie.geolocation.__PREFER_ENGLISH_NAMES__', True)
def test_lookup_with_prefer_english_names_true():
res = geolocation.lookup(lat=55.66333, lon=37.61583)
assert res['address']['city'] == 'Nagorny District', res
@mock.patch('elodie.geolocation.__PREFER_ENGLISH_NAMES__', False)
def test_lookup_with_prefer_english_names_false():
res = geolocation.lookup(lat=55.66333, lon=37.61583)
assert res['address']['city'] == u'\u041d\u0430\u0433\u043e\u0440\u043d\u044b\u0439 \u0440\u0430\u0439\u043e\u043d', res
@mock.patch('elodie.constants.location_db', '%s/location.json-cached' % gettempdir())
def test_place_name_deprecated_string_cached():
# See gh-160 for backwards compatability needed when a string is stored instead of a dict
helper.reset_dbs()
with open('%s/location.json-cached' % gettempdir(), 'w') as f:
<|code_end|>
with the help of current file imports:
from builtins import range
from past.utils import old_div
from mock import patch
from tempfile import gettempdir
from . import helper
from elodie import geolocation
import mock
import os
import random
import re
import sys
and context from other files:
# Path: elodie/geolocation.py
# __KEY__ = None
# __DEFAULT_LOCATION__ = 'Unknown Location'
# __PREFER_ENGLISH_NAMES__ = None
# __KEY__ = constants.mapquest_key
# __KEY__ = config['MapQuest']['key']
# __PREFER_ENGLISH_NAMES__ = bool(config['MapQuest']['prefer_english_names'])
# def coordinates_by_name(name):
# def decimal_to_dms(decimal):
# def dms_to_decimal(degrees, minutes, seconds, direction=' '):
# def dms_string(decimal, type='latitude'):
# def get_key():
# def get_prefer_english_names():
# def place_name(lat, lon):
# def lookup(**kwargs):
# def parse_result(result):
, which may contain function names, class names, or code. Output only the next line. | f.write(""" |
Given snippet: <|code_start|>from __future__ import absolute_import
# Project imports
try:
except ImportError:
sys.path.insert(0, os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))))
def call_log_and_assert(func, args, expected):
saved_stdout = sys.stdout
try:
out = StringIO()
sys.stdout = out
func(*args)
output = out.getvalue()
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import sys
import unittest
from json import dumps
from mock import patch
from StringIO import StringIO
from io import StringIO
from elodie import constants
from elodie import log
and context:
# Path: elodie/constants.py
#
# Path: elodie/log.py
# def all(message):
# def info(message):
# def info_json(payload):
# def progress(message='.', new_line=False):
# def warn(message):
# def warn_json(payload):
# def error(message):
# def error_json(payload):
# def _print_debug(string):
# def _print(s):
which might include code, classes, or functions. Output only the next line. | assert output == expected, (expected, func, output) |
Given the code snippet: <|code_start|>
try:
except ImportError:
sys.path.insert(0, os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))))
def call_result_and_assert(result, expected):
saved_stdout = sys.stdout
try:
out = StringIO()
sys.stdout = out
result.write()
output = out.getvalue().strip()
assert output == expected, output
finally:
sys.stdout = saved_stdout
def test_add_multiple_rows_with_success():
expected = """****** SUMMARY ******
Metric Count
-------- -------
Success 2
Error 0"""
result = Result()
result.append(('id1', '/some/path/1'))
result.append(('id2', '/some/path/2'))
call_result_and_assert(result, expected)
<|code_end|>
, generate the next line using the imports in this file:
import os
import sys
import unittest
from json import dumps
from mock import patch
from StringIO import StringIO
from io import StringIO
from elodie import constants
from elodie.result import Result
and context (functions, classes, or occasionally code) from other files:
# Path: elodie/constants.py
#
# Path: elodie/result.py
# class Result(object):
#
# def __init__(self):
# self.records = []
# self.success = 0
# self.error = 0
# self.error_items = []
#
# def append(self, row):
# id, status = row
#
# if status:
# self.success += 1
# else:
# self.error += 1
# self.error_items.append(id)
#
# def write(self):
# if self.error > 0:
# error_headers = ["File"]
# error_result = []
# for id in self.error_items:
# error_result.append([id])
#
# print("****** ERROR DETAILS ******")
# print(tabulate(error_result, headers=error_headers))
# print("\n")
#
# headers = ["Metric", "Count"]
# result = [
# ["Success", self.success],
# ["Error", self.error],
# ]
#
# print("****** SUMMARY ******")
# print(tabulate(result, headers=headers))
. Output only the next line. | def test_add_multiple_rows_with_failure(): |
Given snippet: <|code_start|>from __future__ import absolute_import
# Project imports
try:
reload # Python 2.7
except NameError:
try:
except ImportError:
sys.path.insert(0, os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))))
BASE_PATH = os.path.dirname(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
def test_debug():
# This seems pointless but on Travis we explicitly modify the file to be True
assert constants.debug == constants.debug, constants.debug
def test_application_directory_default():
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import sys
import unittest
from importlib import reload # Python 3.4+
from imp import reload # Python 3.0 - 3.3
from mock import patch
from elodie import constants
and context:
# Path: elodie/constants.py
which might include code, classes, or functions. Output only the next line. | if('ELODIE_APPLICATION_DIRECTORY' in os.environ): |
Predict the next line for this snippet: <|code_start|>
class SSHClient:
def __init__(self, host):
self.user, self.host = host_params(host)
self.client = ssh.SSHClient()
def connect(self):
self.client.load_system_host_keys()
self.client.set_missing_host_key_policy(ssh.WarningPolicy())
self.client.connect(self.host, port=22, username=self.user)
def close(self):
self.client.close()
def exec_command(self, command):
_, stdout, stderr = self.client.exec_command(command)
<|code_end|>
with the help of current file imports:
from .core import LOGGER
from .settings import USER
import ssh
and context from other files:
# Path: makesite/core.py
# LOGGER = logging.getLogger('Makesite')
#
# Path: makesite/settings.py
# USER = environ.get('USER', 'roor')
, which may contain function names, class names, or code. Output only the next line. | for line in stdout.readlines(): |
Given the code snippet: <|code_start|>
class SSHClient:
def __init__(self, host):
self.user, self.host = host_params(host)
self.client = ssh.SSHClient()
def connect(self):
self.client.load_system_host_keys()
self.client.set_missing_host_key_policy(ssh.WarningPolicy())
self.client.connect(self.host, port=22, username=self.user)
def close(self):
self.client.close()
<|code_end|>
, generate the next line using the imports in this file:
from .core import LOGGER
from .settings import USER
import ssh
and context (functions, classes, or occasionally code) from other files:
# Path: makesite/core.py
# LOGGER = logging.getLogger('Makesite')
#
# Path: makesite/settings.py
# USER = environ.get('USER', 'roor')
. Output only the next line. | def exec_command(self, command): |
Continue the code snippet: <|code_start|>
class UserManager(Blueprint):
def __init__(self, *args, **kwargs):
self._login_manager = None
self._principal = None
self.app = None
super(UserManager, self).__init__(*args, **kwargs)
def register(self, app, *args, **kwargs):
" Activate loginmanager and principal. "
if not self._login_manager or self.app != app:
self._login_manager = LoginManager()
<|code_end|>
. Use current file imports:
from flask import Blueprint
from flask_login import LoginManager, login_required, logout_user, login_user, current_user
from flask_principal import Principal, identity_changed, Identity, AnonymousIdentity, identity_loaded, UserNeed, RoleNeed
from ..ext import db
from .models import User
and context (classes, functions, or code) from other files:
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
#
# Path: makesite/modules/flask/base/auth/models.py
# class User(db.Model, UserMixin, BaseMixin):
# " Main user model. "
#
# __tablename__ = 'users_user'
#
# username = db.Column(db.String(50), unique=True)
# email = db.Column(db.String(120))
# active = db.Column(db.Boolean, default=True)
# _pw_hash = db.Column(db.String(199), nullable=False)
#
# # OAuth creds
# oauth_token = db.Column(db.String(200))
# oauth_secret = db.Column(db.String(200))
#
# @declared_attr
# def roles(self):
# assert self
# return db.relationship("Role", secondary=userroles, backref="users")
#
# @hybrid_property
# def pw_hash(self):
# """Simple getter function for the user's password."""
# return self._pw_hash
#
# @pw_hash.setter
# def pw_hash(self, raw_password):
# """ Password setter, that handles the hashing
# in the database.
# """
# self._pw_hash = generate_password_hash(raw_password)
#
# @staticmethod
# def permission(role):
# perm = Permission(RoleNeed(role))
# return perm.can()
#
# def check_password(self, password):
# return check_password_hash(self.pw_hash, password)
#
# def is_active(self):
# return self.active
#
# def __unicode__(self):
# return self.username
#
# def __repr__(self):
# return '<User %r>' % (self.username)
. Output only the next line. | self._login_manager.user_callback = self.user_loader |
Given the code snippet: <|code_start|>
if not self._login_manager or self.app != app:
self._login_manager = LoginManager()
self._login_manager.user_callback = self.user_loader
self._login_manager.setup_app(app)
self._login_manager.login_view = 'urls.index'
self._login_manager.login_message = u'You need to be signed in for this page.'
self.app = app
if not self._principal:
self._principal = Principal(app)
identity_loaded.connect(self.identity_loaded)
super(UserManager, self).register(app, *args, **kwargs)
@staticmethod
def user_loader(pk):
return User.query.options(db.joinedload(User.roles)).get(pk)
@staticmethod
def login_required(fn):
return login_required(fn)
def logout(self):
identity_changed.send(self.app, identity=AnonymousIdentity())
return logout_user()
def login(self, user):
identity_changed.send(self.app, identity=Identity(user.id))
<|code_end|>
, generate the next line using the imports in this file:
from flask import Blueprint
from flask_login import LoginManager, login_required, logout_user, login_user, current_user
from flask_principal import Principal, identity_changed, Identity, AnonymousIdentity, identity_loaded, UserNeed, RoleNeed
from ..ext import db
from .models import User
and context (functions, classes, or occasionally code) from other files:
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
#
# Path: makesite/modules/flask/base/auth/models.py
# class User(db.Model, UserMixin, BaseMixin):
# " Main user model. "
#
# __tablename__ = 'users_user'
#
# username = db.Column(db.String(50), unique=True)
# email = db.Column(db.String(120))
# active = db.Column(db.Boolean, default=True)
# _pw_hash = db.Column(db.String(199), nullable=False)
#
# # OAuth creds
# oauth_token = db.Column(db.String(200))
# oauth_secret = db.Column(db.String(200))
#
# @declared_attr
# def roles(self):
# assert self
# return db.relationship("Role", secondary=userroles, backref="users")
#
# @hybrid_property
# def pw_hash(self):
# """Simple getter function for the user's password."""
# return self._pw_hash
#
# @pw_hash.setter
# def pw_hash(self, raw_password):
# """ Password setter, that handles the hashing
# in the database.
# """
# self._pw_hash = generate_password_hash(raw_password)
#
# @staticmethod
# def permission(role):
# perm = Permission(RoleNeed(role))
# return perm.can()
#
# def check_password(self, password):
# return check_password_hash(self.pw_hash, password)
#
# def is_active(self):
# return self.active
#
# def __unicode__(self):
# return self.username
#
# def __repr__(self):
# return '<User %r>' % (self.username)
. Output only the next line. | return login_user(user) |
Continue the code snippet: <|code_start|>
class BaseCoreTest(TestCase):
def create_app(self):
return create_app(test)
<|code_end|>
. Use current file imports:
from flask_testing import TestCase
from ..app import create_app
from ..config import test
from ..ext import db
from ..ext import cache
and context (classes, functions, or code) from other files:
# Path: makesite/modules/flask/base/app.py
# def create_app(config=None, **skip):
# app = Flask(__name__)
# app.config.from_object(config or production)
# app.config.from_envvar("APP_SETTINGS", silent=True)
#
# from .ext import config_extensions
# config_extensions(app)
#
# from .loader import loader
# loader.register(app)
#
# return app
#
# Path: makesite/modules/flask/base/config/test.py
# SQLALCHEMY_DATABASE_URI = 'sqlite:///:memory:'
# CSRF_ENABLED = False
# CACHE_TYPE = 'simple'
#
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
. Output only the next line. | def setUp(self): |
Given the following code snippet before the placeholder: <|code_start|>
class BaseCoreTest(TestCase):
def create_app(self):
return create_app(test)
def setUp(self):
db.create_all()
def tearDown(self):
db.session.remove()
db.drop_all()
def test_home(self):
response = self.client.get('/')
self.assert200(response)
def test_admin(self):
response = self.client.get('/admin/')
self.assert403(response)
<|code_end|>
, predict the next line using imports from the current file:
from flask_testing import TestCase
from ..app import create_app
from ..config import test
from ..ext import db
from ..ext import cache
and context including class names, function names, and sometimes code from other files:
# Path: makesite/modules/flask/base/app.py
# def create_app(config=None, **skip):
# app = Flask(__name__)
# app.config.from_object(config or production)
# app.config.from_envvar("APP_SETTINGS", silent=True)
#
# from .ext import config_extensions
# config_extensions(app)
#
# from .loader import loader
# loader.register(app)
#
# return app
#
# Path: makesite/modules/flask/base/config/test.py
# SQLALCHEMY_DATABASE_URI = 'sqlite:///:memory:'
# CSRF_ENABLED = False
# CACHE_TYPE = 'simple'
#
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
. Output only the next line. | def test_cache(self): |
Predict the next line after this snippet: <|code_start|>
class BaseCoreTest(TestCase):
def create_app(self):
return create_app(test)
def setUp(self):
db.create_all()
def tearDown(self):
db.session.remove()
db.drop_all()
def test_home(self):
response = self.client.get('/')
<|code_end|>
using the current file's imports:
from flask_testing import TestCase
from ..app import create_app
from ..config import test
from ..ext import db
from ..ext import cache
and any relevant context from other files:
# Path: makesite/modules/flask/base/app.py
# def create_app(config=None, **skip):
# app = Flask(__name__)
# app.config.from_object(config or production)
# app.config.from_envvar("APP_SETTINGS", silent=True)
#
# from .ext import config_extensions
# config_extensions(app)
#
# from .loader import loader
# loader.register(app)
#
# return app
#
# Path: makesite/modules/flask/base/config/test.py
# SQLALCHEMY_DATABASE_URI = 'sqlite:///:memory:'
# CSRF_ENABLED = False
# CACHE_TYPE = 'simple'
#
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
. Output only the next line. | self.assert200(response) |
Using the snippet: <|code_start|>
DEPLOYDIR = op.dirname(op.dirname(__file__))
def read_config(folder):
path = op.join(folder, CFGNAME)
parser = MakesiteParser()
parser.read(path)
try:
site = dict(parser.items('Main'))
except Exception:
return dict(project=None)
git_head = op.join(folder, 'source', '.git', 'HEAD')
<|code_end|>
, determine the next line of code. You have imports:
from os import path as op, listdir
from makesite.settings import CFGNAME
from makesite.core import MakesiteParser
and context (class names, function names, or code) available:
# Path: makesite/settings.py
# CFGNAME = 'makesite.ini'
#
# Path: makesite/core.py
# LOGGER = logging.getLogger('Makesite')
# LOGFILE_HANDLER = logging.FileHandler(
# mktemp('.log', 'ms.%s-' % datetime.now().strftime('%d.%m')))
# STREAM_HANDLER = logging.StreamHandler(stdout)
# ACTIONS = dict()
# class ColoredFormater(logging.Formatter):
# class MakesiteArgsParser(ArgumentParser):
# class OrderedSet(list):
# class MakesiteException(AssertionError):
# def format(self, record):
# def error(self, message):
# def parse_args(self, args=None, namespace=None):
# def action(*arguments, **options):
# def _inner(func):
# def _wrapper(params=None):
# def __init__(self, sequence):
# def get_project_templates(path):
# def get_base_modules():
# def get_base_templates():
# def print_header(msg, sep='='):
# def which(program):
# def call(cmd, shell=True, **kwargs):
# def walklevel(dirpath, level=1):
# def is_exe(path):
# def gen_template_files(path):
. Output only the next line. | if op.exists(git_head): |
Given the code snippet: <|code_start|> site = dict(parser.items('Main'))
except Exception:
return dict(project=None)
git_head = op.join(folder, 'source', '.git', 'HEAD')
if op.exists(git_head):
try:
head = open(git_head).read().split()[1]
site['revision'] = open(
op.join(folder, 'source', '.git', head)).read()
except (IOError, IndexError):
return site
return site
def get_sites():
config = read_config(DEPLOYDIR)
sites = []
root = config['makesite_home']
for prj_name in listdir(root):
prj = op.join(root, prj_name)
if op.isdir(prj):
for brn_name in listdir(prj):
brn = op.join(prj, brn_name)
if op.isdir(brn):
for f in listdir(brn):
if f == CFGNAME:
sites.append(read_config(brn))
sites.sort(key=lambda x: x.get('project'))
<|code_end|>
, generate the next line using the imports in this file:
from os import path as op, listdir
from makesite.settings import CFGNAME
from makesite.core import MakesiteParser
and context (functions, classes, or occasionally code) from other files:
# Path: makesite/settings.py
# CFGNAME = 'makesite.ini'
#
# Path: makesite/core.py
# LOGGER = logging.getLogger('Makesite')
# LOGFILE_HANDLER = logging.FileHandler(
# mktemp('.log', 'ms.%s-' % datetime.now().strftime('%d.%m')))
# STREAM_HANDLER = logging.StreamHandler(stdout)
# ACTIONS = dict()
# class ColoredFormater(logging.Formatter):
# class MakesiteArgsParser(ArgumentParser):
# class OrderedSet(list):
# class MakesiteException(AssertionError):
# def format(self, record):
# def error(self, message):
# def parse_args(self, args=None, namespace=None):
# def action(*arguments, **options):
# def _inner(func):
# def _wrapper(params=None):
# def __init__(self, sequence):
# def get_project_templates(path):
# def get_base_modules():
# def get_base_templates():
# def print_header(msg, sep='='):
# def which(program):
# def call(cmd, shell=True, **kwargs):
# def walklevel(dirpath, level=1):
# def is_exe(path):
# def gen_template_files(path):
. Output only the next line. | return sites |
Here is a snippet: <|code_start|>
if full:
context = self.as_dict()
return "".join("{0:<25} = {1}\n".format(
key, context[key]) for key in sorted(context.iterkeys()))
return "%s [%s]" % (self.get_name(), self.template)
def get_name(self):
" Return name of site in format: 'project.branch'. "
return "%s.%s" % (self.project, self.safe_branch or self.branch)
def run_check(self, template_name=None, service_dir=None):
" Run checking scripts. "
print_header('Check requirements', sep='-')
map(lambda cmd: call("bash %s" % cmd), self._gen_scripts(
'check', template_name=template_name, service_dir=service_dir))
return True
def run_install(self, template_name=None, service_dir=None):
" Run instalation scripts. "
LOGGER.info('Site Install start.')
print_header('Install %s' % self.get_name())
map(call, self._gen_scripts(
'install', template_name=template_name, service_dir=service_dir))
LOGGER.info('Site Install done.')
return True
<|code_end|>
. Write the next line using the current file imports:
from os import path as op, listdir, makedirs, remove
from shutil import copy2
from tempfile import mkdtemp
from tempita import Template
from makesite import settings
from makesite.core import walklevel, call, print_header, is_exe, gen_template_files, LOGGER
and context from other files:
# Path: makesite/settings.py
# BASEDIR = op.abspath(op.dirname(__file__))
# TPL_DIR = op.join(BASEDIR, 'templates')
# MOD_DIR = op.join(BASEDIR, 'modules')
# TPLNAME = '.makesite'
# CFGNAME = 'makesite.ini'
# BASECONFIG = op.join(BASEDIR, CFGNAME)
# HOMECONFIG = op.join(getenv('HOME', '~'), CFGNAME)
# MAKESITE_HOME = environ.get('MAKESITE_HOME')
# USER = environ.get('USER', 'roor')
# SRC_CLONE = (
# ('svn', 'svn checkout %(src)s %(source_dir)s'),
# ('git', 'git clone %(src)s %(source_dir)s -b %(branch)s'),
# ('hg', 'hg clone %(src)s %(source_dir)s'),
# )
# class MakesiteParser(ConfigParser):
# def __init__(self, *args, **kwargs):
# def defaults(self):
# def __getitem__(self, name):
# def __setitem__(self, name, value, section='Main'):
# def __getattr__(self, name):
# def as_dict(self, section='Main', **kwargs):
# def read(self, filenames, extending=False, map_sections=None):
#
# Path: makesite/core.py
# def walklevel(dirpath, level=1):
# dirpath = dirpath.rstrip(op.sep)
# assert op.isdir(dirpath)
# start = dirpath.count(op.sep)
# for root, dirs, files in walk(dirpath):
# yield root, dirs, files
# if start + level <= root.count(op.sep):
# del dirs[:]
#
# def call(cmd, shell=True, **kwargs):
# " Run shell command. "
#
# LOGGER.debug("Cmd: %s" % cmd)
# check_call(cmd, shell=shell, stdout=LOGFILE_HANDLER.stream, **kwargs)
#
# def print_header(msg, sep='='):
# " More strong message "
#
# LOGGER.info("\n%s\n%s" % (msg, ''.join(sep for _ in msg)))
#
# def is_exe(path):
# return op.exists(path) and access(path, X_OK)
#
# def gen_template_files(path):
# " Generate relative template pathes. "
#
# path = path.rstrip(op.sep)
# for root, _, files in walk(path):
# for f in filter(lambda x: not x in (TPLNAME, CFGNAME), files):
# yield op.relpath(op.join(root, f), path)
#
# LOGGER = logging.getLogger('Makesite')
, which may include functions, classes, or code. Output only the next line. | def run_update(self, template_name=None, service_dir=None): |
Using the snippet: <|code_start|>
class Site(settings.MakesiteParser):
" Operations with site instance. "
def __init__(self, deploy_dir):
" Init site options. "
super(Site, self).__init__()
self.deploy_dir = deploy_dir.rstrip(op.sep)
self.read([op.join(self.deploy_dir, settings.CFGNAME)])
assert self.project and self.branch, "Invalid site: %s" % self.deploy_dir
self.templates = self.template.split(',')
def get_info(self, full=False):
" Return printable information about current site. "
if full:
context = self.as_dict()
return "".join("{0:<25} = {1}\n".format(
key, context[key]) for key in sorted(context.iterkeys()))
return "%s [%s]" % (self.get_name(), self.template)
def get_name(self):
" Return name of site in format: 'project.branch'. "
return "%s.%s" % (self.project, self.safe_branch or self.branch)
def run_check(self, template_name=None, service_dir=None):
<|code_end|>
, determine the next line of code. You have imports:
from os import path as op, listdir, makedirs, remove
from shutil import copy2
from tempfile import mkdtemp
from tempita import Template
from makesite import settings
from makesite.core import walklevel, call, print_header, is_exe, gen_template_files, LOGGER
and context (class names, function names, or code) available:
# Path: makesite/settings.py
# BASEDIR = op.abspath(op.dirname(__file__))
# TPL_DIR = op.join(BASEDIR, 'templates')
# MOD_DIR = op.join(BASEDIR, 'modules')
# TPLNAME = '.makesite'
# CFGNAME = 'makesite.ini'
# BASECONFIG = op.join(BASEDIR, CFGNAME)
# HOMECONFIG = op.join(getenv('HOME', '~'), CFGNAME)
# MAKESITE_HOME = environ.get('MAKESITE_HOME')
# USER = environ.get('USER', 'roor')
# SRC_CLONE = (
# ('svn', 'svn checkout %(src)s %(source_dir)s'),
# ('git', 'git clone %(src)s %(source_dir)s -b %(branch)s'),
# ('hg', 'hg clone %(src)s %(source_dir)s'),
# )
# class MakesiteParser(ConfigParser):
# def __init__(self, *args, **kwargs):
# def defaults(self):
# def __getitem__(self, name):
# def __setitem__(self, name, value, section='Main'):
# def __getattr__(self, name):
# def as_dict(self, section='Main', **kwargs):
# def read(self, filenames, extending=False, map_sections=None):
#
# Path: makesite/core.py
# def walklevel(dirpath, level=1):
# dirpath = dirpath.rstrip(op.sep)
# assert op.isdir(dirpath)
# start = dirpath.count(op.sep)
# for root, dirs, files in walk(dirpath):
# yield root, dirs, files
# if start + level <= root.count(op.sep):
# del dirs[:]
#
# def call(cmd, shell=True, **kwargs):
# " Run shell command. "
#
# LOGGER.debug("Cmd: %s" % cmd)
# check_call(cmd, shell=shell, stdout=LOGFILE_HANDLER.stream, **kwargs)
#
# def print_header(msg, sep='='):
# " More strong message "
#
# LOGGER.info("\n%s\n%s" % (msg, ''.join(sep for _ in msg)))
#
# def is_exe(path):
# return op.exists(path) and access(path, X_OK)
#
# def gen_template_files(path):
# " Generate relative template pathes. "
#
# path = path.rstrip(op.sep)
# for root, _, files in walk(path):
# for f in filter(lambda x: not x in (TPLNAME, CFGNAME), files):
# yield op.relpath(op.join(root, f), path)
#
# LOGGER = logging.getLogger('Makesite')
. Output only the next line. | " Run checking scripts. " |
Continue the code snippet: <|code_start|> try:
path = self.get('Templates', template_name)
except settings.Error:
path = op.join(settings.TPL_DIR, template_name)
assert op.exists(path), "Template not found."
return path
def gen_sites(path):
" Seek sites by path. "
for root, _, _ in walklevel(path, 2):
try:
yield Site(root)
except AssertionError:
continue
def find_site(site, path=None):
" Return inited site by name (project.bracnch) or path "
try:
return Site(site)
except AssertionError:
path = path or settings.MAKESITE_HOME
if op.sep in site:
raise
site = site if '.' in site else "%s.master" % site
<|code_end|>
. Use current file imports:
from os import path as op, listdir, makedirs, remove
from shutil import copy2
from tempfile import mkdtemp
from tempita import Template
from makesite import settings
from makesite.core import walklevel, call, print_header, is_exe, gen_template_files, LOGGER
and context (classes, functions, or code) from other files:
# Path: makesite/settings.py
# BASEDIR = op.abspath(op.dirname(__file__))
# TPL_DIR = op.join(BASEDIR, 'templates')
# MOD_DIR = op.join(BASEDIR, 'modules')
# TPLNAME = '.makesite'
# CFGNAME = 'makesite.ini'
# BASECONFIG = op.join(BASEDIR, CFGNAME)
# HOMECONFIG = op.join(getenv('HOME', '~'), CFGNAME)
# MAKESITE_HOME = environ.get('MAKESITE_HOME')
# USER = environ.get('USER', 'roor')
# SRC_CLONE = (
# ('svn', 'svn checkout %(src)s %(source_dir)s'),
# ('git', 'git clone %(src)s %(source_dir)s -b %(branch)s'),
# ('hg', 'hg clone %(src)s %(source_dir)s'),
# )
# class MakesiteParser(ConfigParser):
# def __init__(self, *args, **kwargs):
# def defaults(self):
# def __getitem__(self, name):
# def __setitem__(self, name, value, section='Main'):
# def __getattr__(self, name):
# def as_dict(self, section='Main', **kwargs):
# def read(self, filenames, extending=False, map_sections=None):
#
# Path: makesite/core.py
# def walklevel(dirpath, level=1):
# dirpath = dirpath.rstrip(op.sep)
# assert op.isdir(dirpath)
# start = dirpath.count(op.sep)
# for root, dirs, files in walk(dirpath):
# yield root, dirs, files
# if start + level <= root.count(op.sep):
# del dirs[:]
#
# def call(cmd, shell=True, **kwargs):
# " Run shell command. "
#
# LOGGER.debug("Cmd: %s" % cmd)
# check_call(cmd, shell=shell, stdout=LOGFILE_HANDLER.stream, **kwargs)
#
# def print_header(msg, sep='='):
# " More strong message "
#
# LOGGER.info("\n%s\n%s" % (msg, ''.join(sep for _ in msg)))
#
# def is_exe(path):
# return op.exists(path) and access(path, X_OK)
#
# def gen_template_files(path):
# " Generate relative template pathes. "
#
# path = path.rstrip(op.sep)
# for root, _, files in walk(path):
# for f in filter(lambda x: not x in (TPLNAME, CFGNAME), files):
# yield op.relpath(op.join(root, f), path)
#
# LOGGER = logging.getLogger('Makesite')
. Output only the next line. | project, branch = site.split('.', 1) |
Next line prediction: <|code_start|>
class Site(settings.MakesiteParser):
" Operations with site instance. "
def __init__(self, deploy_dir):
" Init site options. "
super(Site, self).__init__()
self.deploy_dir = deploy_dir.rstrip(op.sep)
self.read([op.join(self.deploy_dir, settings.CFGNAME)])
assert self.project and self.branch, "Invalid site: %s" % self.deploy_dir
<|code_end|>
. Use current file imports:
(from os import path as op, listdir, makedirs, remove
from shutil import copy2
from tempfile import mkdtemp
from tempita import Template
from makesite import settings
from makesite.core import walklevel, call, print_header, is_exe, gen_template_files, LOGGER)
and context including class names, function names, or small code snippets from other files:
# Path: makesite/settings.py
# BASEDIR = op.abspath(op.dirname(__file__))
# TPL_DIR = op.join(BASEDIR, 'templates')
# MOD_DIR = op.join(BASEDIR, 'modules')
# TPLNAME = '.makesite'
# CFGNAME = 'makesite.ini'
# BASECONFIG = op.join(BASEDIR, CFGNAME)
# HOMECONFIG = op.join(getenv('HOME', '~'), CFGNAME)
# MAKESITE_HOME = environ.get('MAKESITE_HOME')
# USER = environ.get('USER', 'roor')
# SRC_CLONE = (
# ('svn', 'svn checkout %(src)s %(source_dir)s'),
# ('git', 'git clone %(src)s %(source_dir)s -b %(branch)s'),
# ('hg', 'hg clone %(src)s %(source_dir)s'),
# )
# class MakesiteParser(ConfigParser):
# def __init__(self, *args, **kwargs):
# def defaults(self):
# def __getitem__(self, name):
# def __setitem__(self, name, value, section='Main'):
# def __getattr__(self, name):
# def as_dict(self, section='Main', **kwargs):
# def read(self, filenames, extending=False, map_sections=None):
#
# Path: makesite/core.py
# def walklevel(dirpath, level=1):
# dirpath = dirpath.rstrip(op.sep)
# assert op.isdir(dirpath)
# start = dirpath.count(op.sep)
# for root, dirs, files in walk(dirpath):
# yield root, dirs, files
# if start + level <= root.count(op.sep):
# del dirs[:]
#
# def call(cmd, shell=True, **kwargs):
# " Run shell command. "
#
# LOGGER.debug("Cmd: %s" % cmd)
# check_call(cmd, shell=shell, stdout=LOGFILE_HANDLER.stream, **kwargs)
#
# def print_header(msg, sep='='):
# " More strong message "
#
# LOGGER.info("\n%s\n%s" % (msg, ''.join(sep for _ in msg)))
#
# def is_exe(path):
# return op.exists(path) and access(path, X_OK)
#
# def gen_template_files(path):
# " Generate relative template pathes. "
#
# path = path.rstrip(op.sep)
# for root, _, files in walk(path):
# for f in filter(lambda x: not x in (TPLNAME, CFGNAME), files):
# yield op.relpath(op.join(root, f), path)
#
# LOGGER = logging.getLogger('Makesite')
. Output only the next line. | self.templates = self.template.split(',') |
Here is a snippet: <|code_start|> return "%s.%s" % (self.project, self.safe_branch or self.branch)
def run_check(self, template_name=None, service_dir=None):
" Run checking scripts. "
print_header('Check requirements', sep='-')
map(lambda cmd: call("bash %s" % cmd), self._gen_scripts(
'check', template_name=template_name, service_dir=service_dir))
return True
def run_install(self, template_name=None, service_dir=None):
" Run instalation scripts. "
LOGGER.info('Site Install start.')
print_header('Install %s' % self.get_name())
map(call, self._gen_scripts(
'install', template_name=template_name, service_dir=service_dir))
LOGGER.info('Site Install done.')
return True
def run_update(self, template_name=None, service_dir=None):
" Run update scripts. "
LOGGER.info('Site Update start.')
print_header('Update %s' % self.get_name())
map(call, self._gen_scripts(
'update', template_name=template_name, service_dir=service_dir))
LOGGER.info('Site Update done.')
return True
<|code_end|>
. Write the next line using the current file imports:
from os import path as op, listdir, makedirs, remove
from shutil import copy2
from tempfile import mkdtemp
from tempita import Template
from makesite import settings
from makesite.core import walklevel, call, print_header, is_exe, gen_template_files, LOGGER
and context from other files:
# Path: makesite/settings.py
# BASEDIR = op.abspath(op.dirname(__file__))
# TPL_DIR = op.join(BASEDIR, 'templates')
# MOD_DIR = op.join(BASEDIR, 'modules')
# TPLNAME = '.makesite'
# CFGNAME = 'makesite.ini'
# BASECONFIG = op.join(BASEDIR, CFGNAME)
# HOMECONFIG = op.join(getenv('HOME', '~'), CFGNAME)
# MAKESITE_HOME = environ.get('MAKESITE_HOME')
# USER = environ.get('USER', 'roor')
# SRC_CLONE = (
# ('svn', 'svn checkout %(src)s %(source_dir)s'),
# ('git', 'git clone %(src)s %(source_dir)s -b %(branch)s'),
# ('hg', 'hg clone %(src)s %(source_dir)s'),
# )
# class MakesiteParser(ConfigParser):
# def __init__(self, *args, **kwargs):
# def defaults(self):
# def __getitem__(self, name):
# def __setitem__(self, name, value, section='Main'):
# def __getattr__(self, name):
# def as_dict(self, section='Main', **kwargs):
# def read(self, filenames, extending=False, map_sections=None):
#
# Path: makesite/core.py
# def walklevel(dirpath, level=1):
# dirpath = dirpath.rstrip(op.sep)
# assert op.isdir(dirpath)
# start = dirpath.count(op.sep)
# for root, dirs, files in walk(dirpath):
# yield root, dirs, files
# if start + level <= root.count(op.sep):
# del dirs[:]
#
# def call(cmd, shell=True, **kwargs):
# " Run shell command. "
#
# LOGGER.debug("Cmd: %s" % cmd)
# check_call(cmd, shell=shell, stdout=LOGFILE_HANDLER.stream, **kwargs)
#
# def print_header(msg, sep='='):
# " More strong message "
#
# LOGGER.info("\n%s\n%s" % (msg, ''.join(sep for _ in msg)))
#
# def is_exe(path):
# return op.exists(path) and access(path, X_OK)
#
# def gen_template_files(path):
# " Generate relative template pathes. "
#
# path = path.rstrip(op.sep)
# for root, _, files in walk(path):
# for f in filter(lambda x: not x in (TPLNAME, CFGNAME), files):
# yield op.relpath(op.join(root, f), path)
#
# LOGGER = logging.getLogger('Makesite')
, which may include functions, classes, or code. Output only the next line. | def run_remove(self, template_name=None, service_dir=None): |
Given the following code snippet before the placeholder: <|code_start|> path = self.get('Templates', template_name)
except settings.Error:
path = op.join(settings.TPL_DIR, template_name)
assert op.exists(path), "Template not found."
return path
def gen_sites(path):
" Seek sites by path. "
for root, _, _ in walklevel(path, 2):
try:
yield Site(root)
except AssertionError:
continue
def find_site(site, path=None):
" Return inited site by name (project.bracnch) or path "
try:
return Site(site)
except AssertionError:
path = path or settings.MAKESITE_HOME
if op.sep in site:
raise
site = site if '.' in site else "%s.master" % site
project, branch = site.split('.', 1)
<|code_end|>
, predict the next line using imports from the current file:
from os import path as op, listdir, makedirs, remove
from shutil import copy2
from tempfile import mkdtemp
from tempita import Template
from makesite import settings
from makesite.core import walklevel, call, print_header, is_exe, gen_template_files, LOGGER
and context including class names, function names, and sometimes code from other files:
# Path: makesite/settings.py
# BASEDIR = op.abspath(op.dirname(__file__))
# TPL_DIR = op.join(BASEDIR, 'templates')
# MOD_DIR = op.join(BASEDIR, 'modules')
# TPLNAME = '.makesite'
# CFGNAME = 'makesite.ini'
# BASECONFIG = op.join(BASEDIR, CFGNAME)
# HOMECONFIG = op.join(getenv('HOME', '~'), CFGNAME)
# MAKESITE_HOME = environ.get('MAKESITE_HOME')
# USER = environ.get('USER', 'roor')
# SRC_CLONE = (
# ('svn', 'svn checkout %(src)s %(source_dir)s'),
# ('git', 'git clone %(src)s %(source_dir)s -b %(branch)s'),
# ('hg', 'hg clone %(src)s %(source_dir)s'),
# )
# class MakesiteParser(ConfigParser):
# def __init__(self, *args, **kwargs):
# def defaults(self):
# def __getitem__(self, name):
# def __setitem__(self, name, value, section='Main'):
# def __getattr__(self, name):
# def as_dict(self, section='Main', **kwargs):
# def read(self, filenames, extending=False, map_sections=None):
#
# Path: makesite/core.py
# def walklevel(dirpath, level=1):
# dirpath = dirpath.rstrip(op.sep)
# assert op.isdir(dirpath)
# start = dirpath.count(op.sep)
# for root, dirs, files in walk(dirpath):
# yield root, dirs, files
# if start + level <= root.count(op.sep):
# del dirs[:]
#
# def call(cmd, shell=True, **kwargs):
# " Run shell command. "
#
# LOGGER.debug("Cmd: %s" % cmd)
# check_call(cmd, shell=shell, stdout=LOGFILE_HANDLER.stream, **kwargs)
#
# def print_header(msg, sep='='):
# " More strong message "
#
# LOGGER.info("\n%s\n%s" % (msg, ''.join(sep for _ in msg)))
#
# def is_exe(path):
# return op.exists(path) and access(path, X_OK)
#
# def gen_template_files(path):
# " Generate relative template pathes. "
#
# path = path.rstrip(op.sep)
# for root, _, files in walk(path):
# for f in filter(lambda x: not x in (TPLNAME, CFGNAME), files):
# yield op.relpath(op.join(root, f), path)
#
# LOGGER = logging.getLogger('Makesite')
. Output only the next line. | return Site(op.join(path, project, branch)) |
Given the code snippet: <|code_start|>
class Site(settings.MakesiteParser):
" Operations with site instance. "
def __init__(self, deploy_dir):
" Init site options. "
super(Site, self).__init__()
self.deploy_dir = deploy_dir.rstrip(op.sep)
self.read([op.join(self.deploy_dir, settings.CFGNAME)])
<|code_end|>
, generate the next line using the imports in this file:
from os import path as op, listdir, makedirs, remove
from shutil import copy2
from tempfile import mkdtemp
from tempita import Template
from makesite import settings
from makesite.core import walklevel, call, print_header, is_exe, gen_template_files, LOGGER
and context (functions, classes, or occasionally code) from other files:
# Path: makesite/settings.py
# BASEDIR = op.abspath(op.dirname(__file__))
# TPL_DIR = op.join(BASEDIR, 'templates')
# MOD_DIR = op.join(BASEDIR, 'modules')
# TPLNAME = '.makesite'
# CFGNAME = 'makesite.ini'
# BASECONFIG = op.join(BASEDIR, CFGNAME)
# HOMECONFIG = op.join(getenv('HOME', '~'), CFGNAME)
# MAKESITE_HOME = environ.get('MAKESITE_HOME')
# USER = environ.get('USER', 'roor')
# SRC_CLONE = (
# ('svn', 'svn checkout %(src)s %(source_dir)s'),
# ('git', 'git clone %(src)s %(source_dir)s -b %(branch)s'),
# ('hg', 'hg clone %(src)s %(source_dir)s'),
# )
# class MakesiteParser(ConfigParser):
# def __init__(self, *args, **kwargs):
# def defaults(self):
# def __getitem__(self, name):
# def __setitem__(self, name, value, section='Main'):
# def __getattr__(self, name):
# def as_dict(self, section='Main', **kwargs):
# def read(self, filenames, extending=False, map_sections=None):
#
# Path: makesite/core.py
# def walklevel(dirpath, level=1):
# dirpath = dirpath.rstrip(op.sep)
# assert op.isdir(dirpath)
# start = dirpath.count(op.sep)
# for root, dirs, files in walk(dirpath):
# yield root, dirs, files
# if start + level <= root.count(op.sep):
# del dirs[:]
#
# def call(cmd, shell=True, **kwargs):
# " Run shell command. "
#
# LOGGER.debug("Cmd: %s" % cmd)
# check_call(cmd, shell=shell, stdout=LOGFILE_HANDLER.stream, **kwargs)
#
# def print_header(msg, sep='='):
# " More strong message "
#
# LOGGER.info("\n%s\n%s" % (msg, ''.join(sep for _ in msg)))
#
# def is_exe(path):
# return op.exists(path) and access(path, X_OK)
#
# def gen_template_files(path):
# " Generate relative template pathes. "
#
# path = path.rstrip(op.sep)
# for root, _, files in walk(path):
# for f in filter(lambda x: not x in (TPLNAME, CFGNAME), files):
# yield op.relpath(op.join(root, f), path)
#
# LOGGER = logging.getLogger('Makesite')
. Output only the next line. | assert self.project and self.branch, "Invalid site: %s" % self.deploy_dir |
Continue the code snippet: <|code_start|> continue
if not name in oauth.remote_apps:
remote_app = oauth.remote_app(name, **config)
else:
remote_app = oauth.remote_apps[name]
client_class = CLIENTS.get(name)
client_class(app, remote_app)
class OAuthBase():
name = 'base'
def __init__(self, app, remote_app):
remote_app.tokengetter_func = self.get_token
def login():
return remote_app.authorize(
callback=(
url_for('authorize_%s' % self.name,
next=request.args.get('next') or request.referrer or None)))
login_name = 'login_%s' % self.name
app.add_url_rule('/%s' % login_name, login_name, login)
authorize_name = 'authorize_%s' % self.name
app.add_url_rule('/%s' % authorize_name,
authorize_name,
<|code_end|>
. Use current file imports:
from flask import url_for, request, flash, redirect
from flask_login import current_user
from flaskext.babel import lazy_gettext as _
from flaskext.oauth import OAuth
from random import choice
from ..ext import db
from .models import User
from .views import users
and context (classes, functions, or code) from other files:
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
#
# Path: makesite/modules/flask/base/auth/models.py
# class User(db.Model, UserMixin, BaseMixin):
# " Main user model. "
#
# __tablename__ = 'users_user'
#
# username = db.Column(db.String(50), unique=True)
# email = db.Column(db.String(120))
# active = db.Column(db.Boolean, default=True)
# _pw_hash = db.Column(db.String(199), nullable=False)
#
# # OAuth creds
# oauth_token = db.Column(db.String(200))
# oauth_secret = db.Column(db.String(200))
#
# @declared_attr
# def roles(self):
# assert self
# return db.relationship("Role", secondary=userroles, backref="users")
#
# @hybrid_property
# def pw_hash(self):
# """Simple getter function for the user's password."""
# return self._pw_hash
#
# @pw_hash.setter
# def pw_hash(self, raw_password):
# """ Password setter, that handles the hashing
# in the database.
# """
# self._pw_hash = generate_password_hash(raw_password)
#
# @staticmethod
# def permission(role):
# perm = Permission(RoleNeed(role))
# return perm.can()
#
# def check_password(self, password):
# return check_password_hash(self.pw_hash, password)
#
# def is_active(self):
# return self.active
#
# def __unicode__(self):
# return self.username
#
# def __repr__(self):
# return '<User %r>' % (self.username)
#
# Path: makesite/modules/flask/base/auth/views.py
# def profile():
# def login():
# def logout():
# def register():
. Output only the next line. | remote_app.authorized_handler(self.authorize)) |
Given the following code snippet before the placeholder: <|code_start|>
@staticmethod
def get_token():
if current_user.is_authenticated() and current_user.oauth_token:
return current_user.oauth_token, current_user.oauth_secret
def authorize(self, resp):
pass
class OAuthTwitter(OAuthBase):
name = 'twitter'
def authorize(self, resp):
next_url = request.args.get('next') or url_for('urls.index')
if resp is None:
flash(_(u'You denied the request to sign in.'))
return redirect(next_url)
user = current_user
if not user.is_authenticated():
user = User.query.filter(
User.username == resp['screen_name']).first()
if user is None:
user = User(
username=resp['screen_name'],
pw_hash=''.join(choice(ASCII_LOWERCASE) for c in xrange(15)))
db.session.add(user)
<|code_end|>
, predict the next line using imports from the current file:
from flask import url_for, request, flash, redirect
from flask_login import current_user
from flaskext.babel import lazy_gettext as _
from flaskext.oauth import OAuth
from random import choice
from ..ext import db
from .models import User
from .views import users
and context including class names, function names, and sometimes code from other files:
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
#
# Path: makesite/modules/flask/base/auth/models.py
# class User(db.Model, UserMixin, BaseMixin):
# " Main user model. "
#
# __tablename__ = 'users_user'
#
# username = db.Column(db.String(50), unique=True)
# email = db.Column(db.String(120))
# active = db.Column(db.Boolean, default=True)
# _pw_hash = db.Column(db.String(199), nullable=False)
#
# # OAuth creds
# oauth_token = db.Column(db.String(200))
# oauth_secret = db.Column(db.String(200))
#
# @declared_attr
# def roles(self):
# assert self
# return db.relationship("Role", secondary=userroles, backref="users")
#
# @hybrid_property
# def pw_hash(self):
# """Simple getter function for the user's password."""
# return self._pw_hash
#
# @pw_hash.setter
# def pw_hash(self, raw_password):
# """ Password setter, that handles the hashing
# in the database.
# """
# self._pw_hash = generate_password_hash(raw_password)
#
# @staticmethod
# def permission(role):
# perm = Permission(RoleNeed(role))
# return perm.can()
#
# def check_password(self, password):
# return check_password_hash(self.pw_hash, password)
#
# def is_active(self):
# return self.active
#
# def __unicode__(self):
# return self.username
#
# def __repr__(self):
# return '<User %r>' % (self.username)
#
# Path: makesite/modules/flask/base/auth/views.py
# def profile():
# def login():
# def logout():
# def register():
. Output only the next line. | user.oauth_token = resp['oauth_token'] |
Continue the code snippet: <|code_start|>
ASCII_LOWERCASE = 'abcdefghijklmnopqrstuvwxyz'
PROVIDERS = 'twitter',
CLIENTS = dict()
oauth = OAuth()
def config_oauth(app):
" Configure oauth support. "
for name in PROVIDERS:
config = app.config.get('OAUTH_%s' % name.upper())
if not config:
continue
if not name in oauth.remote_apps:
remote_app = oauth.remote_app(name, **config)
else:
remote_app = oauth.remote_apps[name]
client_class = CLIENTS.get(name)
<|code_end|>
. Use current file imports:
from flask import url_for, request, flash, redirect
from flask_login import current_user
from flaskext.babel import lazy_gettext as _
from flaskext.oauth import OAuth
from random import choice
from ..ext import db
from .models import User
from .views import users
and context (classes, functions, or code) from other files:
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
#
# Path: makesite/modules/flask/base/auth/models.py
# class User(db.Model, UserMixin, BaseMixin):
# " Main user model. "
#
# __tablename__ = 'users_user'
#
# username = db.Column(db.String(50), unique=True)
# email = db.Column(db.String(120))
# active = db.Column(db.Boolean, default=True)
# _pw_hash = db.Column(db.String(199), nullable=False)
#
# # OAuth creds
# oauth_token = db.Column(db.String(200))
# oauth_secret = db.Column(db.String(200))
#
# @declared_attr
# def roles(self):
# assert self
# return db.relationship("Role", secondary=userroles, backref="users")
#
# @hybrid_property
# def pw_hash(self):
# """Simple getter function for the user's password."""
# return self._pw_hash
#
# @pw_hash.setter
# def pw_hash(self, raw_password):
# """ Password setter, that handles the hashing
# in the database.
# """
# self._pw_hash = generate_password_hash(raw_password)
#
# @staticmethod
# def permission(role):
# perm = Permission(RoleNeed(role))
# return perm.can()
#
# def check_password(self, password):
# return check_password_hash(self.pw_hash, password)
#
# def is_active(self):
# return self.active
#
# def __unicode__(self):
# return self.username
#
# def __repr__(self):
# return '<User %r>' % (self.username)
#
# Path: makesite/modules/flask/base/auth/views.py
# def profile():
# def login():
# def logout():
# def register():
. Output only the next line. | client_class(app, remote_app) |
Continue the code snippet: <|code_start|> )
@staticmethod
def run(name=None):
role = Role(name=name)
db.session.add(role)
db.session.commit()
print 'Role "%s" created successfully.' % name
manager.add_command('create_role', Create_role())
class Add_role(Command):
" Add a role to a user. "
option_list = (
Option('username'),
Option('role'),
)
@staticmethod
def run(username=None, role=None):
u = User.query.filter_by(username=username).first()
r = Role.query.filter_by(name=role).first()
if u and r:
u.roles.append(r)
db.session.add(u)
db.session.commit()
<|code_end|>
. Use current file imports:
from flaskext.script import Command, Option, prompt_pass
from ..ext import manager
from .models import User
from base.ext import db
from .models import Role
from base.ext import db
from .models import User, Role
from base.ext import db
from .models import User, Role
from base.ext import db
and context (classes, functions, or code) from other files:
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
. Output only the next line. | print "Role '%s' added to user '%s' successfully" % ( |
Given the code snippet: <|code_start|>
userroles = db.Table(
'users_userroles',
db.Column('user_id', db.Integer, db.ForeignKey('users_user.id')),
db.Column('role_id', db.Integer, db.ForeignKey('users_role.id'))
)
class Role(db.Model, BaseMixin):
" User roles. "
__tablename__ = 'users_role'
name = db.Column(db.String(19), nullable=False, unique=True)
def __unicode__(self):
<|code_end|>
, generate the next line using the imports in this file:
from flask_login import UserMixin
from flask_principal import RoleNeed, Permission
from sqlalchemy.ext.declarative import declared_attr
from sqlalchemy.ext.hybrid import hybrid_property
from werkzeug import check_password_hash, generate_password_hash
from ..core.models import BaseMixin
from ..ext import db
and context (functions, classes, or occasionally code) from other files:
# Path: makesite/modules/flask/base/core/models.py
# class BaseMixin(UpdateMixin, TimestampMixin):
# """Provieds all benefits of
# :class:`~pyramid_alchauth.models.UpdateMixin` and
# :class:`~pyramid_alchauth.models.TimestampMixin` as well as
# providing a deform compatible appstruct property and an easy way to
# query VersionedMeta. It also defines an id column to save on boring
# boilerplate.
# """
#
# id = Column(Integer, primary_key=True)
#
# @declared_attr
# def __tablename__(self):
# return self.__name__.lower()
#
# @property
# def session(self):
# return object_session(self)
#
# @property
# def _history_class(self):
# """Returns the corresponding history class if the inheriting
# class supports versioning (by checking for the existence of a
# '__history_mapper__' attribute). Otherwise, returns None.
# """
# if hasattr(self, '__history_mapper__'):
# return self.__history_mapper__.class_
# else:
# return None
#
# @property
# def history(self):
# """Returns an SQLAlchemy query of the object's history (previous
# versions). If the class does not support history/versioning,
# returns None.
# """
# history = self.history_class
# if history:
# return self.session.query(history).filter(history.id == self.id)
# else:
# return None
#
# def generate_appstruct(self):
# """Returns a Deform compatible appstruct of the object and it's
# properties. Does not recurse into SQLAlchemy relationships.
# An example using the :class:`~drinks.models.User` class (that
# inherits from BaseMixin):
#
# .. code-block:: python
#
# >>> user = User(username='mcuserpants', disabled=True)
# >>> user.appstruct
# {'disabled': True, 'username': 'mcuserpants'}
#
# """
# mapper = object_mapper(self)
# return dict([(p.key, self.__getattribute__(p.key)) for
# p in mapper.iterate_properties if
# not self.__getattribute__(p.key) is None])
#
# @property
# def appstruct(self):
# return self.generate_appstruct()
#
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
. Output only the next line. | return self.name |
Given the following code snippet before the placeholder: <|code_start|>
class Role(db.Model, BaseMixin):
" User roles. "
__tablename__ = 'users_role'
name = db.Column(db.String(19), nullable=False, unique=True)
def __unicode__(self):
return self.name
def __repr__(self):
return '<Role %r>' % (self.name)
class User(db.Model, UserMixin, BaseMixin):
" Main user model. "
__tablename__ = 'users_user'
username = db.Column(db.String(50), unique=True)
email = db.Column(db.String(120))
active = db.Column(db.Boolean, default=True)
_pw_hash = db.Column(db.String(199), nullable=False)
# OAuth creds
oauth_token = db.Column(db.String(200))
oauth_secret = db.Column(db.String(200))
@declared_attr
<|code_end|>
, predict the next line using imports from the current file:
from flask_login import UserMixin
from flask_principal import RoleNeed, Permission
from sqlalchemy.ext.declarative import declared_attr
from sqlalchemy.ext.hybrid import hybrid_property
from werkzeug import check_password_hash, generate_password_hash
from ..core.models import BaseMixin
from ..ext import db
and context including class names, function names, and sometimes code from other files:
# Path: makesite/modules/flask/base/core/models.py
# class BaseMixin(UpdateMixin, TimestampMixin):
# """Provieds all benefits of
# :class:`~pyramid_alchauth.models.UpdateMixin` and
# :class:`~pyramid_alchauth.models.TimestampMixin` as well as
# providing a deform compatible appstruct property and an easy way to
# query VersionedMeta. It also defines an id column to save on boring
# boilerplate.
# """
#
# id = Column(Integer, primary_key=True)
#
# @declared_attr
# def __tablename__(self):
# return self.__name__.lower()
#
# @property
# def session(self):
# return object_session(self)
#
# @property
# def _history_class(self):
# """Returns the corresponding history class if the inheriting
# class supports versioning (by checking for the existence of a
# '__history_mapper__' attribute). Otherwise, returns None.
# """
# if hasattr(self, '__history_mapper__'):
# return self.__history_mapper__.class_
# else:
# return None
#
# @property
# def history(self):
# """Returns an SQLAlchemy query of the object's history (previous
# versions). If the class does not support history/versioning,
# returns None.
# """
# history = self.history_class
# if history:
# return self.session.query(history).filter(history.id == self.id)
# else:
# return None
#
# def generate_appstruct(self):
# """Returns a Deform compatible appstruct of the object and it's
# properties. Does not recurse into SQLAlchemy relationships.
# An example using the :class:`~drinks.models.User` class (that
# inherits from BaseMixin):
#
# .. code-block:: python
#
# >>> user = User(username='mcuserpants', disabled=True)
# >>> user.appstruct
# {'disabled': True, 'username': 'mcuserpants'}
#
# """
# mapper = object_mapper(self)
# return dict([(p.key, self.__getattribute__(p.key)) for
# p in mapper.iterate_properties if
# not self.__getattribute__(p.key) is None])
#
# @property
# def appstruct(self):
# return self.generate_appstruct()
#
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
. Output only the next line. | def roles(self): |
Using the snippet: <|code_start|>
class BaseCoreTest(TestCase):
def create_app(self):
return create_app(test)
def setUp(self):
db.create_all()
def tearDown(self):
db.session.remove()
db.drop_all()
def test_users(self):
response = self.client.post('/users/login/', data=dict())
self.assertRedirects(response, '/')
user = User(username='test', pw_hash='test', email='test@test.com')
db.session.add(user)
db.session.commit()
response = self.client.post('/users/login/', data=dict(
<|code_end|>
, determine the next line of code. You have imports:
from flask_testing import TestCase
from ..app import create_app
from ..config import test
from ..ext import db
from base.auth.models import User
from base.auth.models import Role, User
from manage import manager
from flask import url_for
and context (class names, function names, or code) available:
# Path: makesite/modules/flask/base/app.py
# def create_app(config=None, **skip):
# app = Flask(__name__)
# app.config.from_object(config or production)
# app.config.from_envvar("APP_SETTINGS", silent=True)
#
# from .ext import config_extensions
# config_extensions(app)
#
# from .loader import loader
# loader.register(app)
#
# return app
#
# Path: makesite/modules/flask/base/config/test.py
# SQLALCHEMY_DATABASE_URI = 'sqlite:///:memory:'
# CSRF_ENABLED = False
# CACHE_TYPE = 'simple'
#
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
. Output only the next line. | email='test@test.com', |
Given the following code snippet before the placeholder: <|code_start|> return create_app(test)
def setUp(self):
db.create_all()
def tearDown(self):
db.session.remove()
db.drop_all()
def test_users(self):
response = self.client.post('/users/login/', data=dict())
self.assertRedirects(response, '/')
user = User(username='test', pw_hash='test', email='test@test.com')
db.session.add(user)
db.session.commit()
response = self.client.post('/users/login/', data=dict(
email='test@test.com',
action_save=True,
password='test'))
self.assertRedirects(response, '/users/profile/')
response = self.client.get('/users/logout/')
self.assertRedirects(response, '/')
response = self.client.post('/users/register/', data=dict(
username='test2',
email='test2@test.com',
<|code_end|>
, predict the next line using imports from the current file:
from flask_testing import TestCase
from ..app import create_app
from ..config import test
from ..ext import db
from base.auth.models import User
from base.auth.models import Role, User
from manage import manager
from flask import url_for
and context including class names, function names, and sometimes code from other files:
# Path: makesite/modules/flask/base/app.py
# def create_app(config=None, **skip):
# app = Flask(__name__)
# app.config.from_object(config or production)
# app.config.from_envvar("APP_SETTINGS", silent=True)
#
# from .ext import config_extensions
# config_extensions(app)
#
# from .loader import loader
# loader.register(app)
#
# return app
#
# Path: makesite/modules/flask/base/config/test.py
# SQLALCHEMY_DATABASE_URI = 'sqlite:///:memory:'
# CSRF_ENABLED = False
# CACHE_TYPE = 'simple'
#
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
. Output only the next line. | action_save=True, |
Predict the next line after this snippet: <|code_start|>
def create_app(config=None, **skip):
app = Flask(__name__)
app.config.from_object(config or production)
app.config.from_envvar("APP_SETTINGS", silent=True)
config_extensions(app)
<|code_end|>
using the current file's imports:
from flask import Flask
from .config import production
from .ext import config_extensions
from .loader import loader
and any relevant context from other files:
# Path: makesite/modules/flask/base/config/production.py
# SECRET_KEY = 'SecretKeyForSessionSigning'
# MAIL_SERVER = 'smtp.gmail.com'
# MAIL_PORT = 465
# MAIL_USE_SSL = True
# MAIL_USERNAME = 'username@gmail.com'
# MAIL_PASSWORD = '*********'
# DEFAULT_MAIL_SENDER = 'Admin < %s >' % MAIL_USERNAME
# COLLECT_STATIC_ROOT = op.join(op.dirname(ROOTDIR), 'static')
# ADMINS = frozenset([MAIL_USERNAME])
# OAUTH_TWITTER = dict(
# base_url='http://api.twitter.com/1/',
# request_token_url='http://api.twitter.com/oauth/request_token',
# access_token_url='http://api.twitter.com/oauth/access_token',
# authorize_url='http://api.twitter.com/oauth/authorize',
#
# # flask-base-template app
# consumer_key='ydcXz2pWyePfc3MX3nxJw',
# consumer_secret='Pt1t2PjzKu8vsX5ixbFKu5gNEAekYrbpJrlsQMIwquc'
# )
. Output only the next line. | loader.register(app) |
Based on the snippet: <|code_start|> " Create database. "
db.create_all()
# Evolution support
evolution_db.init_app(current_app)
evolution_db.create_all()
print "Database created successfuly"
@manager.command
def drop_db():
" Drop all tables. "
if prompt_bool("Are you sure? You will lose all your data!"):
db.drop_all()
# Evolution support
evolution_db.init_app(current_app)
evolution_db.drop_all()
print "Database clearing"
@manager.command
def reset_db():
" Drop and create all tables. "
<|code_end|>
, predict the immediate next line with the help of imports:
from flaskext.script import prompt_bool
from ..ext import manager
from ..ext import db
from flask import current_app
from flaskext.evolution import db as evolution_db
from ..ext import db
from flask import current_app
from flaskext.evolution import db as evolution_db
and context (classes, functions, sometimes code) from other files:
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
. Output only the next line. | drop_db() |
Predict the next line after this snippet: <|code_start|>
babel = Babel()
cache = Cache()
db = SQLAlchemy()
main = Mail()
manager = Manager(create_app)
manager.add_option("-c", "--config", dest="config", required=False)
collect = Collect()
collect.init_script(manager)
<|code_end|>
using the current file's imports:
from flask import request
from flask_sqlalchemy import SQLAlchemy
from flaskext.babel import Babel
from flaskext.cache import Cache
from flaskext.mail import Mail
from flaskext.script import Manager
from flask_collect import Collect
from .app import create_app
and any relevant context from other files:
# Path: makesite/modules/flask/base/app.py
# def create_app(config=None, **skip):
# app = Flask(__name__)
# app.config.from_object(config or production)
# app.config.from_envvar("APP_SETTINGS", silent=True)
#
# from .ext import config_extensions
# config_extensions(app)
#
# from .loader import loader
# loader.register(app)
#
# return app
. Output only the next line. | def config_extensions(app): |
Predict the next line after this snippet: <|code_start|> flash(_('Wrong email or password'), 'error-message')
return redirect(request.referrer or url_for(users._login_manager.login_view))
@users.route('/logout/', methods=['GET'])
@users.login_required
def logout():
" View function which handles a logout request. "
users.logout()
return redirect(request.referrer or url_for(users._login_manager.login_view))
@users.route('/register/', methods=['GET', 'POST'])
def register():
" Registration Form. "
form = RegisterForm(request.form)
if form.validate_on_submit():
# create an user instance not yet stored in the database
user = User(
username=form.username.data,
email=form.email.data,
pw_hash=form.password.data)
# Insert the record in our database and commit it
db.session.add(user)
db.session.commit()
users.login(user)
# flash will display a message to the user
<|code_end|>
using the current file's imports:
from flask import request, render_template, flash, redirect, url_for
from flaskext.babel import lazy_gettext as _
from ..ext import db
from .forms import RegisterForm, LoginForm
from .manager import UserManager
from .models import User
and any relevant context from other files:
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
#
# Path: makesite/modules/flask/base/auth/forms.py
# class RegisterForm(Form, EmailFormMixin, PasswordFormMixin, PasswordConfirmFormMixin):
# " The default register form. "
#
# username = TextField(_('UserName'), [Required(message=_('Required'))])
# # submit = SubmitField(_("Register"))
#
# def to_dict(self):
# return dict(email=self.email.data, password=self.password.data)
#
# class LoginForm(Form, EmailFormMixin, PasswordFormMixin):
# " The default login form. "
#
# remember = BooleanField(_("Remember Me"), default=True)
# next = HiddenField()
# submit = SubmitField(_("Login"))
#
# def __init__(self, *args, **kwargs):
# super(LoginForm, self).__init__(*args, **kwargs)
#
# if request.method == 'GET':
# self.next.data = request.args.get('next', None)
#
# Path: makesite/modules/flask/base/auth/manager.py
# class UserManager(Blueprint):
#
# def __init__(self, *args, **kwargs):
# self._login_manager = None
# self._principal = None
# self.app = None
# super(UserManager, self).__init__(*args, **kwargs)
#
# def register(self, app, *args, **kwargs):
# " Activate loginmanager and principal. "
#
# if not self._login_manager or self.app != app:
# self._login_manager = LoginManager()
# self._login_manager.user_callback = self.user_loader
# self._login_manager.setup_app(app)
# self._login_manager.login_view = 'urls.index'
# self._login_manager.login_message = u'You need to be signed in for this page.'
#
# self.app = app
#
# if not self._principal:
# self._principal = Principal(app)
# identity_loaded.connect(self.identity_loaded)
#
# super(UserManager, self).register(app, *args, **kwargs)
#
# @staticmethod
# def user_loader(pk):
# return User.query.options(db.joinedload(User.roles)).get(pk)
#
# @staticmethod
# def login_required(fn):
# return login_required(fn)
#
# def logout(self):
# identity_changed.send(self.app, identity=AnonymousIdentity())
# return logout_user()
#
# def login(self, user):
# identity_changed.send(self.app, identity=Identity(user.id))
# return login_user(user)
#
# @staticmethod
# def identity_loaded(sender, identity):
# identity.user = current_user
#
# # Add the UserNeed to the identity
# if current_user.is_authenticated():
# identity.provides.add(UserNeed(current_user.id))
#
# # Assuming the User model has a list of roles, update the
# # identity with the roles that the user provides
# for role in current_user.roles:
# identity.provides.add(RoleNeed(role.name))
#
# Path: makesite/modules/flask/base/auth/models.py
# class User(db.Model, UserMixin, BaseMixin):
# " Main user model. "
#
# __tablename__ = 'users_user'
#
# username = db.Column(db.String(50), unique=True)
# email = db.Column(db.String(120))
# active = db.Column(db.Boolean, default=True)
# _pw_hash = db.Column(db.String(199), nullable=False)
#
# # OAuth creds
# oauth_token = db.Column(db.String(200))
# oauth_secret = db.Column(db.String(200))
#
# @declared_attr
# def roles(self):
# assert self
# return db.relationship("Role", secondary=userroles, backref="users")
#
# @hybrid_property
# def pw_hash(self):
# """Simple getter function for the user's password."""
# return self._pw_hash
#
# @pw_hash.setter
# def pw_hash(self, raw_password):
# """ Password setter, that handles the hashing
# in the database.
# """
# self._pw_hash = generate_password_hash(raw_password)
#
# @staticmethod
# def permission(role):
# perm = Permission(RoleNeed(role))
# return perm.can()
#
# def check_password(self, password):
# return check_password_hash(self.pw_hash, password)
#
# def is_active(self):
# return self.active
#
# def __unicode__(self):
# return self.username
#
# def __repr__(self):
# return '<User %r>' % (self.username)
. Output only the next line. | flash(_('Thanks for registering')) |
Using the snippet: <|code_start|>
@users.route('/logout/', methods=['GET'])
@users.login_required
def logout():
" View function which handles a logout request. "
users.logout()
return redirect(request.referrer or url_for(users._login_manager.login_view))
@users.route('/register/', methods=['GET', 'POST'])
def register():
" Registration Form. "
form = RegisterForm(request.form)
if form.validate_on_submit():
# create an user instance not yet stored in the database
user = User(
username=form.username.data,
email=form.email.data,
pw_hash=form.password.data)
# Insert the record in our database and commit it
db.session.add(user)
db.session.commit()
users.login(user)
# flash will display a message to the user
flash(_('Thanks for registering'))
# redirect user to the 'home' method of the user module.
<|code_end|>
, determine the next line of code. You have imports:
from flask import request, render_template, flash, redirect, url_for
from flaskext.babel import lazy_gettext as _
from ..ext import db
from .forms import RegisterForm, LoginForm
from .manager import UserManager
from .models import User
and context (class names, function names, or code) available:
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
#
# Path: makesite/modules/flask/base/auth/forms.py
# class RegisterForm(Form, EmailFormMixin, PasswordFormMixin, PasswordConfirmFormMixin):
# " The default register form. "
#
# username = TextField(_('UserName'), [Required(message=_('Required'))])
# # submit = SubmitField(_("Register"))
#
# def to_dict(self):
# return dict(email=self.email.data, password=self.password.data)
#
# class LoginForm(Form, EmailFormMixin, PasswordFormMixin):
# " The default login form. "
#
# remember = BooleanField(_("Remember Me"), default=True)
# next = HiddenField()
# submit = SubmitField(_("Login"))
#
# def __init__(self, *args, **kwargs):
# super(LoginForm, self).__init__(*args, **kwargs)
#
# if request.method == 'GET':
# self.next.data = request.args.get('next', None)
#
# Path: makesite/modules/flask/base/auth/manager.py
# class UserManager(Blueprint):
#
# def __init__(self, *args, **kwargs):
# self._login_manager = None
# self._principal = None
# self.app = None
# super(UserManager, self).__init__(*args, **kwargs)
#
# def register(self, app, *args, **kwargs):
# " Activate loginmanager and principal. "
#
# if not self._login_manager or self.app != app:
# self._login_manager = LoginManager()
# self._login_manager.user_callback = self.user_loader
# self._login_manager.setup_app(app)
# self._login_manager.login_view = 'urls.index'
# self._login_manager.login_message = u'You need to be signed in for this page.'
#
# self.app = app
#
# if not self._principal:
# self._principal = Principal(app)
# identity_loaded.connect(self.identity_loaded)
#
# super(UserManager, self).register(app, *args, **kwargs)
#
# @staticmethod
# def user_loader(pk):
# return User.query.options(db.joinedload(User.roles)).get(pk)
#
# @staticmethod
# def login_required(fn):
# return login_required(fn)
#
# def logout(self):
# identity_changed.send(self.app, identity=AnonymousIdentity())
# return logout_user()
#
# def login(self, user):
# identity_changed.send(self.app, identity=Identity(user.id))
# return login_user(user)
#
# @staticmethod
# def identity_loaded(sender, identity):
# identity.user = current_user
#
# # Add the UserNeed to the identity
# if current_user.is_authenticated():
# identity.provides.add(UserNeed(current_user.id))
#
# # Assuming the User model has a list of roles, update the
# # identity with the roles that the user provides
# for role in current_user.roles:
# identity.provides.add(RoleNeed(role.name))
#
# Path: makesite/modules/flask/base/auth/models.py
# class User(db.Model, UserMixin, BaseMixin):
# " Main user model. "
#
# __tablename__ = 'users_user'
#
# username = db.Column(db.String(50), unique=True)
# email = db.Column(db.String(120))
# active = db.Column(db.Boolean, default=True)
# _pw_hash = db.Column(db.String(199), nullable=False)
#
# # OAuth creds
# oauth_token = db.Column(db.String(200))
# oauth_secret = db.Column(db.String(200))
#
# @declared_attr
# def roles(self):
# assert self
# return db.relationship("Role", secondary=userroles, backref="users")
#
# @hybrid_property
# def pw_hash(self):
# """Simple getter function for the user's password."""
# return self._pw_hash
#
# @pw_hash.setter
# def pw_hash(self, raw_password):
# """ Password setter, that handles the hashing
# in the database.
# """
# self._pw_hash = generate_password_hash(raw_password)
#
# @staticmethod
# def permission(role):
# perm = Permission(RoleNeed(role))
# return perm.can()
#
# def check_password(self, password):
# return check_password_hash(self.pw_hash, password)
#
# def is_active(self):
# return self.active
#
# def __unicode__(self):
# return self.username
#
# def __repr__(self):
# return '<User %r>' % (self.username)
. Output only the next line. | return redirect(url_for('users.profile')) |
Given the following code snippet before the placeholder: <|code_start|> " View function which handles an authentication request. "
form = LoginForm(request.form)
# make sure data are valid, but doesn't validate password is right
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
# we use werzeug to validate user's password
if user and user.check_password(form.password.data):
users.login(user)
flash(_('Welcome %(user)s', user=user.username))
return redirect(url_for('users.profile'))
flash(_('Wrong email or password'), 'error-message')
return redirect(request.referrer or url_for(users._login_manager.login_view))
@users.route('/logout/', methods=['GET'])
@users.login_required
def logout():
" View function which handles a logout request. "
users.logout()
return redirect(request.referrer or url_for(users._login_manager.login_view))
@users.route('/register/', methods=['GET', 'POST'])
def register():
" Registration Form. "
form = RegisterForm(request.form)
if form.validate_on_submit():
# create an user instance not yet stored in the database
user = User(
username=form.username.data,
<|code_end|>
, predict the next line using imports from the current file:
from flask import request, render_template, flash, redirect, url_for
from flaskext.babel import lazy_gettext as _
from ..ext import db
from .forms import RegisterForm, LoginForm
from .manager import UserManager
from .models import User
and context including class names, function names, and sometimes code from other files:
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
#
# Path: makesite/modules/flask/base/auth/forms.py
# class RegisterForm(Form, EmailFormMixin, PasswordFormMixin, PasswordConfirmFormMixin):
# " The default register form. "
#
# username = TextField(_('UserName'), [Required(message=_('Required'))])
# # submit = SubmitField(_("Register"))
#
# def to_dict(self):
# return dict(email=self.email.data, password=self.password.data)
#
# class LoginForm(Form, EmailFormMixin, PasswordFormMixin):
# " The default login form. "
#
# remember = BooleanField(_("Remember Me"), default=True)
# next = HiddenField()
# submit = SubmitField(_("Login"))
#
# def __init__(self, *args, **kwargs):
# super(LoginForm, self).__init__(*args, **kwargs)
#
# if request.method == 'GET':
# self.next.data = request.args.get('next', None)
#
# Path: makesite/modules/flask/base/auth/manager.py
# class UserManager(Blueprint):
#
# def __init__(self, *args, **kwargs):
# self._login_manager = None
# self._principal = None
# self.app = None
# super(UserManager, self).__init__(*args, **kwargs)
#
# def register(self, app, *args, **kwargs):
# " Activate loginmanager and principal. "
#
# if not self._login_manager or self.app != app:
# self._login_manager = LoginManager()
# self._login_manager.user_callback = self.user_loader
# self._login_manager.setup_app(app)
# self._login_manager.login_view = 'urls.index'
# self._login_manager.login_message = u'You need to be signed in for this page.'
#
# self.app = app
#
# if not self._principal:
# self._principal = Principal(app)
# identity_loaded.connect(self.identity_loaded)
#
# super(UserManager, self).register(app, *args, **kwargs)
#
# @staticmethod
# def user_loader(pk):
# return User.query.options(db.joinedload(User.roles)).get(pk)
#
# @staticmethod
# def login_required(fn):
# return login_required(fn)
#
# def logout(self):
# identity_changed.send(self.app, identity=AnonymousIdentity())
# return logout_user()
#
# def login(self, user):
# identity_changed.send(self.app, identity=Identity(user.id))
# return login_user(user)
#
# @staticmethod
# def identity_loaded(sender, identity):
# identity.user = current_user
#
# # Add the UserNeed to the identity
# if current_user.is_authenticated():
# identity.provides.add(UserNeed(current_user.id))
#
# # Assuming the User model has a list of roles, update the
# # identity with the roles that the user provides
# for role in current_user.roles:
# identity.provides.add(RoleNeed(role.name))
#
# Path: makesite/modules/flask/base/auth/models.py
# class User(db.Model, UserMixin, BaseMixin):
# " Main user model. "
#
# __tablename__ = 'users_user'
#
# username = db.Column(db.String(50), unique=True)
# email = db.Column(db.String(120))
# active = db.Column(db.Boolean, default=True)
# _pw_hash = db.Column(db.String(199), nullable=False)
#
# # OAuth creds
# oauth_token = db.Column(db.String(200))
# oauth_secret = db.Column(db.String(200))
#
# @declared_attr
# def roles(self):
# assert self
# return db.relationship("Role", secondary=userroles, backref="users")
#
# @hybrid_property
# def pw_hash(self):
# """Simple getter function for the user's password."""
# return self._pw_hash
#
# @pw_hash.setter
# def pw_hash(self, raw_password):
# """ Password setter, that handles the hashing
# in the database.
# """
# self._pw_hash = generate_password_hash(raw_password)
#
# @staticmethod
# def permission(role):
# perm = Permission(RoleNeed(role))
# return perm.can()
#
# def check_password(self, password):
# return check_password_hash(self.pw_hash, password)
#
# def is_active(self):
# return self.active
#
# def __unicode__(self):
# return self.username
#
# def __repr__(self):
# return '<User %r>' % (self.username)
. Output only the next line. | email=form.email.data, |
Using the snippet: <|code_start|>@users.login_required
def profile():
return render_template("users/profile.html")
@users.route('/login/', methods=['POST'])
def login():
" View function which handles an authentication request. "
form = LoginForm(request.form)
# make sure data are valid, but doesn't validate password is right
if form.validate_on_submit():
user = User.query.filter_by(email=form.email.data).first()
# we use werzeug to validate user's password
if user and user.check_password(form.password.data):
users.login(user)
flash(_('Welcome %(user)s', user=user.username))
return redirect(url_for('users.profile'))
flash(_('Wrong email or password'), 'error-message')
return redirect(request.referrer or url_for(users._login_manager.login_view))
@users.route('/logout/', methods=['GET'])
@users.login_required
def logout():
" View function which handles a logout request. "
users.logout()
return redirect(request.referrer or url_for(users._login_manager.login_view))
@users.route('/register/', methods=['GET', 'POST'])
<|code_end|>
, determine the next line of code. You have imports:
from flask import request, render_template, flash, redirect, url_for
from flaskext.babel import lazy_gettext as _
from ..ext import db
from .forms import RegisterForm, LoginForm
from .manager import UserManager
from .models import User
and context (class names, function names, or code) available:
# Path: makesite/modules/flask/base/ext.py
# def config_extensions(app):
# def config_babel(app):
# def get_locale():
#
# Path: makesite/modules/flask/base/auth/forms.py
# class RegisterForm(Form, EmailFormMixin, PasswordFormMixin, PasswordConfirmFormMixin):
# " The default register form. "
#
# username = TextField(_('UserName'), [Required(message=_('Required'))])
# # submit = SubmitField(_("Register"))
#
# def to_dict(self):
# return dict(email=self.email.data, password=self.password.data)
#
# class LoginForm(Form, EmailFormMixin, PasswordFormMixin):
# " The default login form. "
#
# remember = BooleanField(_("Remember Me"), default=True)
# next = HiddenField()
# submit = SubmitField(_("Login"))
#
# def __init__(self, *args, **kwargs):
# super(LoginForm, self).__init__(*args, **kwargs)
#
# if request.method == 'GET':
# self.next.data = request.args.get('next', None)
#
# Path: makesite/modules/flask/base/auth/manager.py
# class UserManager(Blueprint):
#
# def __init__(self, *args, **kwargs):
# self._login_manager = None
# self._principal = None
# self.app = None
# super(UserManager, self).__init__(*args, **kwargs)
#
# def register(self, app, *args, **kwargs):
# " Activate loginmanager and principal. "
#
# if not self._login_manager or self.app != app:
# self._login_manager = LoginManager()
# self._login_manager.user_callback = self.user_loader
# self._login_manager.setup_app(app)
# self._login_manager.login_view = 'urls.index'
# self._login_manager.login_message = u'You need to be signed in for this page.'
#
# self.app = app
#
# if not self._principal:
# self._principal = Principal(app)
# identity_loaded.connect(self.identity_loaded)
#
# super(UserManager, self).register(app, *args, **kwargs)
#
# @staticmethod
# def user_loader(pk):
# return User.query.options(db.joinedload(User.roles)).get(pk)
#
# @staticmethod
# def login_required(fn):
# return login_required(fn)
#
# def logout(self):
# identity_changed.send(self.app, identity=AnonymousIdentity())
# return logout_user()
#
# def login(self, user):
# identity_changed.send(self.app, identity=Identity(user.id))
# return login_user(user)
#
# @staticmethod
# def identity_loaded(sender, identity):
# identity.user = current_user
#
# # Add the UserNeed to the identity
# if current_user.is_authenticated():
# identity.provides.add(UserNeed(current_user.id))
#
# # Assuming the User model has a list of roles, update the
# # identity with the roles that the user provides
# for role in current_user.roles:
# identity.provides.add(RoleNeed(role.name))
#
# Path: makesite/modules/flask/base/auth/models.py
# class User(db.Model, UserMixin, BaseMixin):
# " Main user model. "
#
# __tablename__ = 'users_user'
#
# username = db.Column(db.String(50), unique=True)
# email = db.Column(db.String(120))
# active = db.Column(db.Boolean, default=True)
# _pw_hash = db.Column(db.String(199), nullable=False)
#
# # OAuth creds
# oauth_token = db.Column(db.String(200))
# oauth_secret = db.Column(db.String(200))
#
# @declared_attr
# def roles(self):
# assert self
# return db.relationship("Role", secondary=userroles, backref="users")
#
# @hybrid_property
# def pw_hash(self):
# """Simple getter function for the user's password."""
# return self._pw_hash
#
# @pw_hash.setter
# def pw_hash(self, raw_password):
# """ Password setter, that handles the hashing
# in the database.
# """
# self._pw_hash = generate_password_hash(raw_password)
#
# @staticmethod
# def permission(role):
# perm = Permission(RoleNeed(role))
# return perm.can()
#
# def check_password(self, password):
# return check_password_hash(self.pw_hash, password)
#
# def is_active(self):
# return self.active
#
# def __unicode__(self):
# return self.username
#
# def __repr__(self):
# return '<User %r>' % (self.username)
. Output only the next line. | def register(): |
Predict the next line after this snippet: <|code_start|>
class TestTextToInt:
def setup(self):
pass
@pytest.mark.parametrize("text,expected,default_base", [
("12", 0x12, "hex"),
("$1234", 0x1234, "hex"),
("0xffff", 0xffff, "hex"),
("#12", 12, "hex"),
<|code_end|>
using the current file's imports:
from builtins import object
from mock import *
from atrcopy import utils
and any relevant context from other files:
# Path: atrcopy/utils.py
# def uuid():
# def to_numpy(value):
# def to_numpy_list(value):
# def text_to_int(text, default_base="hex"):
# def __init__(self, sector_size, data=None, num=-1):
# def __str__(self):
# def sector_num(self):
# def sector_num(self, value):
# def next_sector_num(self):
# def next_sector_num(self, value):
# def space_remaining(self):
# def is_empty(self):
# def add_data(self, data):
# def __init__(self, header):
# def __len__(self):
# def __str__(self):
# def __getitem__(self, index):
# def num_sectors(self):
# def first_sector(self):
# def bytes_used(self):
# def append(self, sector):
# def extend(self, sectors):
# def __init__(self, file_num=0):
# def __eq__(self, other):
# def extra_metadata(self, image):
# def mark_deleted(self):
# def parse_raw_dirent(self, image, bytes):
# def encode_dirent(self):
# def get_sectors_in_vtoc(self, image):
# def start_read(self, image):
# def read_sector(self, image):
# def __init__(self, header, num_dirents=-1, sector_class=WriteableSector):
# def set(self, index, dirent):
# def get_free_dirent(self):
# def add_dirent(self, filename, filetype):
# def find_dirent(self, filename):
# def save_dirent(self, image, dirent, vtoc, sector_list):
# def remove_dirent(self, image, dirent, vtoc, sector_list):
# def dirent_class(self):
# def calc_sectors(self, image):
# def get_dirent_sector(self):
# def encode_empty(self):
# def encode_dirent(self, dirent):
# def store_encoded(self, data):
# def finish_encoding(self, image):
# def set_sector_numbers(self, image):
# def __init__(self, header, segments=None):
# def __str__(self):
# def num_free_sectors(self):
# def iter_free_sectors(self):
# def parse_segments(self, segments):
# def assign_sector_numbers(self, dirent, sector_list):
# def reserve_space(self, num):
# def get_next_free_sector(self):
# def calc_bitmap(self):
# def free_sector_list(self, sector_list):
# class WriteableSector:
# class BaseSectorList:
# class Dirent:
# class Directory(BaseSectorList):
# class VTOC(BaseSectorList):
. Output only the next line. | ("%11001010", 202, "hex"), |
Predict the next line after this snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 MissingConfigObjects(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
<|code_end|>
using the current file's imports:
from typing import Dict, List, Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and any relevant context from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
. Output only the next line. | pass |
Predict the next line for this snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 MultiplePluginsInModuleNum1(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
<|code_end|>
with the help of current file imports:
from typing import Dict, List, Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and context from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
, which may contain function names, class names, or code. Output only the next line. | pass |
Given snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 MultiplePluginsInModuleNum1(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
pass
class MultiplePluginsInModuleNum2(WorkerPlugin):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from typing import Dict, List, Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and context:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
which might include code, classes, or functions. Output only the next line. | async def scan( |
Using the snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 MultiplePluginsInModuleNum1(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
pass
class MultiplePluginsInModuleNum2(WorkerPlugin):
<|code_end|>
, determine the next line of code. You have imports:
from typing import Dict, List, Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and context (class names, function names, or code) available:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
. Output only the next line. | async def scan( |
Here is a snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 MultiplePluginsInModuleNum1(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
pass
class MultiplePluginsInModuleNum2(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
<|code_end|>
. Write the next line using the current file imports:
from typing import Dict, List, Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and context from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
, which may include functions, classes, or code. Output only the next line. | pass |
Given the following code snippet before the placeholder: <|code_start|>
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 SimpleDispatcher(DispatcherPlugin):
RAISE_EXCEPTION = False
RETURN_ERRORS = False
SHOULD_ARCHIVE = True
WORKERS = ['dummy_worker']
async def get_dispatches(
self, payload: Payload, request: Request
) -> Optional[DispatcherResponse]:
if self.RAISE_EXCEPTION:
raise Exception('Test exception please ignore')
dr = DispatcherResponse()
<|code_end|>
, predict the next line using imports from the current file:
from typing import Optional
from stoq.data_classes import Payload, DispatcherResponse, Request
from stoq.plugins import DispatcherPlugin
and context including class names, function names, and sometimes code from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class DispatcherResponse:
# def __init__(
# self,
# plugin_names: Optional[List[str]] = None,
# meta: Optional[Dict] = None,
# errors: Optional[List[Error]] = None,
# ) -> None:
# """
#
# Object containing response from dispatcher plugins
#
# :param plugins_names: Plugins to send payload to for scanning
# :param meta: Metadata pertaining to dispatching results
# :param errors: Errors that occurred
#
# >>> from stoq import DispatcherResponse
# >>> plugins = ['yara', 'exif']
# >>> meta = {'hit': 'exe_file'}
# >>> dispatcher = DispatcherResponse(plugin_names=plugins, meta=meta)
#
# """
# self.plugin_names = [] if plugin_names is None else plugin_names
# self.meta = {} if meta is None else meta
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/dispatcher.py
# class DispatcherPlugin(BasePlugin, ABC):
# @abstractmethod
# async def get_dispatches(
# self, payload: Payload, request: Request
# ) -> Optional[DispatcherResponse]:
# pass
. Output only the next line. | if self.RETURN_ERRORS: |
Continue the code snippet: <|code_start|>#
# 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 SimpleDispatcher(DispatcherPlugin):
RAISE_EXCEPTION = False
RETURN_ERRORS = False
SHOULD_ARCHIVE = True
WORKERS = ['dummy_worker']
async def get_dispatches(
self, payload: Payload, request: Request
) -> Optional[DispatcherResponse]:
if self.RAISE_EXCEPTION:
raise Exception('Test exception please ignore')
dr = DispatcherResponse()
if self.RETURN_ERRORS:
dr.errors.append('Test error please ignore')
<|code_end|>
. Use current file imports:
from typing import Optional
from stoq.data_classes import Payload, DispatcherResponse, Request
from stoq.plugins import DispatcherPlugin
and context (classes, functions, or code) from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class DispatcherResponse:
# def __init__(
# self,
# plugin_names: Optional[List[str]] = None,
# meta: Optional[Dict] = None,
# errors: Optional[List[Error]] = None,
# ) -> None:
# """
#
# Object containing response from dispatcher plugins
#
# :param plugins_names: Plugins to send payload to for scanning
# :param meta: Metadata pertaining to dispatching results
# :param errors: Errors that occurred
#
# >>> from stoq import DispatcherResponse
# >>> plugins = ['yara', 'exif']
# >>> meta = {'hit': 'exe_file'}
# >>> dispatcher = DispatcherResponse(plugin_names=plugins, meta=meta)
#
# """
# self.plugin_names = [] if plugin_names is None else plugin_names
# self.meta = {} if meta is None else meta
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/dispatcher.py
# class DispatcherPlugin(BasePlugin, ABC):
# @abstractmethod
# async def get_dispatches(
# self, payload: Payload, request: Request
# ) -> Optional[DispatcherResponse]:
# pass
. Output only the next line. | dr.plugin_names.extend(self.WORKERS) |
Next line prediction: <|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 SimpleDispatcher(DispatcherPlugin):
RAISE_EXCEPTION = False
RETURN_ERRORS = False
SHOULD_ARCHIVE = True
WORKERS = ['dummy_worker']
async def get_dispatches(
self, payload: Payload, request: Request
) -> Optional[DispatcherResponse]:
if self.RAISE_EXCEPTION:
raise Exception('Test exception please ignore')
dr = DispatcherResponse()
if self.RETURN_ERRORS:
dr.errors.append('Test error please ignore')
dr.plugin_names.extend(self.WORKERS)
dr.meta['test_key'] = 'Useful metadata info'
payload.results.payload_meta.should_archive = self.SHOULD_ARCHIVE
<|code_end|>
. Use current file imports:
(from typing import Optional
from stoq.data_classes import Payload, DispatcherResponse, Request
from stoq.plugins import DispatcherPlugin)
and context including class names, function names, or small code snippets from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class DispatcherResponse:
# def __init__(
# self,
# plugin_names: Optional[List[str]] = None,
# meta: Optional[Dict] = None,
# errors: Optional[List[Error]] = None,
# ) -> None:
# """
#
# Object containing response from dispatcher plugins
#
# :param plugins_names: Plugins to send payload to for scanning
# :param meta: Metadata pertaining to dispatching results
# :param errors: Errors that occurred
#
# >>> from stoq import DispatcherResponse
# >>> plugins = ['yara', 'exif']
# >>> meta = {'hit': 'exe_file'}
# >>> dispatcher = DispatcherResponse(plugin_names=plugins, meta=meta)
#
# """
# self.plugin_names = [] if plugin_names is None else plugin_names
# self.meta = {} if meta is None else meta
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/dispatcher.py
# class DispatcherPlugin(BasePlugin, ABC):
# @abstractmethod
# async def get_dispatches(
# self, payload: Payload, request: Request
# ) -> Optional[DispatcherResponse]:
# pass
. Output only the next line. | return dr |
Next line prediction: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 SimpleDispatcher(DispatcherPlugin):
RAISE_EXCEPTION = False
RETURN_ERRORS = False
<|code_end|>
. Use current file imports:
(from typing import Optional
from stoq.data_classes import Payload, DispatcherResponse, Request
from stoq.plugins import DispatcherPlugin)
and context including class names, function names, or small code snippets from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class DispatcherResponse:
# def __init__(
# self,
# plugin_names: Optional[List[str]] = None,
# meta: Optional[Dict] = None,
# errors: Optional[List[Error]] = None,
# ) -> None:
# """
#
# Object containing response from dispatcher plugins
#
# :param plugins_names: Plugins to send payload to for scanning
# :param meta: Metadata pertaining to dispatching results
# :param errors: Errors that occurred
#
# >>> from stoq import DispatcherResponse
# >>> plugins = ['yara', 'exif']
# >>> meta = {'hit': 'exe_file'}
# >>> dispatcher = DispatcherResponse(plugin_names=plugins, meta=meta)
#
# """
# self.plugin_names = [] if plugin_names is None else plugin_names
# self.meta = {} if meta is None else meta
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/dispatcher.py
# class DispatcherPlugin(BasePlugin, ABC):
# @abstractmethod
# async def get_dispatches(
# self, payload: Payload, request: Request
# ) -> Optional[DispatcherResponse]:
# pass
. Output only the next line. | SHOULD_ARCHIVE = True |
Predict the next line for this snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 InvalidConfig(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
<|code_end|>
with the help of current file imports:
from typing import Dict, List, Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and context from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
, which may contain function names, class names, or code. Output only the next line. | pass |
Given snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 InvalidConfig(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from typing import Dict, List, Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and context:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
which might include code, classes, or functions. Output only the next line. | pass |
Continue the code snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 SimpleDecorator(DecoratorPlugin):
RAISE_EXCEPTION = False
RETURN_ERRORS = False
async def decorate(self, response: StoqResponse) -> Optional[DecoratorResponse]:
<|code_end|>
. Use current file imports:
from typing import Optional
from stoq.data_classes import StoqResponse, DecoratorResponse, Error
from stoq.plugins import DecoratorPlugin
and context (classes, functions, or code) from other files:
# Path: stoq/data_classes.py
# class StoqResponse:
# def __init__(
# self,
# request: Request,
# time: Optional[str] = None,
# decorators: Optional[Dict[str, Dict]] = None,
# scan_id: Optional[str] = None,
# ) -> None:
# """
#
# Response object of a completed scan
#
# :param results: ``PayloadResults`` object of scanned payload
# :param request_meta: ``RequetMeta`` object pertaining to original scan request
# :param time: ISO Formatted timestamp of scan
# :param decorators: Decorator plugin results
#
# """
# self.results = [p.results for p in request.payloads]
# self.request_meta = request.request_meta
# self.errors = request.errors
# self.time: str = datetime.now().isoformat() if time is None else time
# self.decorators = {} if decorators is None else decorators
# self.scan_id = str(uuid.uuid4()) if scan_id is None else scan_id
#
# def split(self) -> List[Dict]:
# """
# Split worker results individually
#
# """
# split_results = []
# for result in self.results:
# for k, v in result.workers.items():
# rcopy = deepcopy(self.__dict__)
# rcopy['results'] = [deepcopy(result.__dict__)]
# rcopy['results'][0]['workers'] = {k: v}
# split_results.append(rcopy)
# return split_results
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class DecoratorResponse:
# def __init__(
# self, results: Optional[Dict] = None, errors: Optional[List[Error]] = None
# ) -> None:
# """
#
# Object containing response from decorator plugins
#
# :param results: Results from decorator plugin
# :param errors: Errors that occurred
#
# >>> from stoq import DecoratorResponse
# >>> results = {'decorator_key': 'decorator_value'}
# >>> errors = ['This plugin failed for a reason']
# >>> response = DecoratorResponse(results=results, errors=errors)
#
# """
# self.results = results
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Error:
# def __init__(
# self,
# error: str,
# plugin_name: Optional[str] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object for errors collected from plugins
#
# :param error: Error message to add to results
# :param plugin_name: The name of the plugin producing the error
# :param payload_id: The ``payload_id`` of the ``Payload`` that the error occurred on
#
# >>> from stoq import Error, Payload
# >>> errors: List[Error] = []
# >>> payload = Payload(b'test bytes')
# >>> err = Error(
# ... error='This is our error message',
# ... plugin_name='test_plugin',
# ... payload_id=payload.results.payload_id
# ... )
# >>> errors.append(err)
#
# """
# self.error = error
# self.plugin_name = plugin_name
# self.payload_id = payload_id
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/decorator.py
# class DecoratorPlugin(BasePlugin, ABC):
# @abstractmethod
# async def decorate(self, response: StoqResponse) -> Optional[DecoratorResponse]:
# pass
. Output only the next line. | if self.RAISE_EXCEPTION: |
Given the following code snippet before the placeholder: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 SimpleDecorator(DecoratorPlugin):
RAISE_EXCEPTION = False
RETURN_ERRORS = False
async def decorate(self, response: StoqResponse) -> Optional[DecoratorResponse]:
if self.RAISE_EXCEPTION:
raise Exception('Test exception please ignore')
dr = DecoratorResponse({'simple_decoration': 123})
if self.RETURN_ERRORS:
<|code_end|>
, predict the next line using imports from the current file:
from typing import Optional
from stoq.data_classes import StoqResponse, DecoratorResponse, Error
from stoq.plugins import DecoratorPlugin
and context including class names, function names, and sometimes code from other files:
# Path: stoq/data_classes.py
# class StoqResponse:
# def __init__(
# self,
# request: Request,
# time: Optional[str] = None,
# decorators: Optional[Dict[str, Dict]] = None,
# scan_id: Optional[str] = None,
# ) -> None:
# """
#
# Response object of a completed scan
#
# :param results: ``PayloadResults`` object of scanned payload
# :param request_meta: ``RequetMeta`` object pertaining to original scan request
# :param time: ISO Formatted timestamp of scan
# :param decorators: Decorator plugin results
#
# """
# self.results = [p.results for p in request.payloads]
# self.request_meta = request.request_meta
# self.errors = request.errors
# self.time: str = datetime.now().isoformat() if time is None else time
# self.decorators = {} if decorators is None else decorators
# self.scan_id = str(uuid.uuid4()) if scan_id is None else scan_id
#
# def split(self) -> List[Dict]:
# """
# Split worker results individually
#
# """
# split_results = []
# for result in self.results:
# for k, v in result.workers.items():
# rcopy = deepcopy(self.__dict__)
# rcopy['results'] = [deepcopy(result.__dict__)]
# rcopy['results'][0]['workers'] = {k: v}
# split_results.append(rcopy)
# return split_results
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class DecoratorResponse:
# def __init__(
# self, results: Optional[Dict] = None, errors: Optional[List[Error]] = None
# ) -> None:
# """
#
# Object containing response from decorator plugins
#
# :param results: Results from decorator plugin
# :param errors: Errors that occurred
#
# >>> from stoq import DecoratorResponse
# >>> results = {'decorator_key': 'decorator_value'}
# >>> errors = ['This plugin failed for a reason']
# >>> response = DecoratorResponse(results=results, errors=errors)
#
# """
# self.results = results
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Error:
# def __init__(
# self,
# error: str,
# plugin_name: Optional[str] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object for errors collected from plugins
#
# :param error: Error message to add to results
# :param plugin_name: The name of the plugin producing the error
# :param payload_id: The ``payload_id`` of the ``Payload`` that the error occurred on
#
# >>> from stoq import Error, Payload
# >>> errors: List[Error] = []
# >>> payload = Payload(b'test bytes')
# >>> err = Error(
# ... error='This is our error message',
# ... plugin_name='test_plugin',
# ... payload_id=payload.results.payload_id
# ... )
# >>> errors.append(err)
#
# """
# self.error = error
# self.plugin_name = plugin_name
# self.payload_id = payload_id
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/decorator.py
# class DecoratorPlugin(BasePlugin, ABC):
# @abstractmethod
# async def decorate(self, response: StoqResponse) -> Optional[DecoratorResponse]:
# pass
. Output only the next line. | dr.errors.append( |
Here is a snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 IncompatibleMinStoqVersion(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
<|code_end|>
. Write the next line using the current file imports:
from typing import Dict, List, Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and context from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
, which may include functions, classes, or code. Output only the next line. | pass |
Continue the code snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 IncompatibleMinStoqVersion(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
<|code_end|>
. Use current file imports:
from typing import Dict, List, Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and context (classes, functions, or code) from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
. Output only the next line. | pass |
Given snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 IncompatibleMinStoqVersion(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from typing import Dict, List, Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and context:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
which might include code, classes, or functions. Output only the next line. | pass |
Based on the snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 IncompatibleMinStoqVersion(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
<|code_end|>
, predict the immediate next line with the help of imports:
from typing import Dict, List, Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and context (classes, functions, sometimes code) from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
. Output only the next line. | pass |
Predict the next line for this snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 ConfigurableWorker(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
pass
<|code_end|>
with the help of current file imports:
from typing import Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and context from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
, which may contain function names, class names, or code. Output only the next line. | def get_important_option(self): |
Given the code snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 ConfigurableWorker(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
<|code_end|>
, generate the next line using the imports in this file:
from typing import Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and context (functions, classes, or occasionally code) from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
. Output only the next line. | pass |
Predict the next line for this snippet: <|code_start|>
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 ConfigurableWorker(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
pass
def get_important_option(self):
return self.config.get('options', 'important_option')
def get_crazy_runtime_option(self):
return self.config.getint('options', 'crazy_runtime_option')
<|code_end|>
with the help of current file imports:
from typing import Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and context from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
, which may contain function names, class names, or code. Output only the next line. | def getjson_option(self, option): |
Continue the code snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 ConfigurableWorker(WorkerPlugin):
async def scan(
self, payload: Payload, request: Request
) -> Optional[WorkerResponse]:
pass
def get_important_option(self):
<|code_end|>
. Use current file imports:
from typing import Optional
from stoq.data_classes import Payload, Request, WorkerResponse
from stoq.plugins import WorkerPlugin
and context (classes, functions, or code) from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class WorkerResponse:
# def __init__(
# self,
# results: Optional[Dict] = None,
# extracted: Optional[List[ExtractedPayload]] = None,
# errors: Optional[List[Error]] = None,
# dispatch_to: Optional[List[str]] = None,
# ) -> None:
# """
#
# Object containing response from worker plugins
#
# :param results: Results from worker scan
# :param extracted: ``ExtractedPayload`` objects of extracted payloads from scan
# :param errors: Errors that occurred
#
# >>> from stoq import WorkerResponse, ExtractedPayload
# >>> results = {'is_bad': True, 'filetype': 'executable'}
# >>> extracted_payload = [ExtractedPayload(content=data, payload_meta=extracted_meta)]
# >>> response = WorkerResponse(results=results, extracted=extracted_payload)
#
# """
# self.results = results
# self.extracted = extracted or []
# self.errors = errors or []
# self.dispatch_to = dispatch_to or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
. Output only the next line. | return self.config.get('options', 'important_option') |
Next line prediction: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 DummyDispatcher(DispatcherPlugin):
async def get_dispatches(
self, payload: Payload, request: Request
) -> Optional[DispatcherResponse]:
<|code_end|>
. Use current file imports:
(from typing import Optional
from stoq.data_classes import Payload, Request, DispatcherResponse
from stoq.plugins import DispatcherPlugin)
and context including class names, function names, or small code snippets from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class DispatcherResponse:
# def __init__(
# self,
# plugin_names: Optional[List[str]] = None,
# meta: Optional[Dict] = None,
# errors: Optional[List[Error]] = None,
# ) -> None:
# """
#
# Object containing response from dispatcher plugins
#
# :param plugins_names: Plugins to send payload to for scanning
# :param meta: Metadata pertaining to dispatching results
# :param errors: Errors that occurred
#
# >>> from stoq import DispatcherResponse
# >>> plugins = ['yara', 'exif']
# >>> meta = {'hit': 'exe_file'}
# >>> dispatcher = DispatcherResponse(plugin_names=plugins, meta=meta)
#
# """
# self.plugin_names = [] if plugin_names is None else plugin_names
# self.meta = {} if meta is None else meta
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/dispatcher.py
# class DispatcherPlugin(BasePlugin, ABC):
# @abstractmethod
# async def get_dispatches(
# self, payload: Payload, request: Request
# ) -> Optional[DispatcherResponse]:
# pass
. Output only the next line. | return None |
Here is a snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 DummyDispatcher(DispatcherPlugin):
async def get_dispatches(
self, payload: Payload, request: Request
) -> Optional[DispatcherResponse]:
<|code_end|>
. Write the next line using the current file imports:
from typing import Optional
from stoq.data_classes import Payload, Request, DispatcherResponse
from stoq.plugins import DispatcherPlugin
and context from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class DispatcherResponse:
# def __init__(
# self,
# plugin_names: Optional[List[str]] = None,
# meta: Optional[Dict] = None,
# errors: Optional[List[Error]] = None,
# ) -> None:
# """
#
# Object containing response from dispatcher plugins
#
# :param plugins_names: Plugins to send payload to for scanning
# :param meta: Metadata pertaining to dispatching results
# :param errors: Errors that occurred
#
# >>> from stoq import DispatcherResponse
# >>> plugins = ['yara', 'exif']
# >>> meta = {'hit': 'exe_file'}
# >>> dispatcher = DispatcherResponse(plugin_names=plugins, meta=meta)
#
# """
# self.plugin_names = [] if plugin_names is None else plugin_names
# self.meta = {} if meta is None else meta
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/dispatcher.py
# class DispatcherPlugin(BasePlugin, ABC):
# @abstractmethod
# async def get_dispatches(
# self, payload: Payload, request: Request
# ) -> Optional[DispatcherResponse]:
# pass
, which may include functions, classes, or code. Output only the next line. | return None |
Continue the code snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 DummyDispatcher(DispatcherPlugin):
async def get_dispatches(
self, payload: Payload, request: Request
) -> Optional[DispatcherResponse]:
<|code_end|>
. Use current file imports:
from typing import Optional
from stoq.data_classes import Payload, Request, DispatcherResponse
from stoq.plugins import DispatcherPlugin
and context (classes, functions, or code) from other files:
# Path: stoq/data_classes.py
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class DispatcherResponse:
# def __init__(
# self,
# plugin_names: Optional[List[str]] = None,
# meta: Optional[Dict] = None,
# errors: Optional[List[Error]] = None,
# ) -> None:
# """
#
# Object containing response from dispatcher plugins
#
# :param plugins_names: Plugins to send payload to for scanning
# :param meta: Metadata pertaining to dispatching results
# :param errors: Errors that occurred
#
# >>> from stoq import DispatcherResponse
# >>> plugins = ['yara', 'exif']
# >>> meta = {'hit': 'exe_file'}
# >>> dispatcher = DispatcherResponse(plugin_names=plugins, meta=meta)
#
# """
# self.plugin_names = [] if plugin_names is None else plugin_names
# self.meta = {} if meta is None else meta
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/plugins/dispatcher.py
# class DispatcherPlugin(BasePlugin, ABC):
# @abstractmethod
# async def get_dispatches(
# self, payload: Payload, request: Request
# ) -> Optional[DispatcherResponse]:
# pass
. Output only the next line. | return None |
Given the code snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 DummyArchiver(ArchiverPlugin):
async def archive(
self, payload: Payload, request: Request
) -> Optional[ArchiverResponse]:
return None
async def get(self, task: ArchiverResponse) -> Optional[Payload]:
<|code_end|>
, generate the next line using the imports in this file:
from typing import Optional
from stoq.plugins import ArchiverPlugin
from stoq.data_classes import ArchiverResponse, Payload, Request
and context (functions, classes, or occasionally code) from other files:
# Path: stoq/plugins/archiver.py
# class ArchiverPlugin(BasePlugin):
# async def archive(
# self, payload: Payload, request: Request
# ) -> Optional[ArchiverResponse]:
# """
# Archive payload
#
# :param payload: Payload object to archive
# :param request: Originating Request object
#
# :return: ArchiverResponse object. Results are used to retrieve payload.
#
# >>> import asyncio
# >>> from stoq import Stoq, Payload
# >>> payload = Payload(b'this is going to be saved')
# >>> s = Stoq()
# >>> loop = asyncio.get_event_loop()
# >>> archiver = s.load_plugin('filedir')
# >>> loop.run_until_complete(archiver.archive(payload))
# ... {'path': '/tmp/bad.exe'}
#
# """
# pass
#
# async def get(self, task: ArchiverResponse) -> Optional[Payload]:
# """
# Retrieve payload for processing
#
# :param task: Task to be processed to load payload. Must contain `ArchiverResponse`
# results from `ArchiverPlugin.archive()`
#
# :return: Payload object for scanning
#
# >>> import asyncio
# >>> from stoq import Stoq, ArchiverResponse
# >>> s = Stoq()
# >>> loop = asyncio.get_event_loop()
# >>> archiver = s.load_plugin('filedir')
# >>> task = ArchiverResponse(results={'path': '/tmp/bad.exe'})
# >>> payload = loop.run_until_complete(archiver.get(task))
#
# """
# pass
#
# Path: stoq/data_classes.py
# class ArchiverResponse:
# def __init__(
# self, results: Optional[Dict] = None, errors: Optional[List[Error]] = None
# ) -> None:
# """
#
# Object containing response from archiver destination plugins
#
# :param results: Results from archiver plugin
# :param errors: Errors that occurred
#
# >>> from stoq import ArchiverResponse
# >>> results = {'file_id': '12345'}
# >>> archiver_response = ArchiverResponse(results=results)
#
# """
# self.results = results
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
. Output only the next line. | return None |
Using the snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 DummyArchiver(ArchiverPlugin):
async def archive(
self, payload: Payload, request: Request
) -> Optional[ArchiverResponse]:
return None
async def get(self, task: ArchiverResponse) -> Optional[Payload]:
<|code_end|>
, determine the next line of code. You have imports:
from typing import Optional
from stoq.plugins import ArchiverPlugin
from stoq.data_classes import ArchiverResponse, Payload, Request
and context (class names, function names, or code) available:
# Path: stoq/plugins/archiver.py
# class ArchiverPlugin(BasePlugin):
# async def archive(
# self, payload: Payload, request: Request
# ) -> Optional[ArchiverResponse]:
# """
# Archive payload
#
# :param payload: Payload object to archive
# :param request: Originating Request object
#
# :return: ArchiverResponse object. Results are used to retrieve payload.
#
# >>> import asyncio
# >>> from stoq import Stoq, Payload
# >>> payload = Payload(b'this is going to be saved')
# >>> s = Stoq()
# >>> loop = asyncio.get_event_loop()
# >>> archiver = s.load_plugin('filedir')
# >>> loop.run_until_complete(archiver.archive(payload))
# ... {'path': '/tmp/bad.exe'}
#
# """
# pass
#
# async def get(self, task: ArchiverResponse) -> Optional[Payload]:
# """
# Retrieve payload for processing
#
# :param task: Task to be processed to load payload. Must contain `ArchiverResponse`
# results from `ArchiverPlugin.archive()`
#
# :return: Payload object for scanning
#
# >>> import asyncio
# >>> from stoq import Stoq, ArchiverResponse
# >>> s = Stoq()
# >>> loop = asyncio.get_event_loop()
# >>> archiver = s.load_plugin('filedir')
# >>> task = ArchiverResponse(results={'path': '/tmp/bad.exe'})
# >>> payload = loop.run_until_complete(archiver.get(task))
#
# """
# pass
#
# Path: stoq/data_classes.py
# class ArchiverResponse:
# def __init__(
# self, results: Optional[Dict] = None, errors: Optional[List[Error]] = None
# ) -> None:
# """
#
# Object containing response from archiver destination plugins
#
# :param results: Results from archiver plugin
# :param errors: Errors that occurred
#
# >>> from stoq import ArchiverResponse
# >>> results = {'file_id': '12345'}
# >>> archiver_response = ArchiverResponse(results=results)
#
# """
# self.results = results
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
. Output only the next line. | return None |
Predict the next line after this snippet: <|code_start|>#!/usr/bin/env python3
# Copyright 2014-2018 PUNCH Cyber Analytics Group
#
# 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 DummyArchiver(ArchiverPlugin):
async def archive(
self, payload: Payload, request: Request
) -> Optional[ArchiverResponse]:
return None
async def get(self, task: ArchiverResponse) -> Optional[Payload]:
<|code_end|>
using the current file's imports:
from typing import Optional
from stoq.plugins import ArchiverPlugin
from stoq.data_classes import ArchiverResponse, Payload, Request
and any relevant context from other files:
# Path: stoq/plugins/archiver.py
# class ArchiverPlugin(BasePlugin):
# async def archive(
# self, payload: Payload, request: Request
# ) -> Optional[ArchiverResponse]:
# """
# Archive payload
#
# :param payload: Payload object to archive
# :param request: Originating Request object
#
# :return: ArchiverResponse object. Results are used to retrieve payload.
#
# >>> import asyncio
# >>> from stoq import Stoq, Payload
# >>> payload = Payload(b'this is going to be saved')
# >>> s = Stoq()
# >>> loop = asyncio.get_event_loop()
# >>> archiver = s.load_plugin('filedir')
# >>> loop.run_until_complete(archiver.archive(payload))
# ... {'path': '/tmp/bad.exe'}
#
# """
# pass
#
# async def get(self, task: ArchiverResponse) -> Optional[Payload]:
# """
# Retrieve payload for processing
#
# :param task: Task to be processed to load payload. Must contain `ArchiverResponse`
# results from `ArchiverPlugin.archive()`
#
# :return: Payload object for scanning
#
# >>> import asyncio
# >>> from stoq import Stoq, ArchiverResponse
# >>> s = Stoq()
# >>> loop = asyncio.get_event_loop()
# >>> archiver = s.load_plugin('filedir')
# >>> task = ArchiverResponse(results={'path': '/tmp/bad.exe'})
# >>> payload = loop.run_until_complete(archiver.get(task))
#
# """
# pass
#
# Path: stoq/data_classes.py
# class ArchiverResponse:
# def __init__(
# self, results: Optional[Dict] = None, errors: Optional[List[Error]] = None
# ) -> None:
# """
#
# Object containing response from archiver destination plugins
#
# :param results: Results from archiver plugin
# :param errors: Errors that occurred
#
# >>> from stoq import ArchiverResponse
# >>> results = {'file_id': '12345'}
# >>> archiver_response = ArchiverResponse(results=results)
#
# """
# self.results = results
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Payload:
# def __init__(
# self,
# content: Union[bytes, str],
# payload_meta: Optional[PayloadMeta] = None,
# extracted_by: Optional[Union[str, List[str]]] = None,
# extracted_from: Optional[Union[str, List[str]]] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object to store payload and related information
#
# :param content: Raw bytes to be scanned
# :param payload_meta: Metadata pertaining to originating source
# :param extracted_by: Name of plugin that extracted the payload
# :param extracted_from: Unique payload ID the payload was extracted from
# :param payload_id: Unique ID of payload
#
# >>> from stoq import PayloadMeta, Payload
# >>> content = b'This is a raw payload'
# >>> payload_meta = PayloadMeta(should_archive=True)
# >>> payload = Payload(content, payload_meta=payload_meta)
#
# """
# self.content = content if isinstance(content, bytes) else content.encode()
# self.dispatch_meta: Dict[str, Dict] = {}
# self.results = PayloadResults(
# payload_id=payload_id,
# size=len(content),
# payload_meta=payload_meta,
# extracted_from=extracted_from,
# extracted_by=extracted_by,
# )
#
# def __repr__(self):
# return repr(self.__dict__)
#
# class Request:
# def __init__(
# self,
# payloads: Optional[List[Payload]] = None,
# request_meta: Optional[RequestMeta] = None,
# errors: Optional[List[Error]] = None,
# ):
# """
#
# Object that contains the state of a ``Stoq`` scan. This object is accessible within
# all archiver, dispatcher, and worker plugins.
#
# :param payloads: All payloads that are being processed, to include extracted payloads
# :param request_meta: Original ``RequestMeta`` object
# :param errors: All errors that have been generated by plugins or ``Stoq``
#
# """
#
# self.payloads = payloads or []
# self.request_meta = request_meta or RequestMeta()
# self.errors = errors or []
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
. Output only the next line. | return None |
Given the following code snippet before the placeholder: <|code_start|> self._loaded_plugins[plugin_name] = plugin
return plugin
def list_plugins(self) -> Dict[str, Dict[str, Any]]:
valid_classes = [
'ArchiverPlugin',
'BasePlugin',
'ProviderPlugin',
'WorkerPlugin',
'ConnectorPlugin',
'DispatcherPlugin',
'DecoratorPlugin',
]
plugins = {}
for plugin in self._plugin_name_to_info.keys():
plugin_classes = []
try:
with open(self._plugin_name_to_info[plugin][0]) as f:
parsed_plugin = ast.parse(f.read())
classes = [n for n in parsed_plugin.body if isinstance(n, ast.ClassDef)]
for c in classes:
for base in c.bases:
if base.id in valid_classes: # type: ignore
plugin_classes.append(
base.id.replace('Plugin', '') # type: ignore
)
except (UnicodeDecodeError, ValueError):
plugin_classes = ['UNKNOWN']
plugins[plugin] = {
<|code_end|>
, predict the next line using imports from the current file:
import os
import inspect
import logging
import configparser
import importlib.util
import stoq.helpers as helpers
import ast
from pkg_resources import parse_version
from typing import Dict, List, Optional, Tuple, Any, Union
from stoq.data_classes import Error
from .exceptions import StoqException, StoqPluginNotFound
from stoq.plugins import (
ArchiverPlugin,
BasePlugin,
ProviderPlugin,
WorkerPlugin,
ConnectorPlugin,
DispatcherPlugin,
DecoratorPlugin,
)
from stoq import __version__
and context including class names, function names, and sometimes code from other files:
# Path: stoq/data_classes.py
# class Error:
# def __init__(
# self,
# error: str,
# plugin_name: Optional[str] = None,
# payload_id: Optional[str] = None,
# ) -> None:
# """
#
# Object for errors collected from plugins
#
# :param error: Error message to add to results
# :param plugin_name: The name of the plugin producing the error
# :param payload_id: The ``payload_id`` of the ``Payload`` that the error occurred on
#
# >>> from stoq import Error, Payload
# >>> errors: List[Error] = []
# >>> payload = Payload(b'test bytes')
# >>> err = Error(
# ... error='This is our error message',
# ... plugin_name='test_plugin',
# ... payload_id=payload.results.payload_id
# ... )
# >>> errors.append(err)
#
# """
# self.error = error
# self.plugin_name = plugin_name
# self.payload_id = payload_id
#
# def __str__(self) -> str:
# return helpers.dumps(self)
#
# def __repr__(self):
# return repr(self.__dict__)
#
# Path: stoq/exceptions.py
# class StoqException(Exception):
# pass
#
# class StoqPluginNotFound(Exception):
# pass
#
# Path: stoq/plugins/base.py
# class BasePlugin(ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# self.config = config
# self.plugin_name = config.get('Core', 'Name', fallback=self.__class__.__name__)
# self.__author__ = config.get('Documentation', 'Author', fallback='')
# self.__version__ = config.get('Documentation', 'Version', fallback='')
# self.__website__ = config.get('Documentation', 'Website', fallback='')
# self.__description__ = config.get('Documentation', 'Description', fallback='')
# self.log = logging.getLogger(f'stoq.{self.plugin_name}')
#
# Path: stoq/plugins/archiver.py
# class ArchiverPlugin(BasePlugin):
# async def archive(
# self, payload: Payload, request: Request
# ) -> Optional[ArchiverResponse]:
# """
# Archive payload
#
# :param payload: Payload object to archive
# :param request: Originating Request object
#
# :return: ArchiverResponse object. Results are used to retrieve payload.
#
# >>> import asyncio
# >>> from stoq import Stoq, Payload
# >>> payload = Payload(b'this is going to be saved')
# >>> s = Stoq()
# >>> loop = asyncio.get_event_loop()
# >>> archiver = s.load_plugin('filedir')
# >>> loop.run_until_complete(archiver.archive(payload))
# ... {'path': '/tmp/bad.exe'}
#
# """
# pass
#
# async def get(self, task: ArchiverResponse) -> Optional[Payload]:
# """
# Retrieve payload for processing
#
# :param task: Task to be processed to load payload. Must contain `ArchiverResponse`
# results from `ArchiverPlugin.archive()`
#
# :return: Payload object for scanning
#
# >>> import asyncio
# >>> from stoq import Stoq, ArchiverResponse
# >>> s = Stoq()
# >>> loop = asyncio.get_event_loop()
# >>> archiver = s.load_plugin('filedir')
# >>> task = ArchiverResponse(results={'path': '/tmp/bad.exe'})
# >>> payload = loop.run_until_complete(archiver.get(task))
#
# """
# pass
#
# Path: stoq/plugins/connector.py
# class ConnectorPlugin(BasePlugin, ABC):
# @abstractmethod
# async def save(self, response: StoqResponse) -> None:
# pass
#
# Path: stoq/plugins/provider.py
# class ProviderPlugin(BasePlugin, ABC):
# @abstractmethod
# async def ingest(self, queue: Queue) -> None:
# pass
#
# Path: stoq/plugins/worker.py
# class WorkerPlugin(BasePlugin, ABC):
# def __init__(self, config: StoqConfigParser) -> None:
# super().__init__(config)
# self.required_workers = config.getset(
# 'options', 'required_workers', fallback=set()
# )
#
# @abstractmethod
# async def scan(
# self, payload: Payload, request: Request
# ) -> Optional[WorkerResponse]:
# pass
#
# Path: stoq/plugins/dispatcher.py
# class DispatcherPlugin(BasePlugin, ABC):
# @abstractmethod
# async def get_dispatches(
# self, payload: Payload, request: Request
# ) -> Optional[DispatcherResponse]:
# pass
#
# Path: stoq/plugins/decorator.py
# class DecoratorPlugin(BasePlugin, ABC):
# @abstractmethod
# async def decorate(self, response: StoqResponse) -> Optional[DecoratorResponse]:
# pass
. Output only the next line. | 'classes': plugin_classes, |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.