Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Using the snippet: <|code_start|>
@pytest.mark.parametrize('input_value', [
'foo',
100,
True,
False,
None,
])
<|code_end|>
, determine the next line of code. You have imports:
from datetime import datetime
from notifications_utils.timezones import (
convert_bst_to_utc,
convert_utc_to_bst,
utc_string_to_aware_gmt_datetime,
)
import pytest
and context (class names, function names, or code) available:
# Path: notifications_utils/timezones.py
# def convert_bst_to_utc(date):
# """
# Takes a naive London datetime and returns a naive UTC datetime
# """
# return local_timezone.localize(date).astimezone(pytz.UTC).replace(tzinfo=None)
#
# def convert_utc_to_bst(utc_dt):
# """
# Takes a naive UTC datetime and returns a naive London datetime
# """
# return pytz.utc.localize(utc_dt).astimezone(local_timezone).replace(tzinfo=None)
#
# def utc_string_to_aware_gmt_datetime(date):
# """
# Date can either be a string, naive UTC datetime or an aware UTC datetime
# Returns an aware London datetime, essentially the time you'd see on your clock
# """
# if not isinstance(date, datetime):
# date = parser.parse(date)
#
# forced_utc = date.replace(tzinfo=pytz.utc)
# return forced_utc.astimezone(local_timezone)
. Output only the next line. | def test_utc_string_to_aware_gmt_datetime_rejects_bad_input(input_value): |
Based on the snippet: <|code_start|> 'Monday 2017-01-02 17:29:59',
'Tuesday 2017-01-03 15:00',
True,
'Wednesday 2017-01-04 16:00',
'Thursday 2017-01-05 16:00',
'Friday 2017-01-06 16:00',
'Saturday 2017-01-07 16:00',
'Tuesday 2017-01-10 16:00',
'Tuesday 2017-01-10 16:00',
'Thursday 2017-01-12 16:00',
),
# Monday at 17:00 GMT
(
'Monday 2017-01-02 17:30:01',
'Wednesday 2017-01-04 15:00',
True,
'Thursday 2017-01-05 16:00',
'Friday 2017-01-06 16:00',
'Saturday 2017-01-07 16:00',
'Monday 2017-01-09 16:00',
'Wednesday 2017-01-11 16:00',
'Wednesday 2017-01-11 16:00',
'Friday 2017-01-13 16:00',
),
# Over Easter bank holiday weekend
(
'Thursday 2020-04-09 16:29:59',
'Tuesday 2020-04-14 15:00',
False,
<|code_end|>
, predict the immediate next line with the help of imports:
from datetime import datetime
from freezegun import freeze_time
from notifications_utils.letter_timings import (
get_letter_timings,
letter_can_be_cancelled,
)
import pytest
import pytz
and context (classes, functions, sometimes code) from other files:
# Path: notifications_utils/letter_timings.py
# def get_letter_timings(upload_time, postage):
#
# LetterTimings = namedtuple(
# 'LetterTimings',
# 'printed_by, is_printed, earliest_delivery, latest_delivery'
# )
#
# # shift anything after 5:30pm to the next day
# processing_day = utc_string_to_aware_gmt_datetime(upload_time) + timedelta(hours=6, minutes=30)
# print_day = get_next_dvla_working_day(processing_day)
#
# earliest_delivery, latest_delivery = get_earliest_and_latest_delivery(print_day, postage)
#
# # print deadline is 3pm BST
# printed_by = set_gmt_hour(print_day, hour=15)
# now = datetime.utcnow().replace(tzinfo=pytz.utc).astimezone(pytz.timezone('Europe/London'))
#
# return LetterTimings(
# printed_by=printed_by,
# is_printed=(now > printed_by),
# earliest_delivery=set_gmt_hour(earliest_delivery, hour=16),
# latest_delivery=set_gmt_hour(latest_delivery, hour=16),
# )
#
# def letter_can_be_cancelled(notification_status, notification_created_at):
# '''
# If letter does not have status of created or pending-virus-check
# => can't be cancelled (it has already been processed)
#
# If it's after 5.30pm local time and the notification was created today before 5.30pm local time
# => can't be cancelled (it will already be zipped up to be sent)
# '''
# if notification_status not in ('created', 'pending-virus-check'):
# return False
#
# if too_late_to_cancel_letter(notification_created_at):
# return False
# return True
. Output only the next line. | 'Wednesday 2020-04-15 16:00', |
Predict the next line after this snippet: <|code_start|> (
'Monday 2017-01-02 17:29:59',
'Tuesday 2017-01-03 15:00',
True,
'Wednesday 2017-01-04 16:00',
'Thursday 2017-01-05 16:00',
'Friday 2017-01-06 16:00',
'Saturday 2017-01-07 16:00',
'Tuesday 2017-01-10 16:00',
'Tuesday 2017-01-10 16:00',
'Thursday 2017-01-12 16:00',
),
# Monday at 17:00 GMT
(
'Monday 2017-01-02 17:30:01',
'Wednesday 2017-01-04 15:00',
True,
'Thursday 2017-01-05 16:00',
'Friday 2017-01-06 16:00',
'Saturday 2017-01-07 16:00',
'Monday 2017-01-09 16:00',
'Wednesday 2017-01-11 16:00',
'Wednesday 2017-01-11 16:00',
'Friday 2017-01-13 16:00',
),
# Over Easter bank holiday weekend
(
'Thursday 2020-04-09 16:29:59',
'Tuesday 2020-04-14 15:00',
<|code_end|>
using the current file's imports:
from datetime import datetime
from freezegun import freeze_time
from notifications_utils.letter_timings import (
get_letter_timings,
letter_can_be_cancelled,
)
import pytest
import pytz
and any relevant context from other files:
# Path: notifications_utils/letter_timings.py
# def get_letter_timings(upload_time, postage):
#
# LetterTimings = namedtuple(
# 'LetterTimings',
# 'printed_by, is_printed, earliest_delivery, latest_delivery'
# )
#
# # shift anything after 5:30pm to the next day
# processing_day = utc_string_to_aware_gmt_datetime(upload_time) + timedelta(hours=6, minutes=30)
# print_day = get_next_dvla_working_day(processing_day)
#
# earliest_delivery, latest_delivery = get_earliest_and_latest_delivery(print_day, postage)
#
# # print deadline is 3pm BST
# printed_by = set_gmt_hour(print_day, hour=15)
# now = datetime.utcnow().replace(tzinfo=pytz.utc).astimezone(pytz.timezone('Europe/London'))
#
# return LetterTimings(
# printed_by=printed_by,
# is_printed=(now > printed_by),
# earliest_delivery=set_gmt_hour(earliest_delivery, hour=16),
# latest_delivery=set_gmt_hour(latest_delivery, hour=16),
# )
#
# def letter_can_be_cancelled(notification_status, notification_created_at):
# '''
# If letter does not have status of created or pending-virus-check
# => can't be cancelled (it has already been processed)
#
# If it's after 5.30pm local time and the notification was created today before 5.30pm local time
# => can't be cancelled (it will already be zipped up to be sent)
# '''
# if notification_status not in ('created', 'pending-virus-check'):
# return False
#
# if too_late_to_cancel_letter(notification_created_at):
# return False
# return True
. Output only the next line. | False, |
Based on the snippet: <|code_start|> (None, False), (10, False), (11, True)
])
def test_is_letter_too_long(page_count, expected_result):
assert is_letter_too_long(page_count) == expected_result
def test_extract_page_from_pdf_one_page_pdf():
file_data = base64.b64decode(one_page_pdf)
pdf_page = extract_page_from_pdf(BytesIO(file_data), 0)
pdf_original = PyPDF2.PdfFileReader(BytesIO(file_data))
pdf_new = PyPDF2.PdfFileReader(BytesIO(pdf_page))
assert pdf_original.getPage(0).extractText() == pdf_new.getPage(0).extractText()
def test_extract_page_from_pdf_multi_page_pdf():
file_data = base64.b64decode(multi_page_pdf)
pdf_page = extract_page_from_pdf(BytesIO(file_data), 4)
pdf_original = PyPDF2.PdfFileReader(BytesIO(file_data))
pdf_new = PyPDF2.PdfFileReader(BytesIO(pdf_page))
assert pdf_original.getPage(4).extractText() == pdf_new.getPage(0).extractText()
assert pdf_original.getPage(3).extractText() != pdf_new.getPage(0).extractText()
def test_extract_page_from_pdf_request_page_out_of_bounds():
<|code_end|>
, predict the immediate next line with the help of imports:
import base64
import PyPDF2
import pytest
from io import BytesIO
from PyPDF2.utils import PdfReadError
from notifications_utils.pdf import (
extract_page_from_pdf,
is_letter_too_long,
pdf_page_count,
)
from tests.pdf_consts import multi_page_pdf, not_pdf, one_page_pdf
and context (classes, functions, sometimes code) from other files:
# Path: notifications_utils/pdf.py
# def extract_page_from_pdf(src_pdf, page_number):
# """
# Retrieves a new PDF document with the page extracted from the source PDF file.
#
# :param src_pdf: File object or an object that supports the standard read and seek methods similar to a File object.
# :param page_number: The page number to retrieve (pages begin at zero)
# """
# pdf = PyPDF2.PdfFileReader(src_pdf)
#
# if pdf.numPages < page_number:
# raise PdfReadError("Page number requested: {} of {} does not exist in document".format(
# str(page_number),
# str(pdf.numPages)
# ))
#
# writer = PdfFileWriter()
# writer.addPage(pdf.getPage(page_number))
#
# pdf_bytes = io.BytesIO()
# writer.write(pdf_bytes)
# pdf_bytes.seek(0)
#
# return pdf_bytes.read()
#
# def is_letter_too_long(page_count):
# """
# Returns True if page count above the limit
# :param page_count: number of pages in a document or None
# """
# if not page_count:
# return False
# return page_count > LETTER_MAX_PAGE_COUNT
#
# def pdf_page_count(src_pdf):
# """
# Returns number of pages in a pdf file
#
# :param PyPDF2.PdfFileReader src_pdf: A File object or an object that supports the standard read and seek methods
# """
# try:
# pdf = PyPDF2.PdfFileReader(src_pdf)
# except AttributeError as e:
# raise PdfReadError("Could not open PDF file, stream is null", e)
#
# return pdf.numPages
. Output only the next line. | with pytest.raises(PdfReadError) as e: |
Continue the code snippet: <|code_start|>
def test_pdf_page_count_src_pdf_not_a_pdf():
with pytest.raises(PdfReadError):
file_data = base64.b64decode(not_pdf)
pdf_page_count(BytesIO(file_data))
@pytest.mark.parametrize("page_count, expected_result", [
(None, False), (10, False), (11, True)
])
def test_is_letter_too_long(page_count, expected_result):
assert is_letter_too_long(page_count) == expected_result
def test_extract_page_from_pdf_one_page_pdf():
file_data = base64.b64decode(one_page_pdf)
pdf_page = extract_page_from_pdf(BytesIO(file_data), 0)
pdf_original = PyPDF2.PdfFileReader(BytesIO(file_data))
pdf_new = PyPDF2.PdfFileReader(BytesIO(pdf_page))
assert pdf_original.getPage(0).extractText() == pdf_new.getPage(0).extractText()
def test_extract_page_from_pdf_multi_page_pdf():
file_data = base64.b64decode(multi_page_pdf)
pdf_page = extract_page_from_pdf(BytesIO(file_data), 4)
<|code_end|>
. Use current file imports:
import base64
import PyPDF2
import pytest
from io import BytesIO
from PyPDF2.utils import PdfReadError
from notifications_utils.pdf import (
extract_page_from_pdf,
is_letter_too_long,
pdf_page_count,
)
from tests.pdf_consts import multi_page_pdf, not_pdf, one_page_pdf
and context (classes, functions, or code) from other files:
# Path: notifications_utils/pdf.py
# def extract_page_from_pdf(src_pdf, page_number):
# """
# Retrieves a new PDF document with the page extracted from the source PDF file.
#
# :param src_pdf: File object or an object that supports the standard read and seek methods similar to a File object.
# :param page_number: The page number to retrieve (pages begin at zero)
# """
# pdf = PyPDF2.PdfFileReader(src_pdf)
#
# if pdf.numPages < page_number:
# raise PdfReadError("Page number requested: {} of {} does not exist in document".format(
# str(page_number),
# str(pdf.numPages)
# ))
#
# writer = PdfFileWriter()
# writer.addPage(pdf.getPage(page_number))
#
# pdf_bytes = io.BytesIO()
# writer.write(pdf_bytes)
# pdf_bytes.seek(0)
#
# return pdf_bytes.read()
#
# def is_letter_too_long(page_count):
# """
# Returns True if page count above the limit
# :param page_count: number of pages in a document or None
# """
# if not page_count:
# return False
# return page_count > LETTER_MAX_PAGE_COUNT
#
# def pdf_page_count(src_pdf):
# """
# Returns number of pages in a pdf file
#
# :param PyPDF2.PdfFileReader src_pdf: A File object or an object that supports the standard read and seek methods
# """
# try:
# pdf = PyPDF2.PdfFileReader(src_pdf)
# except AttributeError as e:
# raise PdfReadError("Could not open PDF file, stream is null", e)
#
# return pdf.numPages
. Output only the next line. | pdf_original = PyPDF2.PdfFileReader(BytesIO(file_data)) |
Using the snippet: <|code_start|>
def test_pdf_page_count_src_pdf_is_null():
with pytest.raises(PdfReadError):
pdf_page_count(None)
def test_pdf_page_count_src_pdf_has_one_page():
file_data = base64.b64decode(one_page_pdf)
num = pdf_page_count(BytesIO(file_data))
assert num == 1
def test_pdf_page_count_src_pdf_has_multiple_pages():
file_data = base64.b64decode(multi_page_pdf)
num = pdf_page_count(BytesIO(file_data))
assert num == 10
def test_pdf_page_count_src_pdf_not_a_pdf():
with pytest.raises(PdfReadError):
file_data = base64.b64decode(not_pdf)
pdf_page_count(BytesIO(file_data))
@pytest.mark.parametrize("page_count, expected_result", [
<|code_end|>
, determine the next line of code. You have imports:
import base64
import PyPDF2
import pytest
from io import BytesIO
from PyPDF2.utils import PdfReadError
from notifications_utils.pdf import (
extract_page_from_pdf,
is_letter_too_long,
pdf_page_count,
)
from tests.pdf_consts import multi_page_pdf, not_pdf, one_page_pdf
and context (class names, function names, or code) available:
# Path: notifications_utils/pdf.py
# def extract_page_from_pdf(src_pdf, page_number):
# """
# Retrieves a new PDF document with the page extracted from the source PDF file.
#
# :param src_pdf: File object or an object that supports the standard read and seek methods similar to a File object.
# :param page_number: The page number to retrieve (pages begin at zero)
# """
# pdf = PyPDF2.PdfFileReader(src_pdf)
#
# if pdf.numPages < page_number:
# raise PdfReadError("Page number requested: {} of {} does not exist in document".format(
# str(page_number),
# str(pdf.numPages)
# ))
#
# writer = PdfFileWriter()
# writer.addPage(pdf.getPage(page_number))
#
# pdf_bytes = io.BytesIO()
# writer.write(pdf_bytes)
# pdf_bytes.seek(0)
#
# return pdf_bytes.read()
#
# def is_letter_too_long(page_count):
# """
# Returns True if page count above the limit
# :param page_count: number of pages in a document or None
# """
# if not page_count:
# return False
# return page_count > LETTER_MAX_PAGE_COUNT
#
# def pdf_page_count(src_pdf):
# """
# Returns number of pages in a pdf file
#
# :param PyPDF2.PdfFileReader src_pdf: A File object or an object that supports the standard read and seek methods
# """
# try:
# pdf = PyPDF2.PdfFileReader(src_pdf)
# except AttributeError as e:
# raise PdfReadError("Could not open PDF file, stream is null", e)
#
# return pdf.numPages
. Output only the next line. | (None, False), (10, False), (11, True) |
Next line prediction: <|code_start|>
@pytest.fixture()
def encryption_client(app):
client = Encryption()
app.config['SECRET_KEY'] = 'test-notify-secret-key'
<|code_end|>
. Use current file imports:
(import pytest
from notifications_utils.clients.encryption.encryption_client import Encryption)
and context including class names, function names, or small code snippets from other files:
# Path: notifications_utils/clients/encryption/encryption_client.py
# class Encryption:
# def init_app(self, app):
# self.serializer = URLSafeSerializer(app.config.get('SECRET_KEY'))
# self.salt = app.config.get('DANGEROUS_SALT')
#
# def encrypt(self, thing_to_encrypt):
# return self.serializer.dumps(thing_to_encrypt, salt=self.salt)
#
# def decrypt(self, thing_to_decrypt):
# return self.serializer.loads(thing_to_decrypt, salt=self.salt)
. Output only the next line. | app.config['DANGEROUS_SALT'] = 'test-notify-salt' |
Based on the snippet: <|code_start|> '07123 ☟☜⬇⬆☞☝',
'07123☟☜⬇⬆☞☝',
'07";DROP TABLE;"',
'+44 07ab cde fgh',
'ALPHANUM3R1C',
))
]
], [])
invalid_phone_numbers = list(filter(
lambda number: number[0] not in {
'712345678910', # Could be Russia
},
invalid_uk_phone_numbers
)) + [
('800000000000', 'Not a valid country prefix'),
('1234567', 'Not enough digits'),
('+682 1234', 'Not enough digits'), # Cook Islands phone numbers can be 5 digits
('+12345 12345 12345 6', 'Too many digits'),
]
valid_email_addresses = (
'email@domain.com',
'email@domain.COM',
'firstname.lastname@domain.com',
'firstname.o\'lastname@domain.com',
'email@subdomain.domain.com',
'firstname+lastname@domain.com',
<|code_end|>
, predict the immediate next line with the help of imports:
import pytest
from notifications_utils.recipients import (
InvalidEmailError,
InvalidPhoneError,
allowed_to_send_to,
format_phone_number_human_readable,
format_recipient,
get_international_phone_info,
international_phone_info,
is_uk_phone_number,
normalise_phone_number,
try_validate_and_format_phone_number,
validate_and_format_phone_number,
validate_email_address,
validate_phone_number,
)
and context (classes, functions, sometimes code) from other files:
# Path: notifications_utils/recipients.py
# class RecipientCSV():
# class Row(InsensitiveDict):
# class Cell():
# class InvalidEmailError(Exception):
# class InvalidPhoneError(InvalidEmailError):
# class InvalidAddressError(InvalidEmailError):
# def __init__(
# self,
# file_data,
# template,
# max_errors_shown=20,
# max_initial_rows_shown=10,
# guestlist=None,
# remaining_messages=sys.maxsize,
# allow_international_sms=False,
# allow_international_letters=False,
# should_validate=True,
# ):
# def __len__(self):
# def __getitem__(self, requested_index):
# def guestlist(self):
# def guestlist(self, value):
# def template(self):
# def template(self, value):
# def placeholders(self):
# def placeholders(self, value):
# def has_errors(self):
# def allowed_to_send_to(self):
# def rows(self):
# def _rows(self):
# def get_rows(self):
# def more_rows_than_can_send(self):
# def too_many_rows(self):
# def initial_rows(self):
# def displayed_rows(self):
# def _filter_rows(self, attr):
# def rows_with_errors(self):
# def rows_with_bad_recipients(self):
# def rows_with_missing_data(self):
# def rows_with_message_too_long(self):
# def rows_with_empty_message(self):
# def initial_rows_with_errors(self):
# def _raw_column_headers(self):
# def column_headers(self):
# def column_headers_as_column_keys(self):
# def missing_column_headers(self):
# def duplicate_recipient_column_headers(self):
# def is_address_column(self, key):
# def count_of_required_recipient_columns(self):
# def has_recipient_columns(self):
# def _get_error_for_field(self, key, value): # noqa: C901
# def __init__(
# self,
# row_dict,
# *,
# index,
# error_fn,
# recipient_column_headers,
# placeholders,
# template,
# allow_international_letters,
# validate_row=True,
# ):
# def __getitem__(self, key):
# def get(self, key, default=None):
# def has_error(self):
# def has_bad_recipient(self):
# def has_bad_postal_address(self):
# def has_error_spanning_multiple_cells(self):
# def has_missing_data(self):
# def recipient(self):
# def as_postal_address(self):
# def personalisation(self):
# def recipient_and_personalisation(self):
# def __init__(
# self,
# key=None,
# value=None,
# error_fn=None,
# placeholders=None
# ):
# def __eq__(self, other):
# def recipient_error(self):
# def __init__(self, message=None):
# def normalise_phone_number(number):
# def is_uk_phone_number(number):
# def get_international_phone_info(number):
# def _is_a_crown_dependency_number(number):
# def get_international_prefix(number):
# def get_billable_units_for_prefix(prefix):
# def use_numeric_sender(number):
# def validate_uk_phone_number(number):
# def validate_phone_number(number, international=False):
# def try_validate_and_format_phone_number(number, international=None, log_msg=None):
# def validate_email_address(email_address): # noqa (C901 too complex)
# def format_email_address(email_address):
# def validate_and_format_email_address(email_address):
# def format_recipient(recipient):
# def format_phone_number_human_readable(phone_number):
# def allowed_to_send_to(recipient, allowlist):
# def insert_or_append_to_dict(dict_, key, value):
# CROWN_DEPENDENCY_RANGES = ['7781', '7839', '7911', '7509', '7797', '7937', '7700', '7829', '7624', '7524', '7924']
. Output only the next line. | '1234567890@domain.com', |
Given the code snippet: <|code_start|> '712345678910', # Could be Russia
},
invalid_uk_phone_numbers
)) + [
('800000000000', 'Not a valid country prefix'),
('1234567', 'Not enough digits'),
('+682 1234', 'Not enough digits'), # Cook Islands phone numbers can be 5 digits
('+12345 12345 12345 6', 'Too many digits'),
]
valid_email_addresses = (
'email@domain.com',
'email@domain.COM',
'firstname.lastname@domain.com',
'firstname.o\'lastname@domain.com',
'email@subdomain.domain.com',
'firstname+lastname@domain.com',
'1234567890@domain.com',
'email@domain-one.com',
'_______@domain.com',
'email@domain.name',
'email@domain.superlongtld',
'email@domain.co.jp',
'firstname-lastname@domain.com',
'info@german-financial-services.vermögensberatung',
'info@german-financial-services.reallylongarbitrarytldthatiswaytoohugejustincase',
'japanese-info@例え.テスト',
'email@double--hyphen.com'
)
<|code_end|>
, generate the next line using the imports in this file:
import pytest
from notifications_utils.recipients import (
InvalidEmailError,
InvalidPhoneError,
allowed_to_send_to,
format_phone_number_human_readable,
format_recipient,
get_international_phone_info,
international_phone_info,
is_uk_phone_number,
normalise_phone_number,
try_validate_and_format_phone_number,
validate_and_format_phone_number,
validate_email_address,
validate_phone_number,
)
and context (functions, classes, or occasionally code) from other files:
# Path: notifications_utils/recipients.py
# class RecipientCSV():
# class Row(InsensitiveDict):
# class Cell():
# class InvalidEmailError(Exception):
# class InvalidPhoneError(InvalidEmailError):
# class InvalidAddressError(InvalidEmailError):
# def __init__(
# self,
# file_data,
# template,
# max_errors_shown=20,
# max_initial_rows_shown=10,
# guestlist=None,
# remaining_messages=sys.maxsize,
# allow_international_sms=False,
# allow_international_letters=False,
# should_validate=True,
# ):
# def __len__(self):
# def __getitem__(self, requested_index):
# def guestlist(self):
# def guestlist(self, value):
# def template(self):
# def template(self, value):
# def placeholders(self):
# def placeholders(self, value):
# def has_errors(self):
# def allowed_to_send_to(self):
# def rows(self):
# def _rows(self):
# def get_rows(self):
# def more_rows_than_can_send(self):
# def too_many_rows(self):
# def initial_rows(self):
# def displayed_rows(self):
# def _filter_rows(self, attr):
# def rows_with_errors(self):
# def rows_with_bad_recipients(self):
# def rows_with_missing_data(self):
# def rows_with_message_too_long(self):
# def rows_with_empty_message(self):
# def initial_rows_with_errors(self):
# def _raw_column_headers(self):
# def column_headers(self):
# def column_headers_as_column_keys(self):
# def missing_column_headers(self):
# def duplicate_recipient_column_headers(self):
# def is_address_column(self, key):
# def count_of_required_recipient_columns(self):
# def has_recipient_columns(self):
# def _get_error_for_field(self, key, value): # noqa: C901
# def __init__(
# self,
# row_dict,
# *,
# index,
# error_fn,
# recipient_column_headers,
# placeholders,
# template,
# allow_international_letters,
# validate_row=True,
# ):
# def __getitem__(self, key):
# def get(self, key, default=None):
# def has_error(self):
# def has_bad_recipient(self):
# def has_bad_postal_address(self):
# def has_error_spanning_multiple_cells(self):
# def has_missing_data(self):
# def recipient(self):
# def as_postal_address(self):
# def personalisation(self):
# def recipient_and_personalisation(self):
# def __init__(
# self,
# key=None,
# value=None,
# error_fn=None,
# placeholders=None
# ):
# def __eq__(self, other):
# def recipient_error(self):
# def __init__(self, message=None):
# def normalise_phone_number(number):
# def is_uk_phone_number(number):
# def get_international_phone_info(number):
# def _is_a_crown_dependency_number(number):
# def get_international_prefix(number):
# def get_billable_units_for_prefix(prefix):
# def use_numeric_sender(number):
# def validate_uk_phone_number(number):
# def validate_phone_number(number, international=False):
# def try_validate_and_format_phone_number(number, international=None, log_msg=None):
# def validate_email_address(email_address): # noqa (C901 too complex)
# def format_email_address(email_address):
# def validate_and_format_email_address(email_address):
# def format_recipient(recipient):
# def format_phone_number_human_readable(phone_number):
# def allowed_to_send_to(recipient, allowlist):
# def insert_or_append_to_dict(dict_, key, value):
# CROWN_DEPENDENCY_RANGES = ['7781', '7839', '7911', '7509', '7797', '7937', '7700', '7829', '7624', '7524', '7924']
. Output only the next line. | invalid_email_addresses = ( |
Based on the snippet: <|code_start|> '71234567890', # Russia
'1-202-555-0104', # USA
'+12025550104', # USA
'0012025550104', # USA
'+0012025550104', # USA
'23051234567', # Mauritius,
'+682 12345', # Cook islands
'+3312345678',
'003312345678',
'1-2345-12345-12345', # 15 digits
]
valid_phone_numbers = valid_uk_phone_numbers + valid_international_phone_numbers
invalid_uk_phone_numbers = sum([
[
(phone_number, error) for phone_number in group
] for error, group in [
('Too many digits', (
'712345678910',
'0712345678910',
'0044712345678910',
'0044712345678910',
'+44 (0)7123 456 789 10',
)),
('Not enough digits', (
'0712345678',
'004471234567',
<|code_end|>
, predict the immediate next line with the help of imports:
import pytest
from notifications_utils.recipients import (
InvalidEmailError,
InvalidPhoneError,
allowed_to_send_to,
format_phone_number_human_readable,
format_recipient,
get_international_phone_info,
international_phone_info,
is_uk_phone_number,
normalise_phone_number,
try_validate_and_format_phone_number,
validate_and_format_phone_number,
validate_email_address,
validate_phone_number,
)
and context (classes, functions, sometimes code) from other files:
# Path: notifications_utils/recipients.py
# class RecipientCSV():
# class Row(InsensitiveDict):
# class Cell():
# class InvalidEmailError(Exception):
# class InvalidPhoneError(InvalidEmailError):
# class InvalidAddressError(InvalidEmailError):
# def __init__(
# self,
# file_data,
# template,
# max_errors_shown=20,
# max_initial_rows_shown=10,
# guestlist=None,
# remaining_messages=sys.maxsize,
# allow_international_sms=False,
# allow_international_letters=False,
# should_validate=True,
# ):
# def __len__(self):
# def __getitem__(self, requested_index):
# def guestlist(self):
# def guestlist(self, value):
# def template(self):
# def template(self, value):
# def placeholders(self):
# def placeholders(self, value):
# def has_errors(self):
# def allowed_to_send_to(self):
# def rows(self):
# def _rows(self):
# def get_rows(self):
# def more_rows_than_can_send(self):
# def too_many_rows(self):
# def initial_rows(self):
# def displayed_rows(self):
# def _filter_rows(self, attr):
# def rows_with_errors(self):
# def rows_with_bad_recipients(self):
# def rows_with_missing_data(self):
# def rows_with_message_too_long(self):
# def rows_with_empty_message(self):
# def initial_rows_with_errors(self):
# def _raw_column_headers(self):
# def column_headers(self):
# def column_headers_as_column_keys(self):
# def missing_column_headers(self):
# def duplicate_recipient_column_headers(self):
# def is_address_column(self, key):
# def count_of_required_recipient_columns(self):
# def has_recipient_columns(self):
# def _get_error_for_field(self, key, value): # noqa: C901
# def __init__(
# self,
# row_dict,
# *,
# index,
# error_fn,
# recipient_column_headers,
# placeholders,
# template,
# allow_international_letters,
# validate_row=True,
# ):
# def __getitem__(self, key):
# def get(self, key, default=None):
# def has_error(self):
# def has_bad_recipient(self):
# def has_bad_postal_address(self):
# def has_error_spanning_multiple_cells(self):
# def has_missing_data(self):
# def recipient(self):
# def as_postal_address(self):
# def personalisation(self):
# def recipient_and_personalisation(self):
# def __init__(
# self,
# key=None,
# value=None,
# error_fn=None,
# placeholders=None
# ):
# def __eq__(self, other):
# def recipient_error(self):
# def __init__(self, message=None):
# def normalise_phone_number(number):
# def is_uk_phone_number(number):
# def get_international_phone_info(number):
# def _is_a_crown_dependency_number(number):
# def get_international_prefix(number):
# def get_billable_units_for_prefix(prefix):
# def use_numeric_sender(number):
# def validate_uk_phone_number(number):
# def validate_phone_number(number, international=False):
# def try_validate_and_format_phone_number(number, international=None, log_msg=None):
# def validate_email_address(email_address): # noqa (C901 too complex)
# def format_email_address(email_address):
# def validate_and_format_email_address(email_address):
# def format_recipient(recipient):
# def format_phone_number_human_readable(phone_number):
# def allowed_to_send_to(recipient, allowlist):
# def insert_or_append_to_dict(dict_, key, value):
# CROWN_DEPENDENCY_RANGES = ['7781', '7839', '7911', '7509', '7797', '7937', '7700', '7829', '7624', '7524', '7924']
. Output only the next line. | '00447123456', |
Given the following code snippet before the placeholder: <|code_start|> ['1-202-555-0104', '0012025550104'],
['0012025550104', '1-202-555-0104'],
])
def test_validates_against_guestlist_of_international_phone_numbers(recipient_number, allowlist_number):
assert allowed_to_send_to(recipient_number, [allowlist_number])
@pytest.mark.parametrize("email_address", valid_email_addresses)
def test_validates_against_guestlist_of_email_addresses(email_address):
assert not allowed_to_send_to(email_address, ['very_special_and_unique@example.com'])
@pytest.mark.parametrize("phone_number, expected_formatted", [
('07900900123', '07900 900123'), # UK
('+44(0)7900900123', '07900 900123'), # UK
('447900900123', '07900 900123'), # UK
('20-12-1234-1234', '+20 121 234 1234'), # Egypt
('00201212341234', '+20 121 234 1234'), # Egypt
('1664 0000000', '+1 664-000-0000'), # Montserrat
('7 499 1231212', '+7 499 123-12-12'), # Moscow (Russia)
('1-202-555-0104', '+1 202-555-0104'), # Washington DC (USA)
('+23051234567', '+230 5123 4567'), # Mauritius
('33(0)1 12345678', '+33 1 12 34 56 78'), # Paris (France)
])
def test_format_uk_and_international_phone_numbers(phone_number, expected_formatted):
assert format_phone_number_human_readable(phone_number) == expected_formatted
@pytest.mark.parametrize("recipient, expected_formatted", [
(True, ''),
<|code_end|>
, predict the next line using imports from the current file:
import pytest
from notifications_utils.recipients import (
InvalidEmailError,
InvalidPhoneError,
allowed_to_send_to,
format_phone_number_human_readable,
format_recipient,
get_international_phone_info,
international_phone_info,
is_uk_phone_number,
normalise_phone_number,
try_validate_and_format_phone_number,
validate_and_format_phone_number,
validate_email_address,
validate_phone_number,
)
and context including class names, function names, and sometimes code from other files:
# Path: notifications_utils/recipients.py
# class RecipientCSV():
# class Row(InsensitiveDict):
# class Cell():
# class InvalidEmailError(Exception):
# class InvalidPhoneError(InvalidEmailError):
# class InvalidAddressError(InvalidEmailError):
# def __init__(
# self,
# file_data,
# template,
# max_errors_shown=20,
# max_initial_rows_shown=10,
# guestlist=None,
# remaining_messages=sys.maxsize,
# allow_international_sms=False,
# allow_international_letters=False,
# should_validate=True,
# ):
# def __len__(self):
# def __getitem__(self, requested_index):
# def guestlist(self):
# def guestlist(self, value):
# def template(self):
# def template(self, value):
# def placeholders(self):
# def placeholders(self, value):
# def has_errors(self):
# def allowed_to_send_to(self):
# def rows(self):
# def _rows(self):
# def get_rows(self):
# def more_rows_than_can_send(self):
# def too_many_rows(self):
# def initial_rows(self):
# def displayed_rows(self):
# def _filter_rows(self, attr):
# def rows_with_errors(self):
# def rows_with_bad_recipients(self):
# def rows_with_missing_data(self):
# def rows_with_message_too_long(self):
# def rows_with_empty_message(self):
# def initial_rows_with_errors(self):
# def _raw_column_headers(self):
# def column_headers(self):
# def column_headers_as_column_keys(self):
# def missing_column_headers(self):
# def duplicate_recipient_column_headers(self):
# def is_address_column(self, key):
# def count_of_required_recipient_columns(self):
# def has_recipient_columns(self):
# def _get_error_for_field(self, key, value): # noqa: C901
# def __init__(
# self,
# row_dict,
# *,
# index,
# error_fn,
# recipient_column_headers,
# placeholders,
# template,
# allow_international_letters,
# validate_row=True,
# ):
# def __getitem__(self, key):
# def get(self, key, default=None):
# def has_error(self):
# def has_bad_recipient(self):
# def has_bad_postal_address(self):
# def has_error_spanning_multiple_cells(self):
# def has_missing_data(self):
# def recipient(self):
# def as_postal_address(self):
# def personalisation(self):
# def recipient_and_personalisation(self):
# def __init__(
# self,
# key=None,
# value=None,
# error_fn=None,
# placeholders=None
# ):
# def __eq__(self, other):
# def recipient_error(self):
# def __init__(self, message=None):
# def normalise_phone_number(number):
# def is_uk_phone_number(number):
# def get_international_phone_info(number):
# def _is_a_crown_dependency_number(number):
# def get_international_prefix(number):
# def get_billable_units_for_prefix(prefix):
# def use_numeric_sender(number):
# def validate_uk_phone_number(number):
# def validate_phone_number(number, international=False):
# def try_validate_and_format_phone_number(number, international=None, log_msg=None):
# def validate_email_address(email_address): # noqa (C901 too complex)
# def format_email_address(email_address):
# def validate_and_format_email_address(email_address):
# def format_recipient(recipient):
# def format_phone_number_human_readable(phone_number):
# def allowed_to_send_to(recipient, allowlist):
# def insert_or_append_to_dict(dict_, key, value):
# CROWN_DEPENDENCY_RANGES = ['7781', '7839', '7911', '7509', '7797', '7937', '7700', '7829', '7624', '7524', '7924']
. Output only the next line. | (False, ''), |
Given the code snippet: <|code_start|> 'email@domain-one.com',
'_______@domain.com',
'email@domain.name',
'email@domain.superlongtld',
'email@domain.co.jp',
'firstname-lastname@domain.com',
'info@german-financial-services.vermögensberatung',
'info@german-financial-services.reallylongarbitrarytldthatiswaytoohugejustincase',
'japanese-info@例え.テスト',
'email@double--hyphen.com'
)
invalid_email_addresses = (
'email@123.123.123.123',
'email@[123.123.123.123]',
'plainaddress',
'@no-local-part.com',
'Outlook Contact <outlook-contact@domain.com>',
'no-at.domain.com',
'no-tld@domain',
';beginning-semicolon@domain.co.uk',
'middle-semicolon@domain.co;uk',
'trailing-semicolon@domain.com;',
'"email+leading-quotes@domain.com',
'email+middle"-quotes@domain.com',
'"quoted-local-part"@domain.com',
'"quoted@domain.com"',
'lots-of-dots@domain..gov..uk',
'two-dots..in-local@domain.com',
'multiple@domains@domain.com',
'spaces in local@domain.com',
<|code_end|>
, generate the next line using the imports in this file:
import pytest
from notifications_utils.recipients import (
InvalidEmailError,
InvalidPhoneError,
allowed_to_send_to,
format_phone_number_human_readable,
format_recipient,
get_international_phone_info,
international_phone_info,
is_uk_phone_number,
normalise_phone_number,
try_validate_and_format_phone_number,
validate_and_format_phone_number,
validate_email_address,
validate_phone_number,
)
and context (functions, classes, or occasionally code) from other files:
# Path: notifications_utils/recipients.py
# class RecipientCSV():
# class Row(InsensitiveDict):
# class Cell():
# class InvalidEmailError(Exception):
# class InvalidPhoneError(InvalidEmailError):
# class InvalidAddressError(InvalidEmailError):
# def __init__(
# self,
# file_data,
# template,
# max_errors_shown=20,
# max_initial_rows_shown=10,
# guestlist=None,
# remaining_messages=sys.maxsize,
# allow_international_sms=False,
# allow_international_letters=False,
# should_validate=True,
# ):
# def __len__(self):
# def __getitem__(self, requested_index):
# def guestlist(self):
# def guestlist(self, value):
# def template(self):
# def template(self, value):
# def placeholders(self):
# def placeholders(self, value):
# def has_errors(self):
# def allowed_to_send_to(self):
# def rows(self):
# def _rows(self):
# def get_rows(self):
# def more_rows_than_can_send(self):
# def too_many_rows(self):
# def initial_rows(self):
# def displayed_rows(self):
# def _filter_rows(self, attr):
# def rows_with_errors(self):
# def rows_with_bad_recipients(self):
# def rows_with_missing_data(self):
# def rows_with_message_too_long(self):
# def rows_with_empty_message(self):
# def initial_rows_with_errors(self):
# def _raw_column_headers(self):
# def column_headers(self):
# def column_headers_as_column_keys(self):
# def missing_column_headers(self):
# def duplicate_recipient_column_headers(self):
# def is_address_column(self, key):
# def count_of_required_recipient_columns(self):
# def has_recipient_columns(self):
# def _get_error_for_field(self, key, value): # noqa: C901
# def __init__(
# self,
# row_dict,
# *,
# index,
# error_fn,
# recipient_column_headers,
# placeholders,
# template,
# allow_international_letters,
# validate_row=True,
# ):
# def __getitem__(self, key):
# def get(self, key, default=None):
# def has_error(self):
# def has_bad_recipient(self):
# def has_bad_postal_address(self):
# def has_error_spanning_multiple_cells(self):
# def has_missing_data(self):
# def recipient(self):
# def as_postal_address(self):
# def personalisation(self):
# def recipient_and_personalisation(self):
# def __init__(
# self,
# key=None,
# value=None,
# error_fn=None,
# placeholders=None
# ):
# def __eq__(self, other):
# def recipient_error(self):
# def __init__(self, message=None):
# def normalise_phone_number(number):
# def is_uk_phone_number(number):
# def get_international_phone_info(number):
# def _is_a_crown_dependency_number(number):
# def get_international_prefix(number):
# def get_billable_units_for_prefix(prefix):
# def use_numeric_sender(number):
# def validate_uk_phone_number(number):
# def validate_phone_number(number, international=False):
# def try_validate_and_format_phone_number(number, international=None, log_msg=None):
# def validate_email_address(email_address): # noqa (C901 too complex)
# def format_email_address(email_address):
# def validate_and_format_email_address(email_address):
# def format_recipient(recipient):
# def format_phone_number_human_readable(phone_number):
# def allowed_to_send_to(recipient, allowlist):
# def insert_or_append_to_dict(dict_, key, value):
# CROWN_DEPENDENCY_RANGES = ['7781', '7839', '7911', '7509', '7797', '7937', '7700', '7829', '7624', '7524', '7924']
. Output only the next line. | 'spaces-in-domain@dom ain.com', |
Given snippet: <|code_start|>@pytest.mark.parametrize("phone_number", valid_uk_phone_numbers)
@pytest.mark.parametrize("extra_args", [
{},
{'international': False},
])
def test_phone_number_accepts_valid_values(extra_args, phone_number):
try:
validate_phone_number(phone_number, **extra_args)
except InvalidPhoneError:
pytest.fail('Unexpected InvalidPhoneError')
@pytest.mark.parametrize("phone_number", valid_phone_numbers)
def test_phone_number_accepts_valid_international_values(phone_number):
try:
validate_phone_number(phone_number, international=True)
except InvalidPhoneError:
pytest.fail('Unexpected InvalidPhoneError')
@pytest.mark.parametrize("phone_number", valid_uk_phone_numbers)
def test_valid_uk_phone_number_can_be_formatted_consistently(phone_number):
assert validate_and_format_phone_number(phone_number) == '447123456789'
@pytest.mark.parametrize("phone_number, expected_formatted", [
('71234567890', '71234567890'),
('1-202-555-0104', '12025550104'),
('+12025550104', '12025550104'),
('0012025550104', '12025550104'),
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pytest
from notifications_utils.recipients import (
InvalidEmailError,
InvalidPhoneError,
allowed_to_send_to,
format_phone_number_human_readable,
format_recipient,
get_international_phone_info,
international_phone_info,
is_uk_phone_number,
normalise_phone_number,
try_validate_and_format_phone_number,
validate_and_format_phone_number,
validate_email_address,
validate_phone_number,
)
and context:
# Path: notifications_utils/recipients.py
# class RecipientCSV():
# class Row(InsensitiveDict):
# class Cell():
# class InvalidEmailError(Exception):
# class InvalidPhoneError(InvalidEmailError):
# class InvalidAddressError(InvalidEmailError):
# def __init__(
# self,
# file_data,
# template,
# max_errors_shown=20,
# max_initial_rows_shown=10,
# guestlist=None,
# remaining_messages=sys.maxsize,
# allow_international_sms=False,
# allow_international_letters=False,
# should_validate=True,
# ):
# def __len__(self):
# def __getitem__(self, requested_index):
# def guestlist(self):
# def guestlist(self, value):
# def template(self):
# def template(self, value):
# def placeholders(self):
# def placeholders(self, value):
# def has_errors(self):
# def allowed_to_send_to(self):
# def rows(self):
# def _rows(self):
# def get_rows(self):
# def more_rows_than_can_send(self):
# def too_many_rows(self):
# def initial_rows(self):
# def displayed_rows(self):
# def _filter_rows(self, attr):
# def rows_with_errors(self):
# def rows_with_bad_recipients(self):
# def rows_with_missing_data(self):
# def rows_with_message_too_long(self):
# def rows_with_empty_message(self):
# def initial_rows_with_errors(self):
# def _raw_column_headers(self):
# def column_headers(self):
# def column_headers_as_column_keys(self):
# def missing_column_headers(self):
# def duplicate_recipient_column_headers(self):
# def is_address_column(self, key):
# def count_of_required_recipient_columns(self):
# def has_recipient_columns(self):
# def _get_error_for_field(self, key, value): # noqa: C901
# def __init__(
# self,
# row_dict,
# *,
# index,
# error_fn,
# recipient_column_headers,
# placeholders,
# template,
# allow_international_letters,
# validate_row=True,
# ):
# def __getitem__(self, key):
# def get(self, key, default=None):
# def has_error(self):
# def has_bad_recipient(self):
# def has_bad_postal_address(self):
# def has_error_spanning_multiple_cells(self):
# def has_missing_data(self):
# def recipient(self):
# def as_postal_address(self):
# def personalisation(self):
# def recipient_and_personalisation(self):
# def __init__(
# self,
# key=None,
# value=None,
# error_fn=None,
# placeholders=None
# ):
# def __eq__(self, other):
# def recipient_error(self):
# def __init__(self, message=None):
# def normalise_phone_number(number):
# def is_uk_phone_number(number):
# def get_international_phone_info(number):
# def _is_a_crown_dependency_number(number):
# def get_international_prefix(number):
# def get_billable_units_for_prefix(prefix):
# def use_numeric_sender(number):
# def validate_uk_phone_number(number):
# def validate_phone_number(number, international=False):
# def try_validate_and_format_phone_number(number, international=None, log_msg=None):
# def validate_email_address(email_address): # noqa (C901 too complex)
# def format_email_address(email_address):
# def validate_and_format_email_address(email_address):
# def format_recipient(recipient):
# def format_phone_number_human_readable(phone_number):
# def allowed_to_send_to(recipient, allowlist):
# def insert_or_append_to_dict(dict_, key, value):
# CROWN_DEPENDENCY_RANGES = ['7781', '7839', '7911', '7509', '7797', '7937', '7700', '7829', '7624', '7524', '7924']
which might include code, classes, or functions. Output only the next line. | ('+0012025550104', '12025550104'), |
Given snippet: <|code_start|>
valid_phone_numbers = valid_uk_phone_numbers + valid_international_phone_numbers
invalid_uk_phone_numbers = sum([
[
(phone_number, error) for phone_number in group
] for error, group in [
('Too many digits', (
'712345678910',
'0712345678910',
'0044712345678910',
'0044712345678910',
'+44 (0)7123 456 789 10',
)),
('Not enough digits', (
'0712345678',
'004471234567',
'00447123456',
'+44 (0)7123 456 78',
)),
('Not a UK mobile number', (
'08081 570364',
'+44 8081 570364',
'0117 496 0860',
'+44 117 496 0860',
'020 7946 0991',
'+44 20 7946 0991',
)),
('Must not contain letters or symbols', (
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pytest
from notifications_utils.recipients import (
InvalidEmailError,
InvalidPhoneError,
allowed_to_send_to,
format_phone_number_human_readable,
format_recipient,
get_international_phone_info,
international_phone_info,
is_uk_phone_number,
normalise_phone_number,
try_validate_and_format_phone_number,
validate_and_format_phone_number,
validate_email_address,
validate_phone_number,
)
and context:
# Path: notifications_utils/recipients.py
# class RecipientCSV():
# class Row(InsensitiveDict):
# class Cell():
# class InvalidEmailError(Exception):
# class InvalidPhoneError(InvalidEmailError):
# class InvalidAddressError(InvalidEmailError):
# def __init__(
# self,
# file_data,
# template,
# max_errors_shown=20,
# max_initial_rows_shown=10,
# guestlist=None,
# remaining_messages=sys.maxsize,
# allow_international_sms=False,
# allow_international_letters=False,
# should_validate=True,
# ):
# def __len__(self):
# def __getitem__(self, requested_index):
# def guestlist(self):
# def guestlist(self, value):
# def template(self):
# def template(self, value):
# def placeholders(self):
# def placeholders(self, value):
# def has_errors(self):
# def allowed_to_send_to(self):
# def rows(self):
# def _rows(self):
# def get_rows(self):
# def more_rows_than_can_send(self):
# def too_many_rows(self):
# def initial_rows(self):
# def displayed_rows(self):
# def _filter_rows(self, attr):
# def rows_with_errors(self):
# def rows_with_bad_recipients(self):
# def rows_with_missing_data(self):
# def rows_with_message_too_long(self):
# def rows_with_empty_message(self):
# def initial_rows_with_errors(self):
# def _raw_column_headers(self):
# def column_headers(self):
# def column_headers_as_column_keys(self):
# def missing_column_headers(self):
# def duplicate_recipient_column_headers(self):
# def is_address_column(self, key):
# def count_of_required_recipient_columns(self):
# def has_recipient_columns(self):
# def _get_error_for_field(self, key, value): # noqa: C901
# def __init__(
# self,
# row_dict,
# *,
# index,
# error_fn,
# recipient_column_headers,
# placeholders,
# template,
# allow_international_letters,
# validate_row=True,
# ):
# def __getitem__(self, key):
# def get(self, key, default=None):
# def has_error(self):
# def has_bad_recipient(self):
# def has_bad_postal_address(self):
# def has_error_spanning_multiple_cells(self):
# def has_missing_data(self):
# def recipient(self):
# def as_postal_address(self):
# def personalisation(self):
# def recipient_and_personalisation(self):
# def __init__(
# self,
# key=None,
# value=None,
# error_fn=None,
# placeholders=None
# ):
# def __eq__(self, other):
# def recipient_error(self):
# def __init__(self, message=None):
# def normalise_phone_number(number):
# def is_uk_phone_number(number):
# def get_international_phone_info(number):
# def _is_a_crown_dependency_number(number):
# def get_international_prefix(number):
# def get_billable_units_for_prefix(prefix):
# def use_numeric_sender(number):
# def validate_uk_phone_number(number):
# def validate_phone_number(number, international=False):
# def try_validate_and_format_phone_number(number, international=None, log_msg=None):
# def validate_email_address(email_address): # noqa (C901 too complex)
# def format_email_address(email_address):
# def validate_and_format_email_address(email_address):
# def format_recipient(recipient):
# def format_phone_number_human_readable(phone_number):
# def allowed_to_send_to(recipient, allowlist):
# def insert_or_append_to_dict(dict_, key, value):
# CROWN_DEPENDENCY_RANGES = ['7781', '7839', '7911', '7509', '7797', '7937', '7700', '7829', '7624', '7524', '7924']
which might include code, classes, or functions. Output only the next line. | '07890x32109', |
Using the snippet: <|code_start|> '+44 (0)7123 456 78',
)),
('Not a UK mobile number', (
'08081 570364',
'+44 8081 570364',
'0117 496 0860',
'+44 117 496 0860',
'020 7946 0991',
'+44 20 7946 0991',
)),
('Must not contain letters or symbols', (
'07890x32109',
'07123 456789...',
'07123 ☟☜⬇⬆☞☝',
'07123☟☜⬇⬆☞☝',
'07";DROP TABLE;"',
'+44 07ab cde fgh',
'ALPHANUM3R1C',
))
]
], [])
invalid_phone_numbers = list(filter(
lambda number: number[0] not in {
'712345678910', # Could be Russia
},
invalid_uk_phone_numbers
)) + [
('800000000000', 'Not a valid country prefix'),
<|code_end|>
, determine the next line of code. You have imports:
import pytest
from notifications_utils.recipients import (
InvalidEmailError,
InvalidPhoneError,
allowed_to_send_to,
format_phone_number_human_readable,
format_recipient,
get_international_phone_info,
international_phone_info,
is_uk_phone_number,
normalise_phone_number,
try_validate_and_format_phone_number,
validate_and_format_phone_number,
validate_email_address,
validate_phone_number,
)
and context (class names, function names, or code) available:
# Path: notifications_utils/recipients.py
# class RecipientCSV():
# class Row(InsensitiveDict):
# class Cell():
# class InvalidEmailError(Exception):
# class InvalidPhoneError(InvalidEmailError):
# class InvalidAddressError(InvalidEmailError):
# def __init__(
# self,
# file_data,
# template,
# max_errors_shown=20,
# max_initial_rows_shown=10,
# guestlist=None,
# remaining_messages=sys.maxsize,
# allow_international_sms=False,
# allow_international_letters=False,
# should_validate=True,
# ):
# def __len__(self):
# def __getitem__(self, requested_index):
# def guestlist(self):
# def guestlist(self, value):
# def template(self):
# def template(self, value):
# def placeholders(self):
# def placeholders(self, value):
# def has_errors(self):
# def allowed_to_send_to(self):
# def rows(self):
# def _rows(self):
# def get_rows(self):
# def more_rows_than_can_send(self):
# def too_many_rows(self):
# def initial_rows(self):
# def displayed_rows(self):
# def _filter_rows(self, attr):
# def rows_with_errors(self):
# def rows_with_bad_recipients(self):
# def rows_with_missing_data(self):
# def rows_with_message_too_long(self):
# def rows_with_empty_message(self):
# def initial_rows_with_errors(self):
# def _raw_column_headers(self):
# def column_headers(self):
# def column_headers_as_column_keys(self):
# def missing_column_headers(self):
# def duplicate_recipient_column_headers(self):
# def is_address_column(self, key):
# def count_of_required_recipient_columns(self):
# def has_recipient_columns(self):
# def _get_error_for_field(self, key, value): # noqa: C901
# def __init__(
# self,
# row_dict,
# *,
# index,
# error_fn,
# recipient_column_headers,
# placeholders,
# template,
# allow_international_letters,
# validate_row=True,
# ):
# def __getitem__(self, key):
# def get(self, key, default=None):
# def has_error(self):
# def has_bad_recipient(self):
# def has_bad_postal_address(self):
# def has_error_spanning_multiple_cells(self):
# def has_missing_data(self):
# def recipient(self):
# def as_postal_address(self):
# def personalisation(self):
# def recipient_and_personalisation(self):
# def __init__(
# self,
# key=None,
# value=None,
# error_fn=None,
# placeholders=None
# ):
# def __eq__(self, other):
# def recipient_error(self):
# def __init__(self, message=None):
# def normalise_phone_number(number):
# def is_uk_phone_number(number):
# def get_international_phone_info(number):
# def _is_a_crown_dependency_number(number):
# def get_international_prefix(number):
# def get_billable_units_for_prefix(prefix):
# def use_numeric_sender(number):
# def validate_uk_phone_number(number):
# def validate_phone_number(number, international=False):
# def try_validate_and_format_phone_number(number, international=None, log_msg=None):
# def validate_email_address(email_address): # noqa (C901 too complex)
# def format_email_address(email_address):
# def validate_and_format_email_address(email_address):
# def format_recipient(recipient):
# def format_phone_number_human_readable(phone_number):
# def allowed_to_send_to(recipient, allowlist):
# def insert_or_append_to_dict(dict_, key, value):
# CROWN_DEPENDENCY_RANGES = ['7781', '7839', '7911', '7509', '7797', '7937', '7700', '7829', '7624', '7524', '7924']
. Output only the next line. | ('1234567', 'Not enough digits'), |
Next line prediction: <|code_start|> )),
('1664000000000', international_phone_info(
international=True,
crown_dependency=False,
country_prefix='1664', # Montserrat
billable_units=1,
)),
('71234567890', international_phone_info(
international=True,
crown_dependency=False,
country_prefix='7', # Russia
billable_units=1,
)),
('1-202-555-0104', international_phone_info(
international=True,
crown_dependency=False,
country_prefix='1', # USA
billable_units=1,
)),
('+23051234567', international_phone_info(
international=True,
crown_dependency=False,
country_prefix='230', # Mauritius
billable_units=2,
))
])
def test_get_international_info(phone_number, expected_info):
assert get_international_phone_info(phone_number) == expected_info
<|code_end|>
. Use current file imports:
(import pytest
from notifications_utils.recipients import (
InvalidEmailError,
InvalidPhoneError,
allowed_to_send_to,
format_phone_number_human_readable,
format_recipient,
get_international_phone_info,
international_phone_info,
is_uk_phone_number,
normalise_phone_number,
try_validate_and_format_phone_number,
validate_and_format_phone_number,
validate_email_address,
validate_phone_number,
))
and context including class names, function names, or small code snippets from other files:
# Path: notifications_utils/recipients.py
# class RecipientCSV():
# class Row(InsensitiveDict):
# class Cell():
# class InvalidEmailError(Exception):
# class InvalidPhoneError(InvalidEmailError):
# class InvalidAddressError(InvalidEmailError):
# def __init__(
# self,
# file_data,
# template,
# max_errors_shown=20,
# max_initial_rows_shown=10,
# guestlist=None,
# remaining_messages=sys.maxsize,
# allow_international_sms=False,
# allow_international_letters=False,
# should_validate=True,
# ):
# def __len__(self):
# def __getitem__(self, requested_index):
# def guestlist(self):
# def guestlist(self, value):
# def template(self):
# def template(self, value):
# def placeholders(self):
# def placeholders(self, value):
# def has_errors(self):
# def allowed_to_send_to(self):
# def rows(self):
# def _rows(self):
# def get_rows(self):
# def more_rows_than_can_send(self):
# def too_many_rows(self):
# def initial_rows(self):
# def displayed_rows(self):
# def _filter_rows(self, attr):
# def rows_with_errors(self):
# def rows_with_bad_recipients(self):
# def rows_with_missing_data(self):
# def rows_with_message_too_long(self):
# def rows_with_empty_message(self):
# def initial_rows_with_errors(self):
# def _raw_column_headers(self):
# def column_headers(self):
# def column_headers_as_column_keys(self):
# def missing_column_headers(self):
# def duplicate_recipient_column_headers(self):
# def is_address_column(self, key):
# def count_of_required_recipient_columns(self):
# def has_recipient_columns(self):
# def _get_error_for_field(self, key, value): # noqa: C901
# def __init__(
# self,
# row_dict,
# *,
# index,
# error_fn,
# recipient_column_headers,
# placeholders,
# template,
# allow_international_letters,
# validate_row=True,
# ):
# def __getitem__(self, key):
# def get(self, key, default=None):
# def has_error(self):
# def has_bad_recipient(self):
# def has_bad_postal_address(self):
# def has_error_spanning_multiple_cells(self):
# def has_missing_data(self):
# def recipient(self):
# def as_postal_address(self):
# def personalisation(self):
# def recipient_and_personalisation(self):
# def __init__(
# self,
# key=None,
# value=None,
# error_fn=None,
# placeholders=None
# ):
# def __eq__(self, other):
# def recipient_error(self):
# def __init__(self, message=None):
# def normalise_phone_number(number):
# def is_uk_phone_number(number):
# def get_international_phone_info(number):
# def _is_a_crown_dependency_number(number):
# def get_international_prefix(number):
# def get_billable_units_for_prefix(prefix):
# def use_numeric_sender(number):
# def validate_uk_phone_number(number):
# def validate_phone_number(number, international=False):
# def try_validate_and_format_phone_number(number, international=None, log_msg=None):
# def validate_email_address(email_address): # noqa (C901 too complex)
# def format_email_address(email_address):
# def validate_and_format_email_address(email_address):
# def format_recipient(recipient):
# def format_phone_number_human_readable(phone_number):
# def allowed_to_send_to(recipient, allowlist):
# def insert_or_append_to_dict(dict_, key, value):
# CROWN_DEPENDENCY_RANGES = ['7781', '7839', '7911', '7509', '7797', '7937', '7700', '7829', '7624', '7524', '7924']
. Output only the next line. | @pytest.mark.parametrize('phone_number', [ |
Predict the next line after this snippet: <|code_start|> )),
('07700800123', international_phone_info(
international=True,
crown_dependency=True,
country_prefix='44', # UK Crown dependency, so prefix same as UK
billable_units=1,
)),
('20-12-1234-1234', international_phone_info(
international=True,
crown_dependency=False,
country_prefix='20', # Egypt
billable_units=3,
)),
('00201212341234', international_phone_info(
international=True,
crown_dependency=False,
country_prefix='20', # Egypt
billable_units=3,
)),
('1664000000000', international_phone_info(
international=True,
crown_dependency=False,
country_prefix='1664', # Montserrat
billable_units=1,
)),
('71234567890', international_phone_info(
international=True,
crown_dependency=False,
country_prefix='7', # Russia
billable_units=1,
<|code_end|>
using the current file's imports:
import pytest
from notifications_utils.recipients import (
InvalidEmailError,
InvalidPhoneError,
allowed_to_send_to,
format_phone_number_human_readable,
format_recipient,
get_international_phone_info,
international_phone_info,
is_uk_phone_number,
normalise_phone_number,
try_validate_and_format_phone_number,
validate_and_format_phone_number,
validate_email_address,
validate_phone_number,
)
and any relevant context from other files:
# Path: notifications_utils/recipients.py
# class RecipientCSV():
# class Row(InsensitiveDict):
# class Cell():
# class InvalidEmailError(Exception):
# class InvalidPhoneError(InvalidEmailError):
# class InvalidAddressError(InvalidEmailError):
# def __init__(
# self,
# file_data,
# template,
# max_errors_shown=20,
# max_initial_rows_shown=10,
# guestlist=None,
# remaining_messages=sys.maxsize,
# allow_international_sms=False,
# allow_international_letters=False,
# should_validate=True,
# ):
# def __len__(self):
# def __getitem__(self, requested_index):
# def guestlist(self):
# def guestlist(self, value):
# def template(self):
# def template(self, value):
# def placeholders(self):
# def placeholders(self, value):
# def has_errors(self):
# def allowed_to_send_to(self):
# def rows(self):
# def _rows(self):
# def get_rows(self):
# def more_rows_than_can_send(self):
# def too_many_rows(self):
# def initial_rows(self):
# def displayed_rows(self):
# def _filter_rows(self, attr):
# def rows_with_errors(self):
# def rows_with_bad_recipients(self):
# def rows_with_missing_data(self):
# def rows_with_message_too_long(self):
# def rows_with_empty_message(self):
# def initial_rows_with_errors(self):
# def _raw_column_headers(self):
# def column_headers(self):
# def column_headers_as_column_keys(self):
# def missing_column_headers(self):
# def duplicate_recipient_column_headers(self):
# def is_address_column(self, key):
# def count_of_required_recipient_columns(self):
# def has_recipient_columns(self):
# def _get_error_for_field(self, key, value): # noqa: C901
# def __init__(
# self,
# row_dict,
# *,
# index,
# error_fn,
# recipient_column_headers,
# placeholders,
# template,
# allow_international_letters,
# validate_row=True,
# ):
# def __getitem__(self, key):
# def get(self, key, default=None):
# def has_error(self):
# def has_bad_recipient(self):
# def has_bad_postal_address(self):
# def has_error_spanning_multiple_cells(self):
# def has_missing_data(self):
# def recipient(self):
# def as_postal_address(self):
# def personalisation(self):
# def recipient_and_personalisation(self):
# def __init__(
# self,
# key=None,
# value=None,
# error_fn=None,
# placeholders=None
# ):
# def __eq__(self, other):
# def recipient_error(self):
# def __init__(self, message=None):
# def normalise_phone_number(number):
# def is_uk_phone_number(number):
# def get_international_phone_info(number):
# def _is_a_crown_dependency_number(number):
# def get_international_prefix(number):
# def get_billable_units_for_prefix(prefix):
# def use_numeric_sender(number):
# def validate_uk_phone_number(number):
# def validate_phone_number(number, international=False):
# def try_validate_and_format_phone_number(number, international=None, log_msg=None):
# def validate_email_address(email_address): # noqa (C901 too complex)
# def format_email_address(email_address):
# def validate_and_format_email_address(email_address):
# def format_recipient(recipient):
# def format_phone_number_human_readable(phone_number):
# def allowed_to_send_to(recipient, allowlist):
# def insert_or_append_to_dict(dict_, key, value):
# CROWN_DEPENDENCY_RANGES = ['7781', '7839', '7911', '7509', '7797', '7937', '7700', '7829', '7624', '7524', '7924']
. Output only the next line. | )), |
Given the code snippet: <|code_start|> country_prefix='20', # Egypt
billable_units=3,
)),
('00201212341234', international_phone_info(
international=True,
crown_dependency=False,
country_prefix='20', # Egypt
billable_units=3,
)),
('1664000000000', international_phone_info(
international=True,
crown_dependency=False,
country_prefix='1664', # Montserrat
billable_units=1,
)),
('71234567890', international_phone_info(
international=True,
crown_dependency=False,
country_prefix='7', # Russia
billable_units=1,
)),
('1-202-555-0104', international_phone_info(
international=True,
crown_dependency=False,
country_prefix='1', # USA
billable_units=1,
)),
('+23051234567', international_phone_info(
international=True,
crown_dependency=False,
<|code_end|>
, generate the next line using the imports in this file:
import pytest
from notifications_utils.recipients import (
InvalidEmailError,
InvalidPhoneError,
allowed_to_send_to,
format_phone_number_human_readable,
format_recipient,
get_international_phone_info,
international_phone_info,
is_uk_phone_number,
normalise_phone_number,
try_validate_and_format_phone_number,
validate_and_format_phone_number,
validate_email_address,
validate_phone_number,
)
and context (functions, classes, or occasionally code) from other files:
# Path: notifications_utils/recipients.py
# class RecipientCSV():
# class Row(InsensitiveDict):
# class Cell():
# class InvalidEmailError(Exception):
# class InvalidPhoneError(InvalidEmailError):
# class InvalidAddressError(InvalidEmailError):
# def __init__(
# self,
# file_data,
# template,
# max_errors_shown=20,
# max_initial_rows_shown=10,
# guestlist=None,
# remaining_messages=sys.maxsize,
# allow_international_sms=False,
# allow_international_letters=False,
# should_validate=True,
# ):
# def __len__(self):
# def __getitem__(self, requested_index):
# def guestlist(self):
# def guestlist(self, value):
# def template(self):
# def template(self, value):
# def placeholders(self):
# def placeholders(self, value):
# def has_errors(self):
# def allowed_to_send_to(self):
# def rows(self):
# def _rows(self):
# def get_rows(self):
# def more_rows_than_can_send(self):
# def too_many_rows(self):
# def initial_rows(self):
# def displayed_rows(self):
# def _filter_rows(self, attr):
# def rows_with_errors(self):
# def rows_with_bad_recipients(self):
# def rows_with_missing_data(self):
# def rows_with_message_too_long(self):
# def rows_with_empty_message(self):
# def initial_rows_with_errors(self):
# def _raw_column_headers(self):
# def column_headers(self):
# def column_headers_as_column_keys(self):
# def missing_column_headers(self):
# def duplicate_recipient_column_headers(self):
# def is_address_column(self, key):
# def count_of_required_recipient_columns(self):
# def has_recipient_columns(self):
# def _get_error_for_field(self, key, value): # noqa: C901
# def __init__(
# self,
# row_dict,
# *,
# index,
# error_fn,
# recipient_column_headers,
# placeholders,
# template,
# allow_international_letters,
# validate_row=True,
# ):
# def __getitem__(self, key):
# def get(self, key, default=None):
# def has_error(self):
# def has_bad_recipient(self):
# def has_bad_postal_address(self):
# def has_error_spanning_multiple_cells(self):
# def has_missing_data(self):
# def recipient(self):
# def as_postal_address(self):
# def personalisation(self):
# def recipient_and_personalisation(self):
# def __init__(
# self,
# key=None,
# value=None,
# error_fn=None,
# placeholders=None
# ):
# def __eq__(self, other):
# def recipient_error(self):
# def __init__(self, message=None):
# def normalise_phone_number(number):
# def is_uk_phone_number(number):
# def get_international_phone_info(number):
# def _is_a_crown_dependency_number(number):
# def get_international_prefix(number):
# def get_billable_units_for_prefix(prefix):
# def use_numeric_sender(number):
# def validate_uk_phone_number(number):
# def validate_phone_number(number, international=False):
# def try_validate_and_format_phone_number(number, international=None, log_msg=None):
# def validate_email_address(email_address): # noqa (C901 too complex)
# def format_email_address(email_address):
# def validate_and_format_email_address(email_address):
# def format_recipient(recipient):
# def format_phone_number_human_readable(phone_number):
# def allowed_to_send_to(recipient, allowlist):
# def insert_or_append_to_dict(dict_, key, value):
# CROWN_DEPENDENCY_RANGES = ['7781', '7839', '7911', '7509', '7797', '7937', '7700', '7829', '7624', '7524', '7924']
. Output only the next line. | country_prefix='230', # Mauritius |
Next line prediction: <|code_start|> try:
validate_phone_number(phone_number, international=True)
except InvalidPhoneError:
pytest.fail('Unexpected InvalidPhoneError')
@pytest.mark.parametrize("phone_number", valid_uk_phone_numbers)
def test_valid_uk_phone_number_can_be_formatted_consistently(phone_number):
assert validate_and_format_phone_number(phone_number) == '447123456789'
@pytest.mark.parametrize("phone_number, expected_formatted", [
('71234567890', '71234567890'),
('1-202-555-0104', '12025550104'),
('+12025550104', '12025550104'),
('0012025550104', '12025550104'),
('+0012025550104', '12025550104'),
('23051234567', '23051234567'),
])
def test_valid_international_phone_number_can_be_formatted_consistently(phone_number, expected_formatted):
assert validate_and_format_phone_number(
phone_number, international=True
) == expected_formatted
@pytest.mark.parametrize("phone_number, error_message", invalid_uk_phone_numbers)
@pytest.mark.parametrize("extra_args", [
{},
{'international': False},
])
<|code_end|>
. Use current file imports:
(import pytest
from notifications_utils.recipients import (
InvalidEmailError,
InvalidPhoneError,
allowed_to_send_to,
format_phone_number_human_readable,
format_recipient,
get_international_phone_info,
international_phone_info,
is_uk_phone_number,
normalise_phone_number,
try_validate_and_format_phone_number,
validate_and_format_phone_number,
validate_email_address,
validate_phone_number,
))
and context including class names, function names, or small code snippets from other files:
# Path: notifications_utils/recipients.py
# class RecipientCSV():
# class Row(InsensitiveDict):
# class Cell():
# class InvalidEmailError(Exception):
# class InvalidPhoneError(InvalidEmailError):
# class InvalidAddressError(InvalidEmailError):
# def __init__(
# self,
# file_data,
# template,
# max_errors_shown=20,
# max_initial_rows_shown=10,
# guestlist=None,
# remaining_messages=sys.maxsize,
# allow_international_sms=False,
# allow_international_letters=False,
# should_validate=True,
# ):
# def __len__(self):
# def __getitem__(self, requested_index):
# def guestlist(self):
# def guestlist(self, value):
# def template(self):
# def template(self, value):
# def placeholders(self):
# def placeholders(self, value):
# def has_errors(self):
# def allowed_to_send_to(self):
# def rows(self):
# def _rows(self):
# def get_rows(self):
# def more_rows_than_can_send(self):
# def too_many_rows(self):
# def initial_rows(self):
# def displayed_rows(self):
# def _filter_rows(self, attr):
# def rows_with_errors(self):
# def rows_with_bad_recipients(self):
# def rows_with_missing_data(self):
# def rows_with_message_too_long(self):
# def rows_with_empty_message(self):
# def initial_rows_with_errors(self):
# def _raw_column_headers(self):
# def column_headers(self):
# def column_headers_as_column_keys(self):
# def missing_column_headers(self):
# def duplicate_recipient_column_headers(self):
# def is_address_column(self, key):
# def count_of_required_recipient_columns(self):
# def has_recipient_columns(self):
# def _get_error_for_field(self, key, value): # noqa: C901
# def __init__(
# self,
# row_dict,
# *,
# index,
# error_fn,
# recipient_column_headers,
# placeholders,
# template,
# allow_international_letters,
# validate_row=True,
# ):
# def __getitem__(self, key):
# def get(self, key, default=None):
# def has_error(self):
# def has_bad_recipient(self):
# def has_bad_postal_address(self):
# def has_error_spanning_multiple_cells(self):
# def has_missing_data(self):
# def recipient(self):
# def as_postal_address(self):
# def personalisation(self):
# def recipient_and_personalisation(self):
# def __init__(
# self,
# key=None,
# value=None,
# error_fn=None,
# placeholders=None
# ):
# def __eq__(self, other):
# def recipient_error(self):
# def __init__(self, message=None):
# def normalise_phone_number(number):
# def is_uk_phone_number(number):
# def get_international_phone_info(number):
# def _is_a_crown_dependency_number(number):
# def get_international_prefix(number):
# def get_billable_units_for_prefix(prefix):
# def use_numeric_sender(number):
# def validate_uk_phone_number(number):
# def validate_phone_number(number, international=False):
# def try_validate_and_format_phone_number(number, international=None, log_msg=None):
# def validate_email_address(email_address): # noqa (C901 too complex)
# def format_email_address(email_address):
# def validate_and_format_email_address(email_address):
# def format_recipient(recipient):
# def format_phone_number_human_readable(phone_number):
# def allowed_to_send_to(recipient, allowlist):
# def insert_or_append_to_dict(dict_, key, value):
# CROWN_DEPENDENCY_RANGES = ['7781', '7839', '7911', '7509', '7797', '7937', '7700', '7829', '7624', '7524', '7924']
. Output only the next line. | def test_phone_number_rejects_invalid_values(extra_args, phone_number, error_message): |
Given the following code snippet before the placeholder: <|code_start|> 'pound-sign-in-local£@domain.com',
'local-with-’-apostrophe@domain.com',
'local-with-”-quotes@domain.com',
'domain-starts-with-a-dot@.domain.com',
'brackets(in)local@domain.com',
'email-too-long-{}@example.com'.format('a' * 320),
'incorrect-punycode@xn---something.com'
)
@pytest.mark.parametrize("phone_number", valid_international_phone_numbers)
def test_detect_international_phone_numbers(phone_number):
assert is_uk_phone_number(phone_number) is False
@pytest.mark.parametrize("phone_number", valid_uk_phone_numbers)
def test_detect_uk_phone_numbers(phone_number):
assert is_uk_phone_number(phone_number) is True
@pytest.mark.parametrize("phone_number, expected_info", [
('07900900123', international_phone_info(
international=False,
crown_dependency=False,
country_prefix='44', # UK
billable_units=1,
)),
('07700900123', international_phone_info(
international=False,
crown_dependency=False,
<|code_end|>
, predict the next line using imports from the current file:
import pytest
from notifications_utils.recipients import (
InvalidEmailError,
InvalidPhoneError,
allowed_to_send_to,
format_phone_number_human_readable,
format_recipient,
get_international_phone_info,
international_phone_info,
is_uk_phone_number,
normalise_phone_number,
try_validate_and_format_phone_number,
validate_and_format_phone_number,
validate_email_address,
validate_phone_number,
)
and context including class names, function names, and sometimes code from other files:
# Path: notifications_utils/recipients.py
# class RecipientCSV():
# class Row(InsensitiveDict):
# class Cell():
# class InvalidEmailError(Exception):
# class InvalidPhoneError(InvalidEmailError):
# class InvalidAddressError(InvalidEmailError):
# def __init__(
# self,
# file_data,
# template,
# max_errors_shown=20,
# max_initial_rows_shown=10,
# guestlist=None,
# remaining_messages=sys.maxsize,
# allow_international_sms=False,
# allow_international_letters=False,
# should_validate=True,
# ):
# def __len__(self):
# def __getitem__(self, requested_index):
# def guestlist(self):
# def guestlist(self, value):
# def template(self):
# def template(self, value):
# def placeholders(self):
# def placeholders(self, value):
# def has_errors(self):
# def allowed_to_send_to(self):
# def rows(self):
# def _rows(self):
# def get_rows(self):
# def more_rows_than_can_send(self):
# def too_many_rows(self):
# def initial_rows(self):
# def displayed_rows(self):
# def _filter_rows(self, attr):
# def rows_with_errors(self):
# def rows_with_bad_recipients(self):
# def rows_with_missing_data(self):
# def rows_with_message_too_long(self):
# def rows_with_empty_message(self):
# def initial_rows_with_errors(self):
# def _raw_column_headers(self):
# def column_headers(self):
# def column_headers_as_column_keys(self):
# def missing_column_headers(self):
# def duplicate_recipient_column_headers(self):
# def is_address_column(self, key):
# def count_of_required_recipient_columns(self):
# def has_recipient_columns(self):
# def _get_error_for_field(self, key, value): # noqa: C901
# def __init__(
# self,
# row_dict,
# *,
# index,
# error_fn,
# recipient_column_headers,
# placeholders,
# template,
# allow_international_letters,
# validate_row=True,
# ):
# def __getitem__(self, key):
# def get(self, key, default=None):
# def has_error(self):
# def has_bad_recipient(self):
# def has_bad_postal_address(self):
# def has_error_spanning_multiple_cells(self):
# def has_missing_data(self):
# def recipient(self):
# def as_postal_address(self):
# def personalisation(self):
# def recipient_and_personalisation(self):
# def __init__(
# self,
# key=None,
# value=None,
# error_fn=None,
# placeholders=None
# ):
# def __eq__(self, other):
# def recipient_error(self):
# def __init__(self, message=None):
# def normalise_phone_number(number):
# def is_uk_phone_number(number):
# def get_international_phone_info(number):
# def _is_a_crown_dependency_number(number):
# def get_international_prefix(number):
# def get_billable_units_for_prefix(prefix):
# def use_numeric_sender(number):
# def validate_uk_phone_number(number):
# def validate_phone_number(number, international=False):
# def try_validate_and_format_phone_number(number, international=None, log_msg=None):
# def validate_email_address(email_address): # noqa (C901 too complex)
# def format_email_address(email_address):
# def validate_and_format_email_address(email_address):
# def format_recipient(recipient):
# def format_phone_number_human_readable(phone_number):
# def allowed_to_send_to(recipient, allowlist):
# def insert_or_append_to_dict(dict_, key, value):
# CROWN_DEPENDENCY_RANGES = ['7781', '7839', '7911', '7509', '7797', '7937', '7700', '7829', '7624', '7524', '7924']
. Output only the next line. | country_prefix='44', # Number in TV range |
Predict the next line for this snippet: <|code_start|>
def generate_token(payload, secret, salt):
return url_encode_full_stops(
URLSafeTimedSerializer(secret).dumps(payload, salt)
)
def check_token(token, secret, salt, max_age_seconds):
ser = URLSafeTimedSerializer(secret)
payload = ser.loads(token, max_age=max_age_seconds,
salt=salt)
<|code_end|>
with the help of current file imports:
from itsdangerous import URLSafeTimedSerializer
from notifications_utils.formatters import url_encode_full_stops
and context from other files:
# Path: notifications_utils/formatters.py
# def url_encode_full_stops(value):
# return value.replace('.', '%2E')
, which may contain function names, class names, or code. Output only the next line. | return payload |
Based on the snippet: <|code_start|> enabled_statsd_client.statsd_client.timing.assert_called_with('test.notifications.api.key', 1000, 1)
def test_should_call_timing_with_params_if_enabled(enabled_statsd_client):
enabled_statsd_client.timing('key', 1, 99)
enabled_statsd_client.statsd_client.timing.assert_called_with('test.notifications.api.key', 1000, 99)
def test_should_not_call_timing_from_dates_method_if_not_enabled(disabled_statsd_client):
disabled_statsd_client.timing_with_dates('key', datetime.utcnow(), datetime.utcnow())
disabled_statsd_client.statsd_client.timing.assert_not_called()
def test_should_call_timing_from_dates_method_if_enabled(enabled_statsd_client):
now = datetime.utcnow()
enabled_statsd_client.timing_with_dates('key', now + timedelta(seconds=3), now)
enabled_statsd_client.statsd_client.timing.assert_called_with('test.notifications.api.key', 3000, 1)
def test_should_call_timing_from_dates_method_with_params_if_enabled(enabled_statsd_client):
now = datetime.utcnow()
enabled_statsd_client.timing_with_dates('key', now + timedelta(seconds=3), now, 99)
enabled_statsd_client.statsd_client.timing.assert_called_with('test.notifications.api.key', 3000, 99)
def test_should_not_call_gauge_if_not_enabled(disabled_statsd_client):
disabled_statsd_client.gauge('key', 10)
disabled_statsd_client.statsd_client.gauge.assert_not_called()
<|code_end|>
, predict the immediate next line with the help of imports:
from datetime import datetime, timedelta
from unittest.mock import Mock, patch
from notifications_utils.clients.statsd.statsd_client import (
NotifyStatsClient,
StatsdClient,
)
import pytest
and context (classes, functions, sometimes code) from other files:
# Path: notifications_utils/clients/statsd/statsd_client.py
# class NotifyStatsClient(StatsClientBase):
# def __init__(self, host, port, prefix):
# self._host = host
# self._port = port
# self._prefix = prefix
# self._sock = socket(AF_INET, SOCK_DGRAM)
#
# def _resolve(self, addr):
# return gethostbyname(addr)
#
# @cachetools.func.ttl_cache(maxsize=2, ttl=15, timer=time_monotonic_with_jitter)
# def _cached_host(self):
# try:
# return self._resolve(self._host)
# except Exception as e:
# # if we get an error store None in the cache so that we don't keep trying to retrieve the DNS
# # if paas's dns server is having issues
# current_app.logger.warning('Error resolving statsd dns: {}'.format(str(e)))
# return None
#
# def _send(self, data):
# try:
# host = self._cached_host()
#
# # if we can't resolve DNS then host is none - just skip sending stats for next 15 secs
# if host:
# self._sock.sendto(data.encode('ascii'), (host, self._port))
# except Exception as e:
# current_app.logger.warning('Error sending statsd metric: {}'.format(str(e)))
# pass
#
# class StatsdClient():
# def __init__(self):
# self.statsd_client = None
#
# def init_app(self, app, *args, **kwargs):
# app.statsd_client = self
# self.active = app.config.get('STATSD_ENABLED')
# self.namespace = "{}.notifications.{}.".format(
# app.config.get('NOTIFY_ENVIRONMENT'),
# app.config.get('NOTIFY_APP_NAME')
# )
#
# if self.active:
# self.statsd_client = NotifyStatsClient(
# app.config.get('STATSD_HOST'),
# app.config.get('STATSD_PORT'),
# prefix=app.config.get('STATSD_PREFIX')
# )
#
# def format_stat_name(self, stat):
# return self.namespace + stat
#
# def incr(self, stat, count=1, rate=1):
# if self.active:
# self.statsd_client.incr(self.format_stat_name(stat), count, rate)
#
# def gauge(self, stat, count):
# if self.active:
# self.statsd_client.gauge(self.format_stat_name(stat), count)
#
# def timing(self, stat, delta, rate=1):
# # delta should be in seconds
# if self.active:
# self.statsd_client.timing(self.format_stat_name(stat), delta * 1000, rate)
#
# def timing_with_dates(self, stat, start, end, rate=1):
# if self.active:
# delta = (start - end).total_seconds()
# self.statsd_client.timing(self.format_stat_name(stat), delta * 1000, rate)
. Output only the next line. | def test_should_call_gauge_if_enabled(enabled_statsd_client): |
Given the code snippet: <|code_start|>def test_should_not_call_incr_if_not_enabled(disabled_statsd_client):
disabled_statsd_client.incr('key')
disabled_statsd_client.statsd_client.incr.assert_not_called()
def test_should_call_incr_if_enabled(enabled_statsd_client):
enabled_statsd_client.incr('key')
enabled_statsd_client.statsd_client.incr.assert_called_with('test.notifications.api.key', 1, 1)
def test_should_call_incr_with_params_if_enabled(enabled_statsd_client):
enabled_statsd_client.incr('key', 10, 11)
enabled_statsd_client.statsd_client.incr.assert_called_with('test.notifications.api.key', 10, 11)
def test_should_not_call_timing_if_not_enabled(disabled_statsd_client):
disabled_statsd_client.timing('key', 1)
disabled_statsd_client.statsd_client.timing.assert_not_called()
def test_should_call_timing_if_enabled(enabled_statsd_client):
enabled_statsd_client.timing('key', 1)
enabled_statsd_client.statsd_client.timing.assert_called_with('test.notifications.api.key', 1000, 1)
def test_should_call_timing_with_params_if_enabled(enabled_statsd_client):
enabled_statsd_client.timing('key', 1, 99)
enabled_statsd_client.statsd_client.timing.assert_called_with('test.notifications.api.key', 1000, 99)
<|code_end|>
, generate the next line using the imports in this file:
from datetime import datetime, timedelta
from unittest.mock import Mock, patch
from notifications_utils.clients.statsd.statsd_client import (
NotifyStatsClient,
StatsdClient,
)
import pytest
and context (functions, classes, or occasionally code) from other files:
# Path: notifications_utils/clients/statsd/statsd_client.py
# class NotifyStatsClient(StatsClientBase):
# def __init__(self, host, port, prefix):
# self._host = host
# self._port = port
# self._prefix = prefix
# self._sock = socket(AF_INET, SOCK_DGRAM)
#
# def _resolve(self, addr):
# return gethostbyname(addr)
#
# @cachetools.func.ttl_cache(maxsize=2, ttl=15, timer=time_monotonic_with_jitter)
# def _cached_host(self):
# try:
# return self._resolve(self._host)
# except Exception as e:
# # if we get an error store None in the cache so that we don't keep trying to retrieve the DNS
# # if paas's dns server is having issues
# current_app.logger.warning('Error resolving statsd dns: {}'.format(str(e)))
# return None
#
# def _send(self, data):
# try:
# host = self._cached_host()
#
# # if we can't resolve DNS then host is none - just skip sending stats for next 15 secs
# if host:
# self._sock.sendto(data.encode('ascii'), (host, self._port))
# except Exception as e:
# current_app.logger.warning('Error sending statsd metric: {}'.format(str(e)))
# pass
#
# class StatsdClient():
# def __init__(self):
# self.statsd_client = None
#
# def init_app(self, app, *args, **kwargs):
# app.statsd_client = self
# self.active = app.config.get('STATSD_ENABLED')
# self.namespace = "{}.notifications.{}.".format(
# app.config.get('NOTIFY_ENVIRONMENT'),
# app.config.get('NOTIFY_APP_NAME')
# )
#
# if self.active:
# self.statsd_client = NotifyStatsClient(
# app.config.get('STATSD_HOST'),
# app.config.get('STATSD_PORT'),
# prefix=app.config.get('STATSD_PREFIX')
# )
#
# def format_stat_name(self, stat):
# return self.namespace + stat
#
# def incr(self, stat, count=1, rate=1):
# if self.active:
# self.statsd_client.incr(self.format_stat_name(stat), count, rate)
#
# def gauge(self, stat, count):
# if self.active:
# self.statsd_client.gauge(self.format_stat_name(stat), count)
#
# def timing(self, stat, delta, rate=1):
# # delta should be in seconds
# if self.active:
# self.statsd_client.timing(self.format_stat_name(stat), delta * 1000, rate)
#
# def timing_with_dates(self, stat, start, end, rate=1):
# if self.active:
# delta = (start - end).total_seconds()
# self.statsd_client.timing(self.format_stat_name(stat), delta * 1000, rate)
. Output only the next line. | def test_should_not_call_timing_from_dates_method_if_not_enabled(disabled_statsd_client): |
Predict the next line for this snippet: <|code_start|>
@pytest.mark.parametrize('body, expected', [
('((with-brackets))', 'with-brackets'),
('without-brackets', 'without-brackets'),
])
def test_placeholder_returns_name(body, expected):
assert Placeholder(body).name == expected
@pytest.mark.parametrize('body, is_conditional', [
('not a conditional', False),
('not? a conditional', False),
('a?? conditional', True),
])
def test_placeholder_identifies_conditional(body, is_conditional):
assert Placeholder(body).is_conditional() == is_conditional
@pytest.mark.parametrize('body, conditional_text', [
('a??b', 'b'),
('a?? b ', ' b '),
('a??b??c', 'b??c'),
])
<|code_end|>
with the help of current file imports:
import re
import pytest
from notifications_utils.field import Placeholder
and context from other files:
# Path: notifications_utils/field.py
# class Placeholder:
# def __init__(self, body):
# # body shouldn’t include leading/trailing brackets, like (( and ))
# self.body = body.lstrip('(').rstrip(')')
#
# @classmethod
# def from_match(cls, match):
# return cls(match.group(0))
#
# def is_conditional(self):
# return '??' in self.body
#
# @property
# def name(self):
# # for non conditionals, name equals body
# return self.body.split('??')[0]
#
# @property
# def conditional_text(self):
# if self.is_conditional():
# # ((a?? b??c)) returns " b??c"
# return '??'.join(self.body.split('??')[1:])
# else:
# raise ValueError('{} not conditional'.format(self))
#
# def get_conditional_body(self, show_conditional):
# # note: unsanitised/converted
# if self.is_conditional():
# return self.conditional_text if str2bool(show_conditional) else ''
# else:
# raise ValueError('{} not conditional'.format(self))
#
# def __repr__(self):
# return 'Placeholder({})'.format(self.body)
, which may contain function names, class names, or code. Output only the next line. | def test_placeholder_gets_conditional_text(body, conditional_text): |
Using the snippet: <|code_start|>
LETTER_PROCESSING_DEADLINE = time(17, 30)
CANCELLABLE_JOB_LETTER_STATUSES = [
'created', 'cancelled', 'virus-scan-failed', 'validation-failed', 'technical-failure', 'pending-virus-check'
]
non_working_days_dvla = BankHolidays(
use_cached_holidays=True,
weekend=(5, 6),
)
<|code_end|>
, determine the next line of code. You have imports:
from collections import namedtuple
from datetime import datetime, time, timedelta
from govuk_bank_holidays.bank_holidays import BankHolidays
from notifications_utils.countries.data import Postage
from notifications_utils.timezones import (
convert_utc_to_bst,
utc_string_to_aware_gmt_datetime,
)
import pytz
and context (class names, function names, or code) available:
# Path: notifications_utils/countries/data.py
# class Postage:
# UK = 'united-kingdom'
# FIRST = 'first'
# SECOND = 'second'
# EUROPE = 'europe'
# REST_OF_WORLD = 'rest-of-world'
#
# Path: notifications_utils/timezones.py
# def convert_utc_to_bst(utc_dt):
# """
# Takes a naive UTC datetime and returns a naive London datetime
# """
# return pytz.utc.localize(utc_dt).astimezone(local_timezone).replace(tzinfo=None)
#
# def utc_string_to_aware_gmt_datetime(date):
# """
# Date can either be a string, naive UTC datetime or an aware UTC datetime
# Returns an aware London datetime, essentially the time you'd see on your clock
# """
# if not isinstance(date, datetime):
# date = parser.parse(date)
#
# forced_utc = date.replace(tzinfo=pytz.utc)
# return forced_utc.astimezone(local_timezone)
. Output only the next line. | non_working_days_royal_mail = BankHolidays( |
Predict the next line after this snippet: <|code_start|>
LETTER_PROCESSING_DEADLINE = time(17, 30)
CANCELLABLE_JOB_LETTER_STATUSES = [
'created', 'cancelled', 'virus-scan-failed', 'validation-failed', 'technical-failure', 'pending-virus-check'
]
non_working_days_dvla = BankHolidays(
use_cached_holidays=True,
weekend=(5, 6),
)
non_working_days_royal_mail = BankHolidays(
use_cached_holidays=True,
weekend=(6,) # Only Sunday (day 6 of the week) is a non-working day
)
def set_gmt_hour(day, hour):
return day.astimezone(pytz.timezone('Europe/London')).replace(hour=hour, minute=0).astimezone(pytz.utc)
def get_next_work_day(date, non_working_days):
next_day = date + timedelta(days=1)
if non_working_days.is_work_day(
date=next_day.date(),
<|code_end|>
using the current file's imports:
from collections import namedtuple
from datetime import datetime, time, timedelta
from govuk_bank_holidays.bank_holidays import BankHolidays
from notifications_utils.countries.data import Postage
from notifications_utils.timezones import (
convert_utc_to_bst,
utc_string_to_aware_gmt_datetime,
)
import pytz
and any relevant context from other files:
# Path: notifications_utils/countries/data.py
# class Postage:
# UK = 'united-kingdom'
# FIRST = 'first'
# SECOND = 'second'
# EUROPE = 'europe'
# REST_OF_WORLD = 'rest-of-world'
#
# Path: notifications_utils/timezones.py
# def convert_utc_to_bst(utc_dt):
# """
# Takes a naive UTC datetime and returns a naive London datetime
# """
# return pytz.utc.localize(utc_dt).astimezone(local_timezone).replace(tzinfo=None)
#
# def utc_string_to_aware_gmt_datetime(date):
# """
# Date can either be a string, naive UTC datetime or an aware UTC datetime
# Returns an aware London datetime, essentially the time you'd see on your clock
# """
# if not isinstance(date, datetime):
# date = parser.parse(date)
#
# forced_utc = date.replace(tzinfo=pytz.utc)
# return forced_utc.astimezone(local_timezone)
. Output only the next line. | division=BankHolidays.ENGLAND_AND_WALES, |
Predict the next line for this snippet: <|code_start|>
LETTER_PROCESSING_DEADLINE = time(17, 30)
CANCELLABLE_JOB_LETTER_STATUSES = [
'created', 'cancelled', 'virus-scan-failed', 'validation-failed', 'technical-failure', 'pending-virus-check'
]
non_working_days_dvla = BankHolidays(
use_cached_holidays=True,
weekend=(5, 6),
)
<|code_end|>
with the help of current file imports:
from collections import namedtuple
from datetime import datetime, time, timedelta
from govuk_bank_holidays.bank_holidays import BankHolidays
from notifications_utils.countries.data import Postage
from notifications_utils.timezones import (
convert_utc_to_bst,
utc_string_to_aware_gmt_datetime,
)
import pytz
and context from other files:
# Path: notifications_utils/countries/data.py
# class Postage:
# UK = 'united-kingdom'
# FIRST = 'first'
# SECOND = 'second'
# EUROPE = 'europe'
# REST_OF_WORLD = 'rest-of-world'
#
# Path: notifications_utils/timezones.py
# def convert_utc_to_bst(utc_dt):
# """
# Takes a naive UTC datetime and returns a naive London datetime
# """
# return pytz.utc.localize(utc_dt).astimezone(local_timezone).replace(tzinfo=None)
#
# def utc_string_to_aware_gmt_datetime(date):
# """
# Date can either be a string, naive UTC datetime or an aware UTC datetime
# Returns an aware London datetime, essentially the time you'd see on your clock
# """
# if not isinstance(date, datetime):
# date = parser.parse(date)
#
# forced_utc = date.replace(tzinfo=pytz.utc)
# return forced_utc.astimezone(local_timezone)
, which may contain function names, class names, or code. Output only the next line. | non_working_days_royal_mail = BankHolidays( |
Predict the next line for this snippet: <|code_start|>
ESRI_GEOMETRY_PROPS = [RINGS, POINTS, PATHS, X, Y, Z]
ESRI_GEOMETRY_TYPES = [ESRI_POINT, ESRI_POLYGON, ESRI_MULTIPOINT, ESRI_ENVELOPE]
GEOMJSON_GEOMETRY_PROPS = [COORDINATES]
GEOJSON_GEOMETRY_TYPES = [GEOJSON_LINESTRING, GEOJSON_POINT, GEOJSON_MULTI_LINESTRING, GEOJSON_POLYGON, GEOJSON_MULTIPOLYGON, GEOJSON_MULTIPOINT]
EXTENT_PROPS = [XMIN, XMAX, YMIN, YMAX]
OID_ATTRIBUTES = [OBJECTID, 'objectid', FID]
GEOJSON_POLYGON_TYPES = [GEOJSON_POLYGON, GEOJSON_MULTIPOLYGON]
GEOJSON_LINE_TYPES = [GEOJSON_LINESTRING, GEOJSON_MULTI_LINESTRING]
GEOJSON_GEOMETRY_MAPPING = {
GEOJSON_POINT: ESRI_POINT,
<|code_end|>
with the help of current file imports:
import six
import numbers
from ._strings import *
from .rest_utils import FeatureCollection, FeatureSet
from munch import munchify
and context from other files:
# Path: restapi/rest_utils.py
# class FeatureCollection(FeatureSetBase):
# """Class that handles Geo JSON formatted Feature Set, known as a FeatureCollection."""
# _format = GEOJSON_FORMAT
#
# def __init__(self, in_json):
# """Inits class with JSON as geo feature set.
#
# Args:
# in_json: Input json response from request.
# """
#
# if isinstance(in_json, six.string_types):
# if not in_json.startswith('{') and os.path.isfile(in_json):
# with open(in_json, 'r') as f:
# in_json = json.load(f)
# else:
# in_json = json.loads(in_json)
# if isinstance(in_json, self.__class__):
# self.json = in_json.json
# elif isinstance(in_json, dict):
# self.json = munch.munchify(in_json)
#
#
# def extend(other):
# """Combines features from another FeatureSet with this one.
#
# Args:
# other: Other FeatureSet to combine with this one.
# """
#
# if not isinstance(other, FeatureCollection):
# other = FeatureCollection(other)
# otherCopy = copy.deepcopy(other)
#
# # get max oid
# oidF = getattr(self, OID_FIELD_NAME) if hasattr(self, OID_FIELD_NAME) else OBJECTID
# nextOID = max([ft.get(oidF, 0) for ft in iter(self)]) + 1
#
# if sorted(self.list_fields()) == sorted(other.list_fields()):
# for ft in otherCopy.features:
# if ft.get(oidF) < nextOID:
# ft.properties[oidF] = nextOID
# nextOID += 1
# self.features.extend(otherCopy.features)
#
# def getEmptyCopy(self):
# """Gets an empty copy of a feature set."""
# fsd = munch.Munch()
# for k,v in six.iteritems(self.json):
# if k != FEATURES:
# fsd[k] = v
# fsd[FEATURES] = []
# return FeatureCollection(fsd)
#
# class FeatureSet(FeatureSetBase):
# """Class that handles feature sets."""
# _format = ESRI_JSON_FORMAT
#
# def __init__(self, in_json):
# """Inits Class with input JSON for feature set.
#
# Args:
# in_json: Input json response from request.
#
# Raises:
# ValueError: 'Not a valid Feature Set!'
# """
#
# if isinstance(in_json, six.string_types):
# if not in_json.startswith('{') and os.path.isfile(in_json):
# with open(in_json, 'r') as f:
# in_json = json.load(f)
# else:
# in_json = json.loads(in_json)
# if isinstance(in_json, self.__class__):
# self.json = in_json.json
# elif isinstance(in_json, dict):
# self.json = munch.munchify(in_json)
# if not all(map(lambda k: k in self.json.keys(), [FIELDS, FEATURES])):
# # print(self.json.keys())
# raise ValueError('Not a valid Feature Set!')
#
# def extend(self, other):
# """Combines features from another FeatureSet with this one.
#
# Args:
# other: Other FeatureSet to combine with this one.
# """
# if not isinstance(other, FeatureSet):
# other = FeatureSet(other)
# otherCopy = copy.deepcopy(other)
#
# # get max oid
# oidF = getattr(self, OID_FIELD_NAME) if hasattr(self, OID_FIELD_NAME) else OBJECTID
# nextOID = max([ft.get(oidF, 0) for ft in iter(self)]) + 1
#
# if sorted(self.list_fields()) == sorted(other.list_fields()):
# for ft in otherCopy.features:
# if ft.get(oidF) < nextOID:
# ft.attributes[oidF] = nextOID
# nextOID += 1
# self.features.extend(otherCopy.features)
#
# def getEmptyCopy(self):
# """Gets an empty copy of a feature set."""
# fsd = munch.Munch()
# for k,v in six.iteritems(self.json):
# if k == FIELDS:
# fsd[k] = [f for f in self.fields if f and not f.name.lower().startswith('shape')]
# elif k != FEATURES:
# fsd[k] = v
# fsd[FEATURES] = []
# return FeatureSet(fsd)
, which may contain function names, class names, or code. Output only the next line. | GEOJSON_POLYGON: ESRI_POLYGON, |
Continue the code snippet: <|code_start|>
ESRI_GEOMETRY_PROPS = [RINGS, POINTS, PATHS, X, Y, Z]
ESRI_GEOMETRY_TYPES = [ESRI_POINT, ESRI_POLYGON, ESRI_MULTIPOINT, ESRI_ENVELOPE]
GEOMJSON_GEOMETRY_PROPS = [COORDINATES]
GEOJSON_GEOMETRY_TYPES = [GEOJSON_LINESTRING, GEOJSON_POINT, GEOJSON_MULTI_LINESTRING, GEOJSON_POLYGON, GEOJSON_MULTIPOLYGON, GEOJSON_MULTIPOINT]
EXTENT_PROPS = [XMIN, XMAX, YMIN, YMAX]
OID_ATTRIBUTES = [OBJECTID, 'objectid', FID]
GEOJSON_POLYGON_TYPES = [GEOJSON_POLYGON, GEOJSON_MULTIPOLYGON]
GEOJSON_LINE_TYPES = [GEOJSON_LINESTRING, GEOJSON_MULTI_LINESTRING]
GEOJSON_GEOMETRY_MAPPING = {
GEOJSON_POINT: ESRI_POINT,
GEOJSON_POLYGON: ESRI_POLYGON,
GEOJSON_MULTIPOLYGON: ESRI_POLYGON,
GEOJSON_LINESTRING: ESRI_POLYLINE,
GEOJSON_MULTI_LINESTRING: ESRI_POLYLINE,
<|code_end|>
. Use current file imports:
import six
import numbers
from ._strings import *
from .rest_utils import FeatureCollection, FeatureSet
from munch import munchify
and context (classes, functions, or code) from other files:
# Path: restapi/rest_utils.py
# class FeatureCollection(FeatureSetBase):
# """Class that handles Geo JSON formatted Feature Set, known as a FeatureCollection."""
# _format = GEOJSON_FORMAT
#
# def __init__(self, in_json):
# """Inits class with JSON as geo feature set.
#
# Args:
# in_json: Input json response from request.
# """
#
# if isinstance(in_json, six.string_types):
# if not in_json.startswith('{') and os.path.isfile(in_json):
# with open(in_json, 'r') as f:
# in_json = json.load(f)
# else:
# in_json = json.loads(in_json)
# if isinstance(in_json, self.__class__):
# self.json = in_json.json
# elif isinstance(in_json, dict):
# self.json = munch.munchify(in_json)
#
#
# def extend(other):
# """Combines features from another FeatureSet with this one.
#
# Args:
# other: Other FeatureSet to combine with this one.
# """
#
# if not isinstance(other, FeatureCollection):
# other = FeatureCollection(other)
# otherCopy = copy.deepcopy(other)
#
# # get max oid
# oidF = getattr(self, OID_FIELD_NAME) if hasattr(self, OID_FIELD_NAME) else OBJECTID
# nextOID = max([ft.get(oidF, 0) for ft in iter(self)]) + 1
#
# if sorted(self.list_fields()) == sorted(other.list_fields()):
# for ft in otherCopy.features:
# if ft.get(oidF) < nextOID:
# ft.properties[oidF] = nextOID
# nextOID += 1
# self.features.extend(otherCopy.features)
#
# def getEmptyCopy(self):
# """Gets an empty copy of a feature set."""
# fsd = munch.Munch()
# for k,v in six.iteritems(self.json):
# if k != FEATURES:
# fsd[k] = v
# fsd[FEATURES] = []
# return FeatureCollection(fsd)
#
# class FeatureSet(FeatureSetBase):
# """Class that handles feature sets."""
# _format = ESRI_JSON_FORMAT
#
# def __init__(self, in_json):
# """Inits Class with input JSON for feature set.
#
# Args:
# in_json: Input json response from request.
#
# Raises:
# ValueError: 'Not a valid Feature Set!'
# """
#
# if isinstance(in_json, six.string_types):
# if not in_json.startswith('{') and os.path.isfile(in_json):
# with open(in_json, 'r') as f:
# in_json = json.load(f)
# else:
# in_json = json.loads(in_json)
# if isinstance(in_json, self.__class__):
# self.json = in_json.json
# elif isinstance(in_json, dict):
# self.json = munch.munchify(in_json)
# if not all(map(lambda k: k in self.json.keys(), [FIELDS, FEATURES])):
# # print(self.json.keys())
# raise ValueError('Not a valid Feature Set!')
#
# def extend(self, other):
# """Combines features from another FeatureSet with this one.
#
# Args:
# other: Other FeatureSet to combine with this one.
# """
# if not isinstance(other, FeatureSet):
# other = FeatureSet(other)
# otherCopy = copy.deepcopy(other)
#
# # get max oid
# oidF = getattr(self, OID_FIELD_NAME) if hasattr(self, OID_FIELD_NAME) else OBJECTID
# nextOID = max([ft.get(oidF, 0) for ft in iter(self)]) + 1
#
# if sorted(self.list_fields()) == sorted(other.list_fields()):
# for ft in otherCopy.features:
# if ft.get(oidF) < nextOID:
# ft.attributes[oidF] = nextOID
# nextOID += 1
# self.features.extend(otherCopy.features)
#
# def getEmptyCopy(self):
# """Gets an empty copy of a feature set."""
# fsd = munch.Munch()
# for k,v in six.iteritems(self.json):
# if k == FIELDS:
# fsd[k] = [f for f in self.fields if f and not f.name.lower().startswith('shape')]
# elif k != FEATURES:
# fsd[k] = v
# fsd[FEATURES] = []
# return FeatureSet(fsd)
. Output only the next line. | GEOJSON_MULTIPOINT: ESRI_MULTIPOINT |
Using the snippet: <|code_start|># little grammar for test
class CSV(grammar.Grammar):
entry = "csv"
grammar = """
csv = [ [@ignore("null") line : l #add_line(_, l)]+ eof ]
line =
[
<|code_end|>
, determine the next line of code. You have imports:
from pyrser import grammar
and context (class names, function names, or code) available:
# Path: pyrser/grammar.py
# class MetaGrammar(parsing.MetaBasicParser):
# class Grammar(parsing.Parser, metaclass=MetaGrammar):
# def __new__(metacls, name, bases, namespace):
# def after_parse(self, node: parsing.Node) -> parsing.Node:
# def _do_parse(self, entry: str) -> parsing.Node:
# def parse(self, source: str=None, entry: str=None) -> parsing.Node:
# def parse_file(self, filename: str, entry: str=None) -> parsing.Node:
# def build_grammar(inherit: tuple, scope: dict) -> Grammar:
# def from_string(bnf: str, entry=None, *optional_inherit) -> Grammar:
# def from_file(fn: str, entry=None, *optional_inherit) -> Grammar:
. Output only the next line. | item : c #add_col(_, c) |
Predict the next line after this snippet: <|code_start|>
class TestCheckTypes(unittest.TestCase):
def test_it_calls_function_without_annotation_normally(self):
@meta.checktypes
def f(a):
return [1, 2, 3]
self.assertEqual([1, 2, 3], f(0))
def test_it_calls_function_with_non_type_annotation_normally(self):
@meta.checktypes
def f(a: (lambda x: 5 < x < 11)):
return [1, 2, 3]
self.assertEqual([1, 2, 3], f(0))
def test_it_calls_function_with_type_annotation_normally(self):
@meta.checktypes
def f(a: int, *args: int, b: str, **kwargs: str) -> [int]:
return [1, 2, 3]
self.assertEqual([1, 2, 3], f(0, 1, b='', c=''))
def test_it_raises_valueerror_for_incorrect_default_value_type(self):
with self.assertRaises(ValueError):
@meta.checktypes
def f(a: int='9'):
<|code_end|>
using the current file's imports:
import unittest
from unittest import mock
from pyrser import meta
and any relevant context from other files:
# Path: pyrser/meta.py
# def enum(*sequential, **named):
# def checktypes(func):
# def check_type(sig, arg_name, arg_type, arg_value):
# def wrapper(*args, **kwargs):
# def set_one(chainmap, thing_name, callobject):
# def _get_base_class(cls):
# def add_method(cls):
# def wrapper(f):
# def hook(cls, hookname=None, erase=False):
# def wrapper(f):
# def rule(cls, rulename=None, erase=False):
# def wrapper(f):
# def directive(directname=None):
# def wrapper(f):
# def decorator(directname=None):
# def wrapper(f):
. Output only the next line. | pass |
Predict the next line after this snippet: <|code_start|># This pass is for debug only
scalar = {'bool': bool, 'int': int, 'float': float, 'str': str}
composed = {'list': list, 'dict': dict, 'set': set}
@meta.add_method(node.Node)
<|code_end|>
using the current file's imports:
from pyrser import meta, fmt
from pyrser.parsing import node
import weakref
and any relevant context from other files:
# Path: pyrser/meta.py
# def enum(*sequential, **named):
# def checktypes(func):
# def check_type(sig, arg_name, arg_type, arg_value):
# def wrapper(*args, **kwargs):
# def set_one(chainmap, thing_name, callobject):
# def _get_base_class(cls):
# def add_method(cls):
# def wrapper(f):
# def hook(cls, hookname=None, erase=False):
# def wrapper(f):
# def rule(cls, rulename=None, erase=False):
# def wrapper(f):
# def directive(directname=None):
# def wrapper(f):
# def decorator(directname=None):
# def wrapper(f):
#
# Path: pyrser/fmt.py
# class indentable:
# class block(indentable):
# class sep(indentable):
# class end(indentable):
# class tab(indentable):
# def __init__(self):
# def to_str(self, res: str) -> str:
# def __str__(self):
# def lsdata(self) -> list:
# def set_indent(self, indent: int=1):
# def catend(dst: str, src: str, indent) -> str:
# def list_set_indent(lst: list, indent: int=1):
# def list_to_str(lst: list, content: str, indent: int=1):
# def __init__(self, beginby: str, endby: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, ch: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, ch: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, lsdata: indentable):
# def set_indent(self, indent: int=1):
# def to_str(self, res: str, parent_indent) -> str:
#
# Path: pyrser/parsing/node.py
# class Node(dict):
# class ListNodeItem:
# class ListNodeItemIterator:
# class DictNode(dict):
# class TupleNode(list):
# class ListNode:
# class ListNodeItem:
# class ListNodeItemIterator:
# def __bool__(self):
# def __repr__(self):
# def check(self, ndict: dict, info="") -> bool:
# def iscycle(thing, ndict: dict, info: str) -> bool:
# def recurs(thing, ndict: dict, info: str) -> bool:
# def clean(self):
# def set(self, othernode):
# def __init__(self, it: []=None):
# def append(self, d):
# def prepend(self, d):
# def __eq__(self, oth) -> bool:
# def __str__(self) -> str:
# def __repr__(self) -> str:
# def dump(self) -> str:
# def __len__(self) -> int:
# def __iter__(self) -> ListNodeItemIterator:
# def __reversed__(self) -> ListNodeItemIterator:
# def _trueindex(self, k) -> int:
# def _cache(self) -> str:
# def _update(self):
# def index(self, data) -> int:
# def count(self, data) -> int:
# def get(self, k) -> ListNodeItem:
# def __getitem__(self, k) -> object:
# def __setitem__(self, k, d):
# def __delitem__(self, k):
# def __init__(self, data):
# def __str__(self) -> str:
# def __repr__(self) -> str:
# def dump(self) -> str:
# def index(self, v) -> int:
# def count(self, v) -> int:
# def _get_slice(self, sl) -> [object]:
# def __getitem__(self, k) -> object:
# def __setitem__(self, k, d):
# def __delitem__(self, k):
# def popitem(self) -> object:
# def append(self, data) -> ListNodeItem:
# def prepend(self, data) -> ListNodeItem:
# def values(self):
# def rvalues(self):
# def _fwd(self):
# def _bwd(self):
# def __init__(self, current: ListNodeItem, reverse=False):
# def __iter__(self):
# def __next__(self):
# def normalize(ast: Node) -> Node:
. Output only the next line. | def to_yml(self): |
Predict the next line for this snippet: <|code_start|>
current_file = os.path.abspath(__file__)
class InternalError_Test(unittest.TestCase):
def test_locationinfo_01(self):
li = LocationInfo(current_file, 1, 8)
s = li.get_content()
#print("#####\n%s\n######" % s)
self.assertEqual(s,
("from {f} at line:1 col:8 :\n".format(f=current_file)
+ "import unittest\n%s^" % (' ' * 7)),
"Bad LocationInfo.get_content")
li = LocationInfo(current_file, 1, 8, 8)
s = li.get_content()
self.assertEqual(s,
("from {f} at line:1 col:8 :\n".format(f=current_file)
<|code_end|>
with the help of current file imports:
import unittest
import os
from pyrser.error import *
from pyrser.parsing import *
from pyrser.passes.to_yml import *
from pyrser import meta, error
from pyrser.grammar import Grammar
from pyrser.hooks.predicate import pred_false
and context from other files:
# Path: pyrser/meta.py
# def enum(*sequential, **named):
# def checktypes(func):
# def check_type(sig, arg_name, arg_type, arg_value):
# def wrapper(*args, **kwargs):
# def set_one(chainmap, thing_name, callobject):
# def _get_base_class(cls):
# def add_method(cls):
# def wrapper(f):
# def hook(cls, hookname=None, erase=False):
# def wrapper(f):
# def rule(cls, rulename=None, erase=False):
# def wrapper(f):
# def directive(directname=None):
# def wrapper(f):
# def decorator(directname=None):
# def wrapper(f):
#
# Path: pyrser/error.py
# class LocationInfo:
# class Notification:
# class Diagnostic(Exception):
# def __init__(self, filepath: str, line: int, col: int, size: int=1):
# def from_stream(stream: 'Stream', is_error=False) -> 'LocationInfo':
# def from_maxstream(stream: 'Stream', is_error=False) -> 'LocationInfo':
# def from_here(pos=1):
# def get_content(self) -> str:
# def __init__(self, severity: Severity, msg: str,
# location: LocationInfo=None, details: str=None):
# def get_content(self, with_locinfos=False, with_details=False) -> str:
# def __init__(self):
# def __bool__(self):
# def __str__(self) -> str:
# def notify(self, severity: Severity, msg: str,
# location: LocationInfo=None, details: str=None) -> int:
# def add(self, n: Notification) -> int:
# def get_content(self, with_locinfos=True, with_details=False) -> str:
# def get_infos(self) -> {Severity, int}:
# def have_errors(self) -> bool:
#
# Path: pyrser/grammar.py
# class Grammar(parsing.Parser, metaclass=MetaGrammar):
# """
# Base class for all grammars.
#
# This class turn any class A that inherit it into a grammar.
# Taking the description of the grammar in parameter it will add
# all what is what is needed for A to parse it.
# """
# # Text grammar to generate parsing rules for this class.
# grammar = None
# # Name of the default rule to parse the grammar.
# entry = None
# # DSL parsing class
# dsl_parser = dsl.EBNF
#
# def after_parse(self, node: parsing.Node) -> parsing.Node:
# """
# If you want to do some stuff after parsing, overload this...
# """
# return node
#
# def _do_parse(self, entry: str) -> parsing.Node:
# if self.nstream == 0:
# raise ValueError("No opened stream for reading."
# + " Check if you provide something "
# + "to read for method parse()"
# + " or a correct file for method parse_file()"
# )
# res = None
# self.diagnostic = error.Diagnostic()
# try:
# res = self.eval_rule(entry)
# except error.Diagnostic as d:
# # User put an error rule
# d.notify(
# error.Severity.ERROR,
# "Exception during the evaluation of '%s'" % self._lastRule,
# error.LocationInfo.from_stream(
# self._stream,
# is_error=self.from_string
# )
# )
# self.diagnostic = d
# if not res:
# # we fail to parse, but error is not set on the last rule
# self.diagnostic.notify(
# error.Severity.ERROR,
# "Parse error in '%s'" % self._lastRule,
# error.LocationInfo.from_maxstream(
# self._stream,
# is_error=self.from_string
# )
# )
# if self.raise_diagnostic:
# raise self.diagnostic
# else:
# return self
# # clear contexted variables
# self.rule_nodes.clear()
# # create a new Diagnostic object for the node result
# res.diagnostic = error.Diagnostic()
# # all is ok
# return self.after_parse(res)
#
# def parse(self, source: str=None, entry: str=None) -> parsing.Node:
# """Parse source using the grammar"""
# self.from_string = True
# if source is not None:
# self.parsed_stream(source)
# if entry is None:
# entry = self.entry
# if entry is None:
# raise ValueError("No entry rule name defined for {}".format(
# self.__class__.__name__))
# return self._do_parse(entry)
#
# def parse_file(self, filename: str, entry: str=None) -> parsing.Node:
# """Parse filename using the grammar"""
# self.from_string = False
# import os.path
# with open(filename, 'r') as f:
# self.parsed_stream(f.read(), os.path.abspath(filename))
# if entry is None:
# entry = self.entry
# if entry is None:
# raise ValueError("No entry rule name defined for {}".format(
# self.__class__.__name__))
# return self._do_parse(entry)
#
# Path: pyrser/hooks/predicate.py
# @meta.hook(BasicParser, "false")
# def pred_false(self):
# """
# False in parser. Go to alternative...
#
# example::
#
# R = [
# #false | R2
# ]
#
# """
# return False
, which may contain function names, class names, or code. Output only the next line. | + "import unittest\n%s~~~~~~~~" % (' ' * 7)), |
Based on the snippet: <|code_start|>
#### For debug
def to_png(fpng, cnt):
fdot = fpng + ".dot"
with open(fdot, "w") as f:
f.write(str(cnt))
sp.run(["dot", "-Tpng", "-o", fpng, fdot])
### Type Expr component
class TypeExprComponent(list):
contains = None
minarity = None
def __init__(self, *deflist):
if self.minarity is not None and len(deflist) < self.minarity:
raise TypeError("%s take minimum %d parameters" % (type(self).__name__, self.minarity))
for t in deflist:
<|code_end|>
, predict the immediate next line with the help of imports:
import unittest
import sys
import subprocess as sp
from weakref import ref
from copy import *
from itertools import product
from pyrser import meta
from pyrser.passes import to_yml
from pyrser.parsing import node
from tests.grammar.tl4t import *
from collections import ChainMap
and context (classes, functions, sometimes code) from other files:
# Path: pyrser/meta.py
# def enum(*sequential, **named):
# def checktypes(func):
# def check_type(sig, arg_name, arg_type, arg_value):
# def wrapper(*args, **kwargs):
# def set_one(chainmap, thing_name, callobject):
# def _get_base_class(cls):
# def add_method(cls):
# def wrapper(f):
# def hook(cls, hookname=None, erase=False):
# def wrapper(f):
# def rule(cls, rulename=None, erase=False):
# def wrapper(f):
# def directive(directname=None):
# def wrapper(f):
# def decorator(directname=None):
# def wrapper(f):
#
# Path: pyrser/passes/to_yml.py
# @meta.add_method(node.Node)
# def to_yml(self):
# """
# Allow to get the YML string representation of a Node.::
#
# from pyrser.passes import to_yml
#
# t = Node()
# ...
# print(str(t.to_yml()))
# """
# pp = fmt.tab([])
# to_yml_item(self, pp.lsdata, "")
# return str(pp)
#
# Path: pyrser/parsing/node.py
# class Node(dict):
# class ListNodeItem:
# class ListNodeItemIterator:
# class DictNode(dict):
# class TupleNode(list):
# class ListNode:
# class ListNodeItem:
# class ListNodeItemIterator:
# def __bool__(self):
# def __repr__(self):
# def check(self, ndict: dict, info="") -> bool:
# def iscycle(thing, ndict: dict, info: str) -> bool:
# def recurs(thing, ndict: dict, info: str) -> bool:
# def clean(self):
# def set(self, othernode):
# def __init__(self, it: []=None):
# def append(self, d):
# def prepend(self, d):
# def __eq__(self, oth) -> bool:
# def __str__(self) -> str:
# def __repr__(self) -> str:
# def dump(self) -> str:
# def __len__(self) -> int:
# def __iter__(self) -> ListNodeItemIterator:
# def __reversed__(self) -> ListNodeItemIterator:
# def _trueindex(self, k) -> int:
# def _cache(self) -> str:
# def _update(self):
# def index(self, data) -> int:
# def count(self, data) -> int:
# def get(self, k) -> ListNodeItem:
# def __getitem__(self, k) -> object:
# def __setitem__(self, k, d):
# def __delitem__(self, k):
# def __init__(self, data):
# def __str__(self) -> str:
# def __repr__(self) -> str:
# def dump(self) -> str:
# def index(self, v) -> int:
# def count(self, v) -> int:
# def _get_slice(self, sl) -> [object]:
# def __getitem__(self, k) -> object:
# def __setitem__(self, k, d):
# def __delitem__(self, k):
# def popitem(self) -> object:
# def append(self, data) -> ListNodeItem:
# def prepend(self, data) -> ListNodeItem:
# def values(self):
# def rvalues(self):
# def _fwd(self):
# def _bwd(self):
# def __init__(self, current: ListNodeItem, reverse=False):
# def __iter__(self):
# def __next__(self):
# def normalize(ast: Node) -> Node:
. Output only the next line. | if self.contains is not None and type(t).__name__ not in self.contains: |
Given the code snippet: <|code_start|> sp.run(["dot", "-Tpng", "-o", fpng, fdot])
### Type Expr component
class TypeExprComponent(list):
contains = None
minarity = None
def __init__(self, *deflist):
if self.minarity is not None and len(deflist) < self.minarity:
raise TypeError("%s take minimum %d parameters" % (type(self).__name__, self.minarity))
for t in deflist:
if self.contains is not None and type(t).__name__ not in self.contains:
raise TypeError("%s can't be put in %s" % (type(t), type(self)))
list.__init__(self, deflist)
@property
def reprlist(self):
r = []
for it in self:
t = str(it)
if isinstance(it, list) and type(self) is not Overload and len(it) > 1:
t = '(' + t + ')'
r.append(t)
return r
def __repr__(self) -> str:
return str(self)
class Define:
def __init__(self, name: str, type_def: TypeExprComponent):
<|code_end|>
, generate the next line using the imports in this file:
import unittest
import sys
import subprocess as sp
from weakref import ref
from copy import *
from itertools import product
from pyrser import meta
from pyrser.passes import to_yml
from pyrser.parsing import node
from tests.grammar.tl4t import *
from collections import ChainMap
and context (functions, classes, or occasionally code) from other files:
# Path: pyrser/meta.py
# def enum(*sequential, **named):
# def checktypes(func):
# def check_type(sig, arg_name, arg_type, arg_value):
# def wrapper(*args, **kwargs):
# def set_one(chainmap, thing_name, callobject):
# def _get_base_class(cls):
# def add_method(cls):
# def wrapper(f):
# def hook(cls, hookname=None, erase=False):
# def wrapper(f):
# def rule(cls, rulename=None, erase=False):
# def wrapper(f):
# def directive(directname=None):
# def wrapper(f):
# def decorator(directname=None):
# def wrapper(f):
#
# Path: pyrser/passes/to_yml.py
# @meta.add_method(node.Node)
# def to_yml(self):
# """
# Allow to get the YML string representation of a Node.::
#
# from pyrser.passes import to_yml
#
# t = Node()
# ...
# print(str(t.to_yml()))
# """
# pp = fmt.tab([])
# to_yml_item(self, pp.lsdata, "")
# return str(pp)
#
# Path: pyrser/parsing/node.py
# class Node(dict):
# class ListNodeItem:
# class ListNodeItemIterator:
# class DictNode(dict):
# class TupleNode(list):
# class ListNode:
# class ListNodeItem:
# class ListNodeItemIterator:
# def __bool__(self):
# def __repr__(self):
# def check(self, ndict: dict, info="") -> bool:
# def iscycle(thing, ndict: dict, info: str) -> bool:
# def recurs(thing, ndict: dict, info: str) -> bool:
# def clean(self):
# def set(self, othernode):
# def __init__(self, it: []=None):
# def append(self, d):
# def prepend(self, d):
# def __eq__(self, oth) -> bool:
# def __str__(self) -> str:
# def __repr__(self) -> str:
# def dump(self) -> str:
# def __len__(self) -> int:
# def __iter__(self) -> ListNodeItemIterator:
# def __reversed__(self) -> ListNodeItemIterator:
# def _trueindex(self, k) -> int:
# def _cache(self) -> str:
# def _update(self):
# def index(self, data) -> int:
# def count(self, data) -> int:
# def get(self, k) -> ListNodeItem:
# def __getitem__(self, k) -> object:
# def __setitem__(self, k, d):
# def __delitem__(self, k):
# def __init__(self, data):
# def __str__(self) -> str:
# def __repr__(self) -> str:
# def dump(self) -> str:
# def index(self, v) -> int:
# def count(self, v) -> int:
# def _get_slice(self, sl) -> [object]:
# def __getitem__(self, k) -> object:
# def __setitem__(self, k, d):
# def __delitem__(self, k):
# def popitem(self) -> object:
# def append(self, data) -> ListNodeItem:
# def prepend(self, data) -> ListNodeItem:
# def values(self):
# def rvalues(self):
# def _fwd(self):
# def _bwd(self):
# def __init__(self, current: ListNodeItem, reverse=False):
# def __iter__(self):
# def __next__(self):
# def normalize(ast: Node) -> Node:
. Output only the next line. | self.name = name |
Given the following code snippet before the placeholder: <|code_start|>
def add(self, d1, d2):
class D(dict):
pass
d = D()
d.wref1 = ref(d1)
d.wref2 = ref(d2)
self.diff.append(d)
class ComponentTypeName:
pass
class ComponentTypeName:
empty = TypeName()
def __init__(self):
self.__name = None
self.__params = []
self.__subcomponent = None
def __sub__(self, other: ComponentTypeName) -> DeltaComponentTypeName:
res = DeltaComponentTypeName()
s1 = self.__name
s2 = other._ComponentTypeName__name
if s1 != s2:
res.add(s1, s2)
l1 = len(self.__params)
<|code_end|>
, predict the next line using imports from the current file:
from weakref import *
from pyrser import fmt
from pyrser.grammar import *
and context including class names, function names, and sometimes code from other files:
# Path: pyrser/fmt.py
# class indentable:
# class block(indentable):
# class sep(indentable):
# class end(indentable):
# class tab(indentable):
# def __init__(self):
# def to_str(self, res: str) -> str:
# def __str__(self):
# def lsdata(self) -> list:
# def set_indent(self, indent: int=1):
# def catend(dst: str, src: str, indent) -> str:
# def list_set_indent(lst: list, indent: int=1):
# def list_to_str(lst: list, content: str, indent: int=1):
# def __init__(self, beginby: str, endby: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, ch: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, ch: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, lsdata: indentable):
# def set_indent(self, indent: int=1):
# def to_str(self, res: str, parent_indent) -> str:
. Output only the next line. | l2 = len(other._ComponentTypeName__params) |
Continue the code snippet: <|code_start|># error handling
Severity = meta.enum('INFO', 'WARNING', 'ERROR')
class LocationInfo:
def __init__(self, filepath: str, line: int, col: int, size: int=1):
self.filepath = filepath
self.line = line
self.col = col
self.size = size
@staticmethod
def from_stream(stream: 'Stream', is_error=False) -> 'LocationInfo':
if stream._name is None and is_error is True:
(fh, stream._name) = tempfile.mkstemp()
tmpf = os.fdopen(fh, 'w')
tmpf.write(stream._content)
tmpf.close()
atexit.register(os.remove, stream._name)
loc = LocationInfo(
stream._name,
stream._cursor.lineno,
stream._cursor.col_offset
)
return loc
@staticmethod
def from_maxstream(stream: 'Stream', is_error=False) -> 'LocationInfo':
<|code_end|>
. Use current file imports:
import os
import atexit
import tempfile
import inspect
import re
import weakref
from collections import *
from pyrser import meta
and context (classes, functions, or code) from other files:
# Path: pyrser/meta.py
# def enum(*sequential, **named):
# def checktypes(func):
# def check_type(sig, arg_name, arg_type, arg_value):
# def wrapper(*args, **kwargs):
# def set_one(chainmap, thing_name, callobject):
# def _get_base_class(cls):
# def add_method(cls):
# def wrapper(f):
# def hook(cls, hookname=None, erase=False):
# def wrapper(f):
# def rule(cls, rulename=None, erase=False):
# def wrapper(f):
# def directive(directname=None):
# def wrapper(f):
# def decorator(directname=None):
# def wrapper(f):
. Output only the next line. | if stream._name is None: |
Given the code snippet: <|code_start|># little grammar for test
### ABSTRACTION
class NodeInfo(Node, Inference):
def __init__(self):
self.info = None
def walk(self) -> Node:
raise TypeError("Not implemented!")
class BlockStmt(NodeInfo):
def __init__(self, root=False):
super().__init__()
<|code_end|>
, generate the next line using the imports in this file:
import os
from itertools import chain
from pyrser import grammar
from pyrser import meta
from pyrser import fmt
from pyrser.parsing.node import *
from pyrser.hooks.echo import *
from pyrser.hooks.vars import *
from pyrser.hooks.set import *
from pyrser.hooks.predicate import *
from pyrser.hooks.dump_nodes import *
from pyrser.type_system import *
from pyrser.error import *
from pyrser.passes.to_yml import *
and context (functions, classes, or occasionally code) from other files:
# Path: pyrser/grammar.py
# class MetaGrammar(parsing.MetaBasicParser):
# class Grammar(parsing.Parser, metaclass=MetaGrammar):
# def __new__(metacls, name, bases, namespace):
# def after_parse(self, node: parsing.Node) -> parsing.Node:
# def _do_parse(self, entry: str) -> parsing.Node:
# def parse(self, source: str=None, entry: str=None) -> parsing.Node:
# def parse_file(self, filename: str, entry: str=None) -> parsing.Node:
# def build_grammar(inherit: tuple, scope: dict) -> Grammar:
# def from_string(bnf: str, entry=None, *optional_inherit) -> Grammar:
# def from_file(fn: str, entry=None, *optional_inherit) -> Grammar:
#
# Path: pyrser/meta.py
# def enum(*sequential, **named):
# def checktypes(func):
# def check_type(sig, arg_name, arg_type, arg_value):
# def wrapper(*args, **kwargs):
# def set_one(chainmap, thing_name, callobject):
# def _get_base_class(cls):
# def add_method(cls):
# def wrapper(f):
# def hook(cls, hookname=None, erase=False):
# def wrapper(f):
# def rule(cls, rulename=None, erase=False):
# def wrapper(f):
# def directive(directname=None):
# def wrapper(f):
# def decorator(directname=None):
# def wrapper(f):
#
# Path: pyrser/fmt.py
# class indentable:
# class block(indentable):
# class sep(indentable):
# class end(indentable):
# class tab(indentable):
# def __init__(self):
# def to_str(self, res: str) -> str:
# def __str__(self):
# def lsdata(self) -> list:
# def set_indent(self, indent: int=1):
# def catend(dst: str, src: str, indent) -> str:
# def list_set_indent(lst: list, indent: int=1):
# def list_to_str(lst: list, content: str, indent: int=1):
# def __init__(self, beginby: str, endby: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, ch: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, ch: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, lsdata: indentable):
# def set_indent(self, indent: int=1):
# def to_str(self, res: str, parent_indent) -> str:
. Output only the next line. | self.body = [] |
Based on the snippet: <|code_start|># little grammar for test
### ABSTRACTION
class NodeInfo(Node, Inference):
def __init__(self):
self.info = None
def walk(self) -> Node:
raise TypeError("Not implemented!")
class BlockStmt(NodeInfo):
def __init__(self, root=False):
super().__init__()
<|code_end|>
, predict the immediate next line with the help of imports:
import os
from itertools import chain
from pyrser import grammar
from pyrser import meta
from pyrser import fmt
from pyrser.parsing.node import *
from pyrser.hooks.echo import *
from pyrser.hooks.vars import *
from pyrser.hooks.set import *
from pyrser.hooks.predicate import *
from pyrser.hooks.dump_nodes import *
from pyrser.type_system import *
from pyrser.error import *
from pyrser.passes.to_yml import *
and context (classes, functions, sometimes code) from other files:
# Path: pyrser/grammar.py
# class MetaGrammar(parsing.MetaBasicParser):
# class Grammar(parsing.Parser, metaclass=MetaGrammar):
# def __new__(metacls, name, bases, namespace):
# def after_parse(self, node: parsing.Node) -> parsing.Node:
# def _do_parse(self, entry: str) -> parsing.Node:
# def parse(self, source: str=None, entry: str=None) -> parsing.Node:
# def parse_file(self, filename: str, entry: str=None) -> parsing.Node:
# def build_grammar(inherit: tuple, scope: dict) -> Grammar:
# def from_string(bnf: str, entry=None, *optional_inherit) -> Grammar:
# def from_file(fn: str, entry=None, *optional_inherit) -> Grammar:
#
# Path: pyrser/meta.py
# def enum(*sequential, **named):
# def checktypes(func):
# def check_type(sig, arg_name, arg_type, arg_value):
# def wrapper(*args, **kwargs):
# def set_one(chainmap, thing_name, callobject):
# def _get_base_class(cls):
# def add_method(cls):
# def wrapper(f):
# def hook(cls, hookname=None, erase=False):
# def wrapper(f):
# def rule(cls, rulename=None, erase=False):
# def wrapper(f):
# def directive(directname=None):
# def wrapper(f):
# def decorator(directname=None):
# def wrapper(f):
#
# Path: pyrser/fmt.py
# class indentable:
# class block(indentable):
# class sep(indentable):
# class end(indentable):
# class tab(indentable):
# def __init__(self):
# def to_str(self, res: str) -> str:
# def __str__(self):
# def lsdata(self) -> list:
# def set_indent(self, indent: int=1):
# def catend(dst: str, src: str, indent) -> str:
# def list_set_indent(lst: list, indent: int=1):
# def list_to_str(lst: list, content: str, indent: int=1):
# def __init__(self, beginby: str, endby: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, ch: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, ch: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, lsdata: indentable):
# def set_indent(self, indent: int=1):
# def to_str(self, res: str, parent_indent) -> str:
. Output only the next line. | self.body = [] |
Using the snippet: <|code_start|># little grammar for test
### ABSTRACTION
class NodeInfo(Node, Inference):
def __init__(self):
self.info = None
def walk(self) -> Node:
raise TypeError("Not implemented!")
class BlockStmt(NodeInfo):
<|code_end|>
, determine the next line of code. You have imports:
import os
from itertools import chain
from pyrser import grammar
from pyrser import meta
from pyrser import fmt
from pyrser.parsing.node import *
from pyrser.hooks.echo import *
from pyrser.hooks.vars import *
from pyrser.hooks.set import *
from pyrser.hooks.predicate import *
from pyrser.hooks.dump_nodes import *
from pyrser.type_system import *
from pyrser.error import *
from pyrser.passes.to_yml import *
and context (class names, function names, or code) available:
# Path: pyrser/grammar.py
# class MetaGrammar(parsing.MetaBasicParser):
# class Grammar(parsing.Parser, metaclass=MetaGrammar):
# def __new__(metacls, name, bases, namespace):
# def after_parse(self, node: parsing.Node) -> parsing.Node:
# def _do_parse(self, entry: str) -> parsing.Node:
# def parse(self, source: str=None, entry: str=None) -> parsing.Node:
# def parse_file(self, filename: str, entry: str=None) -> parsing.Node:
# def build_grammar(inherit: tuple, scope: dict) -> Grammar:
# def from_string(bnf: str, entry=None, *optional_inherit) -> Grammar:
# def from_file(fn: str, entry=None, *optional_inherit) -> Grammar:
#
# Path: pyrser/meta.py
# def enum(*sequential, **named):
# def checktypes(func):
# def check_type(sig, arg_name, arg_type, arg_value):
# def wrapper(*args, **kwargs):
# def set_one(chainmap, thing_name, callobject):
# def _get_base_class(cls):
# def add_method(cls):
# def wrapper(f):
# def hook(cls, hookname=None, erase=False):
# def wrapper(f):
# def rule(cls, rulename=None, erase=False):
# def wrapper(f):
# def directive(directname=None):
# def wrapper(f):
# def decorator(directname=None):
# def wrapper(f):
#
# Path: pyrser/fmt.py
# class indentable:
# class block(indentable):
# class sep(indentable):
# class end(indentable):
# class tab(indentable):
# def __init__(self):
# def to_str(self, res: str) -> str:
# def __str__(self):
# def lsdata(self) -> list:
# def set_indent(self, indent: int=1):
# def catend(dst: str, src: str, indent) -> str:
# def list_set_indent(lst: list, indent: int=1):
# def list_to_str(lst: list, content: str, indent: int=1):
# def __init__(self, beginby: str, endby: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, ch: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, ch: str, lsdata: list):
# def to_str(self, res: str, parent_indent) -> str:
# def __init__(self, lsdata: indentable):
# def set_indent(self, indent: int=1):
# def to_str(self, res: str, parent_indent) -> str:
. Output only the next line. | def __init__(self, root=False): |
Given the following code snippet before the placeholder: <|code_start|> long_description='Phylogenetic orthology inference for comparative genomics',
# The project's main homepage.
url='https://github.com/davidemms/OrthoFinder',
# Author details
author='David Emms',
author_email='david_emms@hotmail.com',
# Choose your license
license='OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)',
classifiers=[
# How mature is this project? Common values are
# 3 - Alpha
# 4 - Beta
# 5 - Production/Stable
'Development Status :: 4 - Beta',
# Indicate who your project is intended for
'Intended Audience :: Science/Research',
'Topic :: Scientific/Engineering :: Bio-Informatics',
# Pick your license as you wish (should match "license" above)
'License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)',
# Specify the Python versions you support here.
'Programming Language :: Python :: 2.7',
'Programming Language :: Python :: 3.5',
'Programming Language :: Python :: 3.6',
<|code_end|>
, predict the next line using imports from the current file:
from setuptools import setup, find_packages
from codecs import open
from os import path
from scripts_of.util import version
import sys
and context including class names, function names, and sometimes code from other files:
# Path: scripts_of/util.py
# def PrintNoNewLine(text):
# def PrintTime(message):
# def GetDirectoryName(baseDirName, i):
# def CreateNewWorkingDirectory(baseDirectoryName, qDate=True):
# def CreateNewPairedDirectories(baseDirectoryName1, baseDirectoryName2):
# def GetUnusedFilename(baseFilename, ext):
# def SortArrayPairByFirst(useForSortAr, keepAlignedAr, qLargestFirst=False):
# def GetSeqsInfo(inputDirectory_list, speciesToUse, nSpAll):
# def GetSpeciesToUse(speciesIDsFN):
# def Success():
# def Fail():
# def GetIDPairFromString(line):
# def GetIDToNameDict(self):
# def __init__(self, idsFilename):
# def GetIDToNameDict(self):
# def __init__(self, idsFilename):
# def GetIDToNameDict(self):
# def HaveSupportValues(speciesTreeFN_ids):
# def RenameTreeTaxa(treeFN_or_tree, newTreeFilename, idsMap, qSupport, qFixNegatives=False, inFormat=None, label=None, qViaCopy=False):
# def GetSpeciesDirectory():
# def WriteCitation(d):
# def PrintCitation(d=None):
# def PrintUnderline(text, qHeavy=False):
# def FlowText(text, n=60):
# def number_open_files_exception_advice(n_species, q_at_trees):
# def __init__(self, nSp):
# def __iadd__(self, other):
# def __init__(self, nSp):
# def __iadd__(self, nOrtho_sp_obj):
# def get_i_j_to_write(self, n_max_cache):
# def __enter__(self):
# def __exit__(self, type, value, traceback):
# def writerow(fh, row):
# def getrow(row):
# class IDExtractor(object):
# class FullAccession(IDExtractor):
# class FirstWordExtractor(IDExtractor):
# class nOrtho_sp(object):
# class nOrtho_cache(object):
# class Finalise(object):
# IJ = np.where(self.n > n_max_cache)
# I = list(IJ[0])
# J = list(IJ[1])
. Output only the next line. | ], |
Here is a snippet: <|code_start|> def __contains__(self, item):
""" Check if item belongs to this node. The 'item' argument must
be a node instance or its associated name."""
if isinstance(item, self.__class__):
return item in set(self.get_descendants())
elif type(item)==str:
return item in set([n.name for n in self.traverse()])
def __len__(self):
"""Node len returns number of children."""
return len(self.get_leaves())
def __iter__(self):
""" Iterator over leaf nodes"""
return self.iter_leaves()
def add_feature(self, pr_name, pr_value):
"""
Add or update a node's feature.
"""
setattr(self, pr_name, pr_value)
self.features.add(pr_name)
def add_features(self, **features):
"""
Add or update several features. """
for fname, fvalue in features.items():
setattr(self, fname, fvalue)
self.features.add(fname)
<|code_end|>
. Write the next line using the current file imports:
import os
import cPickle as pickle
import pickle
import random
import copy
import itertools
import functools
from collections import deque
from .newick import read_newick, write_newick
and context from other files:
# Path: scripts_of/newick.py
# def read_newick(newick, root_node=None, format=0):
# """ Reads a newick tree from either a string or a file, and returns
# an ETE tree structure.
#
# A previously existent node object can be passed as the root of the
# tree, which means that all its new children will belong to the same
# class as the root(This allows to work with custom TreeNode
# objects).
#
# You can also take advantage from this behaviour to concatenate
# several tree structures.
# """
#
# if root_node is None:
# from .tree import TreeNode
# root_node = TreeNode()
#
# if isinstance(newick, basestring):
# if os.path.exists(newick):
# nw = open(newick, 'rU').read()
# else:
# nw = newick
# nw = nw.strip()
# if not nw.startswith('(') and nw.endswith(';'):
# return _read_node_data(nw, root_node, "single", format)
#
# elif not nw.startswith('(') or not nw.endswith(';'):
# raise NewickError('Unexisting tree file or Malformed newick tree structure.')
# else:
# return _read_newick_from_string(nw, root_node, format)
#
# else:
# raise NewickError("'newick' argument must be either a filename or a newick string.")
#
# def write_newick(rootnode, features=None, format=1, format_root_node=True,
# is_leaf_fn=None):
# """ Iteratively export a tree structure and returns its NHX
# representation. """
# newick = []
# leaf = is_leaf_fn if is_leaf_fn else lambda n: not bool(n.children)
# for postorder, node in rootnode.iter_prepostorder(is_leaf_fn=is_leaf_fn):
# if postorder:
# newick.append(")")
# if node.up is not None or format_root_node:
# newick.append(format_node(node, "internal", format))
# newick.append(_get_features_string(node, features))
# else:
# if node is not rootnode and node != node.up.children[0]:
# newick.append(",")
#
# if leaf(node):
# safe_name = re.sub("["+_ILEGAL_NEWICK_CHARS+"]", "_", \
# str(getattr(node, "name")))
# newick.append(format_node(node, "leaf", format))
# newick.append(_get_features_string(node, features))
# else:
# newick.append("(")
#
# newick.append(";")
# return ''.join(newick)
, which may include functions, classes, or code. Output only the next line. | def del_feature(self, pr_name): |
Continue the code snippet: <|code_start|>
class LDAP(Base):
endpoint = "/ldap"
def sync_ldap(self):
return self.client.post(self.endpoint + "/sync")
<|code_end|>
. Use current file imports:
from .base import Base
and context (classes, functions, or code) from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | def test_ldap_config(self): |
Next line prediction: <|code_start|>
class Webhooks(Base):
endpoint = "/hooks"
def create_incoming_hook(self, options):
<|code_end|>
. Use current file imports:
(from .base import Base)
and context including class names, function names, or small code snippets from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | return self.client.post(self.endpoint + "/incoming", options=options) |
Based on the snippet: <|code_start|>
def update_user_mfa(self, user_id, options=None):
return self.client.put(self.endpoint + "/" + user_id + "/mfa", options)
def generate_mfa(self, user_id):
return self.client.post(self.endpoint + "/" + user_id + "/mfa/generate")
def check_mfa(self, options=None):
return self.client.post(self.endpoint + "/mfa", options)
def update_user_password(self, user_id, options=None):
return self.client.put(self.endpoint + "/" + user_id + "/password", options)
def send_password_reset_mail(self, options=None):
return self.client.post(self.endpoint + "/password/reset/send", options)
def get_user_by_email(self, email):
return self.client.get(self.endpoint + "/email/" + email)
def get_user_sessions(self, user_id):
return self.client.get(self.endpoint + "/" + user_id + "/sessions")
def revoke_user_session(self, user_id, options=None):
return self.client.post(self.endpoint + "/" + user_id + "/sessions/revoke", options)
def revoke_all_user_sessions(self, user_id):
return self.client.post(
self.endpoint + "/" + user_id + "/sessions/revoke/all",
)
<|code_end|>
, predict the immediate next line with the help of imports:
from .base import Base
and context (classes, functions, sometimes code) from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | def attach_mobile_device(self, options=None): |
Using the snippet: <|code_start|>
class Bots(Base):
endpoint = "/bots"
def create_bot(self, options):
return self.client.post(self.endpoint, options=options)
<|code_end|>
, determine the next line of code. You have imports:
from .base import Base
and context (class names, function names, or code) available:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | def get_bots(self, params=None): |
Here is a snippet: <|code_start|>
class Scheme(Base):
endpoint = "/schemes"
def get_schemes(self, params=None):
return self.client.get(self.endpoint, params=params)
def create_scheme(self, options=None):
<|code_end|>
. Write the next line using the current file imports:
from .base import Base
and context from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
, which may include functions, classes, or code. Output only the next line. | return self.client.post(self.endpoint, options=options) |
Here is a snippet: <|code_start|>
class Compliance(Base):
endpoint = "/compliance"
def create_report(self, params):
return self.client.post(self.endpoint + "/reports", params=params)
def get_reports(self, params=None):
return self.client.get(self.endpoint + "/reports", params=params)
def get_report(self, report_id):
return self.client.get(self.endpoint + "/reports/" + report_id)
def download_report(self, report_id):
<|code_end|>
. Write the next line using the current file imports:
from .base import Base
and context from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
, which may include functions, classes, or code. Output only the next line. | return self.client.get(self.endpoint + "/reports/" + report_id + "/download") |
Here is a snippet: <|code_start|>
class SAML(Base):
endpoint = "/saml"
def get_metadata(self):
return self.client.get(self.endpoint + "/metadata")
def upload_idp_certificate(self, files):
<|code_end|>
. Write the next line using the current file imports:
from .base import Base
and context from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
, which may include functions, classes, or code. Output only the next line. | return self.client.post(self.endpoint + "/certificate/idp", files=files) |
Continue the code snippet: <|code_start|>
class Brand(Base):
endpoint = "/brand"
def get_brand_image(self):
return self.client.get(self.endpoint + "/image")
def upload_brand_image(self, files):
<|code_end|>
. Use current file imports:
from .base import Base
and context (classes, functions, or code) from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | return self.client.post(self.endpoint + "/image", files=files) |
Using the snippet: <|code_start|>
class IntegrationActions(Base):
endpoint = "/actions"
def open_dialog(self, options):
<|code_end|>
, determine the next line of code. You have imports:
from .base import Base
and context (class names, function names, or code) available:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | return self.client.post(self.endpoint + "/dialogs/open", options=options) |
Given the code snippet: <|code_start|>
class Files(Base):
endpoint = "/files"
def upload_file(self, channel_id, files):
return self.client.post(self.endpoint, data={"channel_id": channel_id}, files=files)
def get_file(self, file_id):
return self.client.get(
self.endpoint + "/" + file_id,
)
def get_file_thumbnail(self, file_id):
return self.client.get(
<|code_end|>
, generate the next line using the imports in this file:
from .base import Base
and context (functions, classes, or occasionally code) from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | self.endpoint + "/" + file_id + "/thumbnail", |
Continue the code snippet: <|code_start|>
class Emoji(Base):
endpoint = "/emoji"
def create_custom_emoji(self, emoji_name, files):
emoji = {"name": emoji_name, "creator_id": self.client.userid}
return self.client.post(self.endpoint, data={"emoji": json.dumps(emoji)}, files=files)
def get_emoji_list(self, params=None):
return self.client.get(self.endpoint, params=params)
def get_custom_emoji(self, emoji_id):
return self.client.get(self.endpoint + "/" + emoji_id)
def delete_custom_emoji(self, emoji_id):
return self.client.delete(self.endpoint + "/" + emoji_id)
<|code_end|>
. Use current file imports:
import json
from .base import Base
and context (classes, functions, or code) from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | def get_custom_emoji_by_name(self, name): |
Given the code snippet: <|code_start|>
class OAuth(Base):
endpoint = "/oauth"
def register_oauth_app(self, options):
return self.client.post(self.endpoint + "/apps", options=options)
def get_oauth_apps(self, params=None):
<|code_end|>
, generate the next line using the imports in this file:
from .base import Base
from .users import Users
and context (functions, classes, or occasionally code) from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
#
# Path: src/mattermostdriver/endpoints/users.py
# class Users(Base):
# endpoint = "/users"
#
# def login_user(self, options):
# return self.client.make_request("post", self.endpoint + "/login", options)
#
# def logout_user(self):
# return self.client.post(self.endpoint + "/logout")
#
# def create_user(self, options=None, params=None):
# return self.client.post(self.endpoint, options=options, params=params)
#
# def get_users(self, params=None):
# return self.client.get(self.endpoint, params=params)
#
# def get_users_by_ids(self, options=None):
# return self.client.post(self.endpoint + "/ids", options)
#
# def get_users_by_usernames(self, options=None):
# return self.client.post(self.endpoint + "/usernames", options)
#
# def search_users(self, options=None):
# return self.client.post(self.endpoint + "/search", options)
#
# def autocomplete_users(self, params=None):
# return self.client.get(self.endpoint + "/autocomplete", params=params)
#
# def get_user(self, user_id):
# return self.client.get(self.endpoint + "/" + user_id)
#
# def update_user(self, user_id, options=None):
# return self.client.put(self.endpoint + "/" + user_id, options)
#
# def deactivate_user(self, user_id):
# return self.client.delete(self.endpoint + "/" + user_id)
#
# def patch_user(self, user_id, options=None):
# return self.client.put(self.endpoint + "/" + user_id + "/patch", options)
#
# def update_user_role(self, user_id, options=None):
# return self.client.put(self.endpoint + "/" + user_id + "/roles", options)
#
# def update_user_active_status(self, user_id, options=None):
# return self.client.put(self.endpoint + "/" + user_id + "/active", options)
#
# def get_user_profile_image(self, user_id):
# return self.client.get(self.endpoint + "/" + user_id + "/image")
#
# def set_user_profile_image(self, user_id, files):
# return self.client.post(self.endpoint + "/" + user_id + "/image", files=files)
#
# def get_user_by_username(self, username):
# return self.client.get(self.endpoint + "/username/" + username)
#
# def reset_password(self, options=None):
# return self.client.post(self.endpoint + "/password/reset", options)
#
# def update_user_mfa(self, user_id, options=None):
# return self.client.put(self.endpoint + "/" + user_id + "/mfa", options)
#
# def generate_mfa(self, user_id):
# return self.client.post(self.endpoint + "/" + user_id + "/mfa/generate")
#
# def check_mfa(self, options=None):
# return self.client.post(self.endpoint + "/mfa", options)
#
# def update_user_password(self, user_id, options=None):
# return self.client.put(self.endpoint + "/" + user_id + "/password", options)
#
# def send_password_reset_mail(self, options=None):
# return self.client.post(self.endpoint + "/password/reset/send", options)
#
# def get_user_by_email(self, email):
# return self.client.get(self.endpoint + "/email/" + email)
#
# def get_user_sessions(self, user_id):
# return self.client.get(self.endpoint + "/" + user_id + "/sessions")
#
# def revoke_user_session(self, user_id, options=None):
# return self.client.post(self.endpoint + "/" + user_id + "/sessions/revoke", options)
#
# def revoke_all_user_sessions(self, user_id):
# return self.client.post(
# self.endpoint + "/" + user_id + "/sessions/revoke/all",
# )
#
# def attach_mobile_device(self, options=None):
# return self.client.put(self.endpoint + "/sessions/device", options)
#
# def get_user_audits(self, user_id):
# return self.client.get(self.endpoint + "/" + user_id + "/audits")
#
# def verify_user_email(self, options=None):
# return self.client.post(self.endpoint + "/email/verify", options)
#
# def send_verification_mail(self, options=None):
# return self.client.post(self.endpoint + "/email/verify/send", options)
#
# def switch_login_method(self, options=None):
# return self.client.post(self.endpoint + "/login/switch", options)
#
# def disable_personal_access_token(self, options=None):
# return self.client.post(self.endpoint + "/tokens/disable", options)
#
# def enable_personal_access_token(self, options=None):
# return self.client.post(self.endpoint + "/tokens/enable", options)
#
# def get_user_access_token(self, token_id):
# return self.client.get(self.endpoint + "/tokens/" + token_id)
#
# def search_tokens(self, options=None):
# return self.client.post(self.endpoint + "/tokens/search", options=options)
#
# def update_user_authentication_method(self, user_id, options=None):
# return self.client.put(self.endpoint + "/" + user_id + "/auth", options=options)
#
# def create_user_access_token(self, user_id, options=None):
# return self.client.post(self.endpoint + "/" + user_id + "/tokens", options=options)
#
# def get_stats(self):
# return self.client.get(self.endpoint + "/stats")
. Output only the next line. | return self.client.get(self.endpoint + "/apps", params=params) |
Predict the next line for this snippet: <|code_start|>
class Status(Base):
def get_user_status(self, user_id):
return self.client.get("/users/" + user_id + "/status")
def update_user_status(self, user_id, options=None):
<|code_end|>
with the help of current file imports:
from .base import Base
and context from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
, which may contain function names, class names, or code. Output only the next line. | return self.client.put("/users/" + user_id + "/status", options=options) |
Given snippet: <|code_start|>v1_api = Api(api_name='v1')
v1_api.register(FileResource())
v1_api.register(FileCommentResource())
v1_api.register(UserResource())
v1_api.register(UserProfileResource())
urlpatterns = patterns('',
url(r'^$', 'django_fordrop.views.index', name='index'),
url(r'^explore/$', 'django_fordrop.views.explore', name='explore'),
url(r'^welcome/$', 'django_fordrop.views.welcome', name='welcome'),
url(r'^welcome/(?P<id>[0-9]+)$', 'django_fordrop.views.welcome'),
url(r'^share/file$', 'django_fordrop.views.file_share', name='share_file'),
url(r'^search/$', 'django_fordrop.views.search', name='search'),
url(r'^file/(?P<id>[0-9]+)$', 'django_fordrop.views.file', name='file'),
url(r'^file/(?P<id>[0-9]+)/comment$', 'django_fordrop.views.file_comment', name='file_comment'),
url(r'^file/(?P<id>[0-9]+)/tag$', 'django_fordrop.views.file_tag', name='file_tag'),
url(r'^file/(?P<id>[0-9]+)/clone$', 'django_fordrop.views.file_clone', name='file_clone'),
url(r'^collection$', 'django_fordrop.views.collection', name='collection'),
url(r'^collection/(?P<id>[0-9]+)$', 'django_fordrop.views.collection_timeline', name='collection_timeline'),
url(r'^collection/(?P<id>[0-9]+)/timeline$', 'django_fordrop.views.timeline_json', name='timeline'),
url(r'^collection/(?P<id>[0-9]+)/comment$', 'django_fordrop.views.collection_comment', name='collection_comment'),
url(r'^collection/(?P<id>[0-9]+)/tag$', 'django_fordrop.views.collection_tag', name='collection_tag'),
url(r'^collection/(?P<id>[0-9]+)/follow$', 'django_fordrop.views.collection_follow', name='collection_follow'),
url(r'^collection/(?P<id>[0-9]+)/unfollow$', 'django_fordrop.views.collection_unfollow', name='collection_unfollow'),
url(r'^profile/$', 'django_fordrop.views.profile', name='profile'),
url(r'^profile/(?P<id>[0-9]+)$', 'django_fordrop.views.profile', name='profile'),
url(r'^profile/edit/$', 'django_fordrop.views.edit_profile', name='edit_profile'),
url(r'^profile/settings/edit/$', 'django_fordrop.views.edit_settings', name='edit_settings'),
url(r'^federation/$', 'django_fordrop.views.federation', name='federation'),
url(r'federation/node/add/$', 'django_fordrop.views.add_pubsub_node', name='add_pubsub_node'),
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.conf.urls import patterns, include, url
from django.contrib import admin
from tastypie.api import Api
from django_fordrop.api_v1 import FileResource, FileCommentResource, UserResource, UserProfileResource
from django.views.generic.simple import direct_to_template
and context:
# Path: django_fordrop/api_v1.py
# class FileResource(ModelResource):
# resource_name = 'file'
# user = fields.ForeignKey(UserResource, 'user')
# class Meta:
# queryset = File.objects.all()
# filtering = {
# "uuid": ALL
# }
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
#
# class FileCommentResource(ModelResource):
# resource_name = 'filecomment'
# file = fields.ForeignKey(FileResource, 'file', full=True)
# class Meta:
# queryset = FileComment.objects.all()
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
#
# class UserResource(ModelResource):
# resource_name = 'user'
# class Meta:
# queryset = User.objects.all()
# fields = ['username', 'is_active']
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
#
# class UserProfileResource(ModelResource):
# user = fields.ForeignKey(UserResource, 'user', full=True)
# class Meta:
# queryset = UserProfile.objects.all()
# excludes = ['id']
# filtering = {
# "uuid": ALL
# }
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
which might include code, classes, or functions. Output only the next line. | url(r'^api/', include(v1_api.urls)), |
Given snippet: <|code_start|>v1_api.register(FileResource())
v1_api.register(FileCommentResource())
v1_api.register(UserResource())
v1_api.register(UserProfileResource())
urlpatterns = patterns('',
url(r'^$', 'django_fordrop.views.index', name='index'),
url(r'^explore/$', 'django_fordrop.views.explore', name='explore'),
url(r'^welcome/$', 'django_fordrop.views.welcome', name='welcome'),
url(r'^welcome/(?P<id>[0-9]+)$', 'django_fordrop.views.welcome'),
url(r'^share/file$', 'django_fordrop.views.file_share', name='share_file'),
url(r'^search/$', 'django_fordrop.views.search', name='search'),
url(r'^file/(?P<id>[0-9]+)$', 'django_fordrop.views.file', name='file'),
url(r'^file/(?P<id>[0-9]+)/comment$', 'django_fordrop.views.file_comment', name='file_comment'),
url(r'^file/(?P<id>[0-9]+)/tag$', 'django_fordrop.views.file_tag', name='file_tag'),
url(r'^file/(?P<id>[0-9]+)/clone$', 'django_fordrop.views.file_clone', name='file_clone'),
url(r'^collection$', 'django_fordrop.views.collection', name='collection'),
url(r'^collection/(?P<id>[0-9]+)$', 'django_fordrop.views.collection_timeline', name='collection_timeline'),
url(r'^collection/(?P<id>[0-9]+)/timeline$', 'django_fordrop.views.timeline_json', name='timeline'),
url(r'^collection/(?P<id>[0-9]+)/comment$', 'django_fordrop.views.collection_comment', name='collection_comment'),
url(r'^collection/(?P<id>[0-9]+)/tag$', 'django_fordrop.views.collection_tag', name='collection_tag'),
url(r'^collection/(?P<id>[0-9]+)/follow$', 'django_fordrop.views.collection_follow', name='collection_follow'),
url(r'^collection/(?P<id>[0-9]+)/unfollow$', 'django_fordrop.views.collection_unfollow', name='collection_unfollow'),
url(r'^profile/$', 'django_fordrop.views.profile', name='profile'),
url(r'^profile/(?P<id>[0-9]+)$', 'django_fordrop.views.profile', name='profile'),
url(r'^profile/edit/$', 'django_fordrop.views.edit_profile', name='edit_profile'),
url(r'^profile/settings/edit/$', 'django_fordrop.views.edit_settings', name='edit_settings'),
url(r'^federation/$', 'django_fordrop.views.federation', name='federation'),
url(r'federation/node/add/$', 'django_fordrop.views.add_pubsub_node', name='add_pubsub_node'),
url(r'^api/', include(v1_api.urls)),
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.conf.urls import patterns, include, url
from django.contrib import admin
from tastypie.api import Api
from django_fordrop.api_v1 import FileResource, FileCommentResource, UserResource, UserProfileResource
from django.views.generic.simple import direct_to_template
and context:
# Path: django_fordrop/api_v1.py
# class FileResource(ModelResource):
# resource_name = 'file'
# user = fields.ForeignKey(UserResource, 'user')
# class Meta:
# queryset = File.objects.all()
# filtering = {
# "uuid": ALL
# }
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
#
# class FileCommentResource(ModelResource):
# resource_name = 'filecomment'
# file = fields.ForeignKey(FileResource, 'file', full=True)
# class Meta:
# queryset = FileComment.objects.all()
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
#
# class UserResource(ModelResource):
# resource_name = 'user'
# class Meta:
# queryset = User.objects.all()
# fields = ['username', 'is_active']
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
#
# class UserProfileResource(ModelResource):
# user = fields.ForeignKey(UserResource, 'user', full=True)
# class Meta:
# queryset = UserProfile.objects.all()
# excludes = ['id']
# filtering = {
# "uuid": ALL
# }
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
which might include code, classes, or functions. Output only the next line. | url(r'^accounts/change_password/$', 'django.contrib.auth.views.password_change', {'post_change_redirect' : '/accounts/change_password/done/'}), |
Given the code snippet: <|code_start|>
admin.autodiscover()
v1_api = Api(api_name='v1')
v1_api.register(FileResource())
v1_api.register(FileCommentResource())
v1_api.register(UserResource())
v1_api.register(UserProfileResource())
urlpatterns = patterns('',
url(r'^$', 'django_fordrop.views.index', name='index'),
url(r'^explore/$', 'django_fordrop.views.explore', name='explore'),
<|code_end|>
, generate the next line using the imports in this file:
from django.conf.urls import patterns, include, url
from django.contrib import admin
from tastypie.api import Api
from django_fordrop.api_v1 import FileResource, FileCommentResource, UserResource, UserProfileResource
from django.views.generic.simple import direct_to_template
and context (functions, classes, or occasionally code) from other files:
# Path: django_fordrop/api_v1.py
# class FileResource(ModelResource):
# resource_name = 'file'
# user = fields.ForeignKey(UserResource, 'user')
# class Meta:
# queryset = File.objects.all()
# filtering = {
# "uuid": ALL
# }
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
#
# class FileCommentResource(ModelResource):
# resource_name = 'filecomment'
# file = fields.ForeignKey(FileResource, 'file', full=True)
# class Meta:
# queryset = FileComment.objects.all()
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
#
# class UserResource(ModelResource):
# resource_name = 'user'
# class Meta:
# queryset = User.objects.all()
# fields = ['username', 'is_active']
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
#
# class UserProfileResource(ModelResource):
# user = fields.ForeignKey(UserResource, 'user', full=True)
# class Meta:
# queryset = UserProfile.objects.all()
# excludes = ['id']
# filtering = {
# "uuid": ALL
# }
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
. Output only the next line. | url(r'^welcome/$', 'django_fordrop.views.welcome', name='welcome'), |
Predict the next line after this snippet: <|code_start|>
admin.autodiscover()
v1_api = Api(api_name='v1')
v1_api.register(FileResource())
v1_api.register(FileCommentResource())
v1_api.register(UserResource())
v1_api.register(UserProfileResource())
urlpatterns = patterns('',
url(r'^$', 'django_fordrop.views.index', name='index'),
url(r'^explore/$', 'django_fordrop.views.explore', name='explore'),
url(r'^welcome/$', 'django_fordrop.views.welcome', name='welcome'),
url(r'^welcome/(?P<id>[0-9]+)$', 'django_fordrop.views.welcome'),
url(r'^share/file$', 'django_fordrop.views.file_share', name='share_file'),
url(r'^search/$', 'django_fordrop.views.search', name='search'),
url(r'^file/(?P<id>[0-9]+)$', 'django_fordrop.views.file', name='file'),
url(r'^file/(?P<id>[0-9]+)/comment$', 'django_fordrop.views.file_comment', name='file_comment'),
url(r'^file/(?P<id>[0-9]+)/tag$', 'django_fordrop.views.file_tag', name='file_tag'),
url(r'^file/(?P<id>[0-9]+)/clone$', 'django_fordrop.views.file_clone', name='file_clone'),
url(r'^collection$', 'django_fordrop.views.collection', name='collection'),
url(r'^collection/(?P<id>[0-9]+)$', 'django_fordrop.views.collection_timeline', name='collection_timeline'),
url(r'^collection/(?P<id>[0-9]+)/timeline$', 'django_fordrop.views.timeline_json', name='timeline'),
url(r'^collection/(?P<id>[0-9]+)/comment$', 'django_fordrop.views.collection_comment', name='collection_comment'),
url(r'^collection/(?P<id>[0-9]+)/tag$', 'django_fordrop.views.collection_tag', name='collection_tag'),
url(r'^collection/(?P<id>[0-9]+)/follow$', 'django_fordrop.views.collection_follow', name='collection_follow'),
url(r'^collection/(?P<id>[0-9]+)/unfollow$', 'django_fordrop.views.collection_unfollow', name='collection_unfollow'),
url(r'^profile/$', 'django_fordrop.views.profile', name='profile'),
url(r'^profile/(?P<id>[0-9]+)$', 'django_fordrop.views.profile', name='profile'),
url(r'^profile/edit/$', 'django_fordrop.views.edit_profile', name='edit_profile'),
<|code_end|>
using the current file's imports:
from django.conf.urls import patterns, include, url
from django.contrib import admin
from tastypie.api import Api
from django_fordrop.api_v1 import FileResource, FileCommentResource, UserResource, UserProfileResource
from django.views.generic.simple import direct_to_template
and any relevant context from other files:
# Path: django_fordrop/api_v1.py
# class FileResource(ModelResource):
# resource_name = 'file'
# user = fields.ForeignKey(UserResource, 'user')
# class Meta:
# queryset = File.objects.all()
# filtering = {
# "uuid": ALL
# }
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
#
# class FileCommentResource(ModelResource):
# resource_name = 'filecomment'
# file = fields.ForeignKey(FileResource, 'file', full=True)
# class Meta:
# queryset = FileComment.objects.all()
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
#
# class UserResource(ModelResource):
# resource_name = 'user'
# class Meta:
# queryset = User.objects.all()
# fields = ['username', 'is_active']
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
#
# class UserProfileResource(ModelResource):
# user = fields.ForeignKey(UserResource, 'user', full=True)
# class Meta:
# queryset = UserProfile.objects.all()
# excludes = ['id']
# filtering = {
# "uuid": ALL
# }
# authorization = Authorization()
# authentication = ApiKeyAuthentication()
. Output only the next line. | url(r'^profile/settings/edit/$', 'django_fordrop.views.edit_settings', name='edit_settings'), |
Here is a snippet: <|code_start|>
@login_required
def edit_profile(request):
profile, created = UserProfile.objects.get_or_create(user=request.user)
user_settings, created = UserSettings.objects.get_or_create(user=request.user)
form = UserProfileForm(instance=profile)
settingsform = UserSettingsForm(instance=user_settings)
if request.method == 'POST':
form = UserProfileForm(request.POST, request.FILES, instance=profile)
if form.is_valid():
form.save()
if request.POST.get('welcome', False):
redir_url = "/welcome/2"
else:
redir_url = request.META["HTTP_REFERER"]
messages.success(request, 'Profile saved!')
return HttpResponseRedirect(redir_url)
return render_to_response('edit_profile.html',{'form': form,
'settingsform': settingsform}, RequestContext(request))
@login_required
def edit_settings(request):
user_settings, created = UserSettings.objects.get_or_create(user=request.user)
if request.method == 'POST':
form = UserSettingsForm(request.POST, instance=user_settings)
if form.is_valid():
form.save()
if request.POST.get('welcome', False):
redir_url = "/welcome/3"
else:
<|code_end|>
. Write the next line using the current file imports:
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User
from django.core.exceptions import PermissionDenied, ObjectDoesNotExist
from django.core.mail import mail_admins
from django.db.models.query_utils import Q
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.views.decorators.csrf import csrf_exempt
from django_fordrop.forms import UserProfileForm, RequestInviteForm
from django_fordrop.models import UserProfile, UserSettings, PubSubNode
from forms import UploadFileForm, FileCommentForm, CollectionCommentForm, CollectionForm, FileTagForm, UserProfileForm, UserSettingsForm, CollectionTagForm
from models import handle_uploaded_file, File, Collection, xmpp, notify_by_mail
from django.conf import settings
import uuid
import urllib2
import json
import operator
and context from other files:
# Path: django_fordrop/forms.py
# class UserProfileForm(forms.ModelForm):
# class Meta:
# model = UserProfile
# exclude = ('user', 'uuid')
#
# class RequestInviteForm(forms.Form):
# email = forms.fields.EmailField(label="")
#
# Path: django_fordrop/models.py
# class UserProfile(models.Model):
# user = models.ForeignKey(User, unique=True, null=True, blank=True)
# uuid = models.CharField(max_length=255, null=True, blank=True)
# name = models.CharField(max_length=255, null=True, blank=True)
# email = models.EmailField(null=True, blank=True)
# avatar = ImageField(upload_to='avatars', null=True, blank=True)
# location = models.CharField(max_length=255, null=True, blank=True)
# web = models.URLField(null=True, blank=True)
# bio = models.TextField(max_length=140, null=True, blank=True)
# is_first_login = models.BooleanField(default=True)
# time_created = models.DateTimeField(auto_now_add=True)
# time_updated = models.DateTimeField(auto_now=True)
# def activity(self):
# return {
# "objectType" : "person",
# "id": self.uuid,
# "displayName": self.name,
# "location": self.location,
# 'web': self.web,
# "bio": self.bio,
# }
# def __unicode__(self):
# return '%s' % self.user
# def get_absolute_url(self):
# return '/profile/%s' % self.id
# def save(self, *args, **kwargs):
# super(UserProfile, self).save()
# if not self.uuid:
# self.uuid = uuid.uuid4().urn
# if not self.email:
# self.email = self.user.email
# super(UserProfile, self).save()
# class Admin:
# pass
#
# class UserSettings(models.Model):
# user = models.ForeignKey(User)
# notify_comment_on_file = models.BooleanField(default=False)
# notify_comment_on_collection = models.BooleanField(default=False)
# notify_same_file = models.BooleanField(default=False)
# publish_avatar = models.BooleanField(default=False)
# post_as_self = models.BooleanField(default=False)
# time_created = models.DateTimeField(auto_now_add=True)
# last_updated = models.DateTimeField(auto_now=True)
# def __unicode__(self):
# return '%s' % self.user
# class Admin:
# pass
#
# class PubSubNode(models.Model):
# node = models.CharField(max_length=255, unique=True)
# name = models.CharField(max_length=255, unique=False)
# time_created = models.DateTimeField(auto_now_add=True)
# last_updated = models.DateTimeField(auto_now=True)
# def __unicode__(self):
# return '%s' % self.name
# class Admin:
# pass
, which may include functions, classes, or code. Output only the next line. | redir_url = request.META["HTTP_REFERER"] |
Continue the code snippet: <|code_start|> if request.method == 'POST':
data = request.POST ['search']
elif request.GET.get('q', ''):
data = urllib2.unquote(request.GET.get('q', ''))
else:
return HttpResponseRedirect(request.META['HTTP_REFERER'])
if data.startswith('tag:'):
data = data.replace('tag:', '').lstrip()
result = []
for collection in Collection.objects.filter(tags__name=data):
result.append(collection)
for file in File.objects.filter(tags__name=data):
result.append(file)
else:
result = []
for collection in Collection.objects.filter(Q(title__icontains=data)|Q(description__icontains=data)):
result.append(collection)
for file in File.objects.filter(
Q(filename__icontains=data)|
Q(description__icontains=data)|
Q(md5__icontains=data)|
Q(sha1__icontains=data)|
Q(sha256__icontains=data)|
Q(sha512__icontains=data)):
result.append(file)
return render_to_response("search.html", {'result': result}, RequestContext(request))
@login_required
def profile(request, id=None):
if not id:
<|code_end|>
. Use current file imports:
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User
from django.core.exceptions import PermissionDenied, ObjectDoesNotExist
from django.core.mail import mail_admins
from django.db.models.query_utils import Q
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.views.decorators.csrf import csrf_exempt
from django_fordrop.forms import UserProfileForm, RequestInviteForm
from django_fordrop.models import UserProfile, UserSettings, PubSubNode
from forms import UploadFileForm, FileCommentForm, CollectionCommentForm, CollectionForm, FileTagForm, UserProfileForm, UserSettingsForm, CollectionTagForm
from models import handle_uploaded_file, File, Collection, xmpp, notify_by_mail
from django.conf import settings
import uuid
import urllib2
import json
import operator
and context (classes, functions, or code) from other files:
# Path: django_fordrop/forms.py
# class UserProfileForm(forms.ModelForm):
# class Meta:
# model = UserProfile
# exclude = ('user', 'uuid')
#
# class RequestInviteForm(forms.Form):
# email = forms.fields.EmailField(label="")
#
# Path: django_fordrop/models.py
# class UserProfile(models.Model):
# user = models.ForeignKey(User, unique=True, null=True, blank=True)
# uuid = models.CharField(max_length=255, null=True, blank=True)
# name = models.CharField(max_length=255, null=True, blank=True)
# email = models.EmailField(null=True, blank=True)
# avatar = ImageField(upload_to='avatars', null=True, blank=True)
# location = models.CharField(max_length=255, null=True, blank=True)
# web = models.URLField(null=True, blank=True)
# bio = models.TextField(max_length=140, null=True, blank=True)
# is_first_login = models.BooleanField(default=True)
# time_created = models.DateTimeField(auto_now_add=True)
# time_updated = models.DateTimeField(auto_now=True)
# def activity(self):
# return {
# "objectType" : "person",
# "id": self.uuid,
# "displayName": self.name,
# "location": self.location,
# 'web': self.web,
# "bio": self.bio,
# }
# def __unicode__(self):
# return '%s' % self.user
# def get_absolute_url(self):
# return '/profile/%s' % self.id
# def save(self, *args, **kwargs):
# super(UserProfile, self).save()
# if not self.uuid:
# self.uuid = uuid.uuid4().urn
# if not self.email:
# self.email = self.user.email
# super(UserProfile, self).save()
# class Admin:
# pass
#
# class UserSettings(models.Model):
# user = models.ForeignKey(User)
# notify_comment_on_file = models.BooleanField(default=False)
# notify_comment_on_collection = models.BooleanField(default=False)
# notify_same_file = models.BooleanField(default=False)
# publish_avatar = models.BooleanField(default=False)
# post_as_self = models.BooleanField(default=False)
# time_created = models.DateTimeField(auto_now_add=True)
# last_updated = models.DateTimeField(auto_now=True)
# def __unicode__(self):
# return '%s' % self.user
# class Admin:
# pass
#
# class PubSubNode(models.Model):
# node = models.CharField(max_length=255, unique=True)
# name = models.CharField(max_length=255, unique=False)
# time_created = models.DateTimeField(auto_now_add=True)
# last_updated = models.DateTimeField(auto_now=True)
# def __unicode__(self):
# return '%s' % self.name
# class Admin:
# pass
. Output only the next line. | profile_user = request.user |
Predict the next line for this snippet: <|code_start|> 'is_reporter': is_reporter,
'tagform': FileTagForm(instance=file),
'commentform': FileCommentForm}, RequestContext(request))
@login_required
def file_tag(request, id):
file = File.objects.get(pk=id)
if request.method == 'POST':
form = FileTagForm(request.POST, instance=file)
if form.is_valid():
form.save()
if file.tags.all:
for node in file.nodes.all():
xmpp.publish(node=node.node, payload=file.activity_tags())
return HttpResponseRedirect(request.META['HTTP_REFERER'])
@login_required
def collection(request):
if request.method == 'POST':
form = CollectionForm(request.POST)
if form.is_valid():
collection = form.save(commit=False)
collection.user = request.user
collection.uuid = uuid.uuid4().urn
collection.save()
collection.followers.add(request.user)
collection.save()
form.save_m2m()
for n in request.POST.getlist('nodes'):
node = PubSubNode.objects.get(node=int(n))
<|code_end|>
with the help of current file imports:
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User
from django.core.exceptions import PermissionDenied, ObjectDoesNotExist
from django.core.mail import mail_admins
from django.db.models.query_utils import Q
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.views.decorators.csrf import csrf_exempt
from django_fordrop.forms import UserProfileForm, RequestInviteForm
from django_fordrop.models import UserProfile, UserSettings, PubSubNode
from forms import UploadFileForm, FileCommentForm, CollectionCommentForm, CollectionForm, FileTagForm, UserProfileForm, UserSettingsForm, CollectionTagForm
from models import handle_uploaded_file, File, Collection, xmpp, notify_by_mail
from django.conf import settings
import uuid
import urllib2
import json
import operator
and context from other files:
# Path: django_fordrop/forms.py
# class UserProfileForm(forms.ModelForm):
# class Meta:
# model = UserProfile
# exclude = ('user', 'uuid')
#
# class RequestInviteForm(forms.Form):
# email = forms.fields.EmailField(label="")
#
# Path: django_fordrop/models.py
# class UserProfile(models.Model):
# user = models.ForeignKey(User, unique=True, null=True, blank=True)
# uuid = models.CharField(max_length=255, null=True, blank=True)
# name = models.CharField(max_length=255, null=True, blank=True)
# email = models.EmailField(null=True, blank=True)
# avatar = ImageField(upload_to='avatars', null=True, blank=True)
# location = models.CharField(max_length=255, null=True, blank=True)
# web = models.URLField(null=True, blank=True)
# bio = models.TextField(max_length=140, null=True, blank=True)
# is_first_login = models.BooleanField(default=True)
# time_created = models.DateTimeField(auto_now_add=True)
# time_updated = models.DateTimeField(auto_now=True)
# def activity(self):
# return {
# "objectType" : "person",
# "id": self.uuid,
# "displayName": self.name,
# "location": self.location,
# 'web': self.web,
# "bio": self.bio,
# }
# def __unicode__(self):
# return '%s' % self.user
# def get_absolute_url(self):
# return '/profile/%s' % self.id
# def save(self, *args, **kwargs):
# super(UserProfile, self).save()
# if not self.uuid:
# self.uuid = uuid.uuid4().urn
# if not self.email:
# self.email = self.user.email
# super(UserProfile, self).save()
# class Admin:
# pass
#
# class UserSettings(models.Model):
# user = models.ForeignKey(User)
# notify_comment_on_file = models.BooleanField(default=False)
# notify_comment_on_collection = models.BooleanField(default=False)
# notify_same_file = models.BooleanField(default=False)
# publish_avatar = models.BooleanField(default=False)
# post_as_self = models.BooleanField(default=False)
# time_created = models.DateTimeField(auto_now_add=True)
# last_updated = models.DateTimeField(auto_now=True)
# def __unicode__(self):
# return '%s' % self.user
# class Admin:
# pass
#
# class PubSubNode(models.Model):
# node = models.CharField(max_length=255, unique=True)
# name = models.CharField(max_length=255, unique=False)
# time_created = models.DateTimeField(auto_now_add=True)
# last_updated = models.DateTimeField(auto_now=True)
# def __unicode__(self):
# return '%s' % self.name
# class Admin:
# pass
, which may contain function names, class names, or code. Output only the next line. | collection.nodes.add(node) |
Predict the next line after this snippet: <|code_start|> file = File.objects.get(pk=id)
if request.method == 'POST':
form = FileTagForm(request.POST, instance=file)
if form.is_valid():
form.save()
if file.tags.all:
for node in file.nodes.all():
xmpp.publish(node=node.node, payload=file.activity_tags())
return HttpResponseRedirect(request.META['HTTP_REFERER'])
@login_required
def collection(request):
if request.method == 'POST':
form = CollectionForm(request.POST)
if form.is_valid():
collection = form.save(commit=False)
collection.user = request.user
collection.uuid = uuid.uuid4().urn
collection.save()
collection.followers.add(request.user)
collection.save()
form.save_m2m()
for n in request.POST.getlist('nodes'):
node = PubSubNode.objects.get(node=int(n))
collection.nodes.add(node)
xmpp.publish(node=node.node, payload=collection.activity_fordrop_collection())
if collection.tags.all():
xmpp.publish(node=node.node, payload=collection.activity_tags())
return HttpResponseRedirect('/collection/%s' % collection.id)
<|code_end|>
using the current file's imports:
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User
from django.core.exceptions import PermissionDenied, ObjectDoesNotExist
from django.core.mail import mail_admins
from django.db.models.query_utils import Q
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.views.decorators.csrf import csrf_exempt
from django_fordrop.forms import UserProfileForm, RequestInviteForm
from django_fordrop.models import UserProfile, UserSettings, PubSubNode
from forms import UploadFileForm, FileCommentForm, CollectionCommentForm, CollectionForm, FileTagForm, UserProfileForm, UserSettingsForm, CollectionTagForm
from models import handle_uploaded_file, File, Collection, xmpp, notify_by_mail
from django.conf import settings
import uuid
import urllib2
import json
import operator
and any relevant context from other files:
# Path: django_fordrop/forms.py
# class UserProfileForm(forms.ModelForm):
# class Meta:
# model = UserProfile
# exclude = ('user', 'uuid')
#
# class RequestInviteForm(forms.Form):
# email = forms.fields.EmailField(label="")
#
# Path: django_fordrop/models.py
# class UserProfile(models.Model):
# user = models.ForeignKey(User, unique=True, null=True, blank=True)
# uuid = models.CharField(max_length=255, null=True, blank=True)
# name = models.CharField(max_length=255, null=True, blank=True)
# email = models.EmailField(null=True, blank=True)
# avatar = ImageField(upload_to='avatars', null=True, blank=True)
# location = models.CharField(max_length=255, null=True, blank=True)
# web = models.URLField(null=True, blank=True)
# bio = models.TextField(max_length=140, null=True, blank=True)
# is_first_login = models.BooleanField(default=True)
# time_created = models.DateTimeField(auto_now_add=True)
# time_updated = models.DateTimeField(auto_now=True)
# def activity(self):
# return {
# "objectType" : "person",
# "id": self.uuid,
# "displayName": self.name,
# "location": self.location,
# 'web': self.web,
# "bio": self.bio,
# }
# def __unicode__(self):
# return '%s' % self.user
# def get_absolute_url(self):
# return '/profile/%s' % self.id
# def save(self, *args, **kwargs):
# super(UserProfile, self).save()
# if not self.uuid:
# self.uuid = uuid.uuid4().urn
# if not self.email:
# self.email = self.user.email
# super(UserProfile, self).save()
# class Admin:
# pass
#
# class UserSettings(models.Model):
# user = models.ForeignKey(User)
# notify_comment_on_file = models.BooleanField(default=False)
# notify_comment_on_collection = models.BooleanField(default=False)
# notify_same_file = models.BooleanField(default=False)
# publish_avatar = models.BooleanField(default=False)
# post_as_self = models.BooleanField(default=False)
# time_created = models.DateTimeField(auto_now_add=True)
# last_updated = models.DateTimeField(auto_now=True)
# def __unicode__(self):
# return '%s' % self.user
# class Admin:
# pass
#
# class PubSubNode(models.Model):
# node = models.CharField(max_length=255, unique=True)
# name = models.CharField(max_length=255, unique=False)
# time_created = models.DateTimeField(auto_now_add=True)
# last_updated = models.DateTimeField(auto_now=True)
# def __unicode__(self):
# return '%s' % self.name
# class Admin:
# pass
. Output only the next line. | @login_required |
Given the code snippet: <|code_start|> collection.nodes.add(node)
xmpp.publish(node=node.node, payload=collection.activity_fordrop_collection())
if collection.tags.all():
xmpp.publish(node=node.node, payload=collection.activity_tags())
return HttpResponseRedirect('/collection/%s' % collection.id)
@login_required
def explore(request):
return render_to_response("explore.html", {'collections': Collection.objects.all().order_by('-time_updated'), 'users': User.objects.filter(is_active=True), 'files': File.objects.all()}, RequestContext(request))
@login_required
def collection_tag(request, id):
collection = Collection.objects.get(pk=id)
if request.method == 'POST':
form = CollectionTagForm(request.POST, instance=collection)
if form.is_valid():
form.save()
if collection.tags.all:
for node in collection.nodes.all():
xmpp.publish(node=node.node, payload=collection.activity_tags())
return HttpResponseRedirect(request.META['HTTP_REFERER'])
@login_required
def collection_timeline(request, id):
collection = Collection.objects.get(pk=id)
try:
startdate = collection.latest_file().time_created.strftime('%a %b %d %Y %H:%M:%S')
except:
startdate = collection.time_created.strftime('%a %b %d %Y %H:%M:%S')
return render_to_response("collection_timeline.html", {'uploadform': UploadFileForm,
<|code_end|>
, generate the next line using the imports in this file:
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User
from django.core.exceptions import PermissionDenied, ObjectDoesNotExist
from django.core.mail import mail_admins
from django.db.models.query_utils import Q
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.views.decorators.csrf import csrf_exempt
from django_fordrop.forms import UserProfileForm, RequestInviteForm
from django_fordrop.models import UserProfile, UserSettings, PubSubNode
from forms import UploadFileForm, FileCommentForm, CollectionCommentForm, CollectionForm, FileTagForm, UserProfileForm, UserSettingsForm, CollectionTagForm
from models import handle_uploaded_file, File, Collection, xmpp, notify_by_mail
from django.conf import settings
import uuid
import urllib2
import json
import operator
and context (functions, classes, or occasionally code) from other files:
# Path: django_fordrop/forms.py
# class UserProfileForm(forms.ModelForm):
# class Meta:
# model = UserProfile
# exclude = ('user', 'uuid')
#
# class RequestInviteForm(forms.Form):
# email = forms.fields.EmailField(label="")
#
# Path: django_fordrop/models.py
# class UserProfile(models.Model):
# user = models.ForeignKey(User, unique=True, null=True, blank=True)
# uuid = models.CharField(max_length=255, null=True, blank=True)
# name = models.CharField(max_length=255, null=True, blank=True)
# email = models.EmailField(null=True, blank=True)
# avatar = ImageField(upload_to='avatars', null=True, blank=True)
# location = models.CharField(max_length=255, null=True, blank=True)
# web = models.URLField(null=True, blank=True)
# bio = models.TextField(max_length=140, null=True, blank=True)
# is_first_login = models.BooleanField(default=True)
# time_created = models.DateTimeField(auto_now_add=True)
# time_updated = models.DateTimeField(auto_now=True)
# def activity(self):
# return {
# "objectType" : "person",
# "id": self.uuid,
# "displayName": self.name,
# "location": self.location,
# 'web': self.web,
# "bio": self.bio,
# }
# def __unicode__(self):
# return '%s' % self.user
# def get_absolute_url(self):
# return '/profile/%s' % self.id
# def save(self, *args, **kwargs):
# super(UserProfile, self).save()
# if not self.uuid:
# self.uuid = uuid.uuid4().urn
# if not self.email:
# self.email = self.user.email
# super(UserProfile, self).save()
# class Admin:
# pass
#
# class UserSettings(models.Model):
# user = models.ForeignKey(User)
# notify_comment_on_file = models.BooleanField(default=False)
# notify_comment_on_collection = models.BooleanField(default=False)
# notify_same_file = models.BooleanField(default=False)
# publish_avatar = models.BooleanField(default=False)
# post_as_self = models.BooleanField(default=False)
# time_created = models.DateTimeField(auto_now_add=True)
# last_updated = models.DateTimeField(auto_now=True)
# def __unicode__(self):
# return '%s' % self.user
# class Admin:
# pass
#
# class PubSubNode(models.Model):
# node = models.CharField(max_length=255, unique=True)
# name = models.CharField(max_length=255, unique=False)
# time_created = models.DateTimeField(auto_now_add=True)
# last_updated = models.DateTimeField(auto_now=True)
# def __unicode__(self):
# return '%s' % self.name
# class Admin:
# pass
. Output only the next line. | 'collection': collection, |
Given the following code snippet before the placeholder: <|code_start|> class Meta:
model = Collection
fields = ('tags',)
class CollectionCommentForm(forms.ModelForm):
class Meta:
model = CollectionComment
fields = ('content',)
class CollectionForm(forms.ModelForm):
class Meta:
model = Collection
fields = ('title', 'tags', 'description')
class UploadFileForm(forms.ModelForm):
file = forms.FileField(required=True)
#url = forms.CharField(required=False)
#hash = forms.CharField(required=False)
class Meta:
model = File
fields = ('description', 'tags')
class UserProfileForm(forms.ModelForm):
class Meta:
model = UserProfile
exclude = ('user', 'uuid')
class UserSettingsForm(forms.ModelForm):
class Meta:
model = UserSettings
<|code_end|>
, predict the next line using imports from the current file:
from django import forms
from django_fordrop.models import UserProfile, UserSettings
from models import File, FileComment, CollectionComment, Collection
and context including class names, function names, and sometimes code from other files:
# Path: django_fordrop/models.py
# class UserProfile(models.Model):
# user = models.ForeignKey(User, unique=True, null=True, blank=True)
# uuid = models.CharField(max_length=255, null=True, blank=True)
# name = models.CharField(max_length=255, null=True, blank=True)
# email = models.EmailField(null=True, blank=True)
# avatar = ImageField(upload_to='avatars', null=True, blank=True)
# location = models.CharField(max_length=255, null=True, blank=True)
# web = models.URLField(null=True, blank=True)
# bio = models.TextField(max_length=140, null=True, blank=True)
# is_first_login = models.BooleanField(default=True)
# time_created = models.DateTimeField(auto_now_add=True)
# time_updated = models.DateTimeField(auto_now=True)
# def activity(self):
# return {
# "objectType" : "person",
# "id": self.uuid,
# "displayName": self.name,
# "location": self.location,
# 'web': self.web,
# "bio": self.bio,
# }
# def __unicode__(self):
# return '%s' % self.user
# def get_absolute_url(self):
# return '/profile/%s' % self.id
# def save(self, *args, **kwargs):
# super(UserProfile, self).save()
# if not self.uuid:
# self.uuid = uuid.uuid4().urn
# if not self.email:
# self.email = self.user.email
# super(UserProfile, self).save()
# class Admin:
# pass
#
# class UserSettings(models.Model):
# user = models.ForeignKey(User)
# notify_comment_on_file = models.BooleanField(default=False)
# notify_comment_on_collection = models.BooleanField(default=False)
# notify_same_file = models.BooleanField(default=False)
# publish_avatar = models.BooleanField(default=False)
# post_as_self = models.BooleanField(default=False)
# time_created = models.DateTimeField(auto_now_add=True)
# last_updated = models.DateTimeField(auto_now=True)
# def __unicode__(self):
# return '%s' % self.user
# class Admin:
# pass
. Output only the next line. | exclude = ('user') |
Using the snippet: <|code_start|>
class CommentInline(admin.StackedInline):
model = Comment
ordering = ('-last_edited_on',)
@register(News)
class NewsAdmin(admin.ModelAdmin):
list_display = ('id', 'title', 'author', 'class_number', 'class_letter', 'posted_on')
date_hierarchy = 'posted_on'
<|code_end|>
, determine the next line of code. You have imports:
from django.contrib import admin
from django.contrib.admin.decorators import register
from .models import News, Comment
and context (class names, function names, or code) available:
# Path: news/models.py
# class News(AbstractPost):
# title = models.CharField(max_length=100, blank=False)
# content = models.TextField(max_length=10000, blank=False)
# class_number = models.IntegerField(
# default=8,
# validators=[Class.CLASS_NUMBER_VALIDATORS],
# choices=Class.CLASS_NUMBERS
# )
# class_letter = models.CharField(
# max_length=1,
# blank=True,
# choices=Class.CLASS_LETTERS
# )
#
# def __str__(self):
# return '{} ({})'.format(self.title, self.posted_on.date())
#
# class Meta:
# ordering = ['-last_edited_on']
# verbose_name_plural = 'news'
#
# class Comment(AbstractPost):
# news = models.ForeignKey(News, related_name='comments', on_delete=models.CASCADE)
# author_image = models.URLField(blank=True)
# content = models.TextField(max_length=2048)
#
# def __str__(self):
# return '{} - {}'.format(self.author, self.news)
#
# class Meta:
# ordering = ['-posted_on']
. Output only the next line. | list_filter = ('class_number', 'class_letter', 'author') |
Given snippet: <|code_start|>
app_name = 'talks'
meetups_router = routers.SimpleRouter()
meetups_router.register(r'meetups', MeetupsViewSet, base_name='meetups')
talks_router = routers.NestedSimpleRouter(
parent_router=meetups_router,
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.conf.urls import url
from rest_framework_nested import routers
from .views import MeetupsViewSet, TalksViewSet
and context:
# Path: talks/views.py
# class MeetupsViewSet(viewsets.ModelViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated,),
# 'retrieve': (IsAuthenticated,),
# 'create': (IsAdminUser,),
# 'update': (IsAdminUser,),
# 'destroy': (IsAdminUser,),
# }
# queryset = Meetup.objects.all()
# filter_backends = (MeetupsFilterBackend,)
# serializer_class = MeetupSerializer
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# class TalksViewSet(viewsets.ModelViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated,),
# 'retrieve': (IsAuthenticated,),
# 'create': (IsAuthenticated,),
# 'update': (IsAuthenticated, IsUserAuthor),
# 'upvote': (IsAuthenticated,),
# 'downvote': (IsAuthenticated,),
# 'destroy': (IsAdminUser,),
# }
# serializer_class = TalkSerializer
# filter_backends = (FullWordSearchFilter,)
# word_filters = ('topic', 'author__username')
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_related_meetup(self):
# return generics.get_object_or_404(Meetup, id=self.kwargs['meetups_pk'])
#
# def get_queryset(self):
# meetup = self.get_related_meetup()
# return meetup.talks.all()
#
# def get_object(self):
# return generics.get_object_or_404(self.get_queryset(), id=self.kwargs['pk'])
#
# def create(self, request, *args, **kwargs):
# context = {
# 'request': request,
# 'meetup': self.get_related_meetup()
# }
#
# serializer = self.get_serializer_class()(data=request.data, context=context)
# serializer.is_valid(raise_exception=True)
# self.perform_create(serializer)
#
# headers = self.get_success_headers(serializer.data)
#
# return Response(serializer.validated_data, status=status.HTTP_201_CREATED, headers=headers)
#
# def update(self, request, *args, **kwargs):
# talk = self.get_object()
# self.check_object_permissions(request, talk)
#
# serializer = self.get_serializer(talk, data=request.data, partial=True)
# serializer.is_valid(raise_exception=True)
# self.perform_update(serializer)
#
# return Response(serializer.data, status=status.HTTP_200_OK)
#
# def vote(self, request, up=True):
# talk = self.get_object()
#
# if up:
# talk.votes.up(request.user.id)
# else:
# talk.votes.down(request.user.id)
#
# return Response({'votes_count': talk.votes.count()}, status=status.HTTP_200_OK)
#
# @detail_route(methods=['put'])
# def upvote(self, request, *args, **kwargs):
# return self.vote(request, up=True)
#
# @detail_route(methods=['put'])
# def downvote(self, request, *args, **kwargs):
# return self.vote(request, up=False)
which might include code, classes, or functions. Output only the next line. | parent_prefix=r'meetups', |
Continue the code snippet: <|code_start|>
app_name = 'talks'
meetups_router = routers.SimpleRouter()
meetups_router.register(r'meetups', MeetupsViewSet, base_name='meetups')
<|code_end|>
. Use current file imports:
from django.conf.urls import url
from rest_framework_nested import routers
from .views import MeetupsViewSet, TalksViewSet
and context (classes, functions, or code) from other files:
# Path: talks/views.py
# class MeetupsViewSet(viewsets.ModelViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated,),
# 'retrieve': (IsAuthenticated,),
# 'create': (IsAdminUser,),
# 'update': (IsAdminUser,),
# 'destroy': (IsAdminUser,),
# }
# queryset = Meetup.objects.all()
# filter_backends = (MeetupsFilterBackend,)
# serializer_class = MeetupSerializer
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# class TalksViewSet(viewsets.ModelViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated,),
# 'retrieve': (IsAuthenticated,),
# 'create': (IsAuthenticated,),
# 'update': (IsAuthenticated, IsUserAuthor),
# 'upvote': (IsAuthenticated,),
# 'downvote': (IsAuthenticated,),
# 'destroy': (IsAdminUser,),
# }
# serializer_class = TalkSerializer
# filter_backends = (FullWordSearchFilter,)
# word_filters = ('topic', 'author__username')
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_related_meetup(self):
# return generics.get_object_or_404(Meetup, id=self.kwargs['meetups_pk'])
#
# def get_queryset(self):
# meetup = self.get_related_meetup()
# return meetup.talks.all()
#
# def get_object(self):
# return generics.get_object_or_404(self.get_queryset(), id=self.kwargs['pk'])
#
# def create(self, request, *args, **kwargs):
# context = {
# 'request': request,
# 'meetup': self.get_related_meetup()
# }
#
# serializer = self.get_serializer_class()(data=request.data, context=context)
# serializer.is_valid(raise_exception=True)
# self.perform_create(serializer)
#
# headers = self.get_success_headers(serializer.data)
#
# return Response(serializer.validated_data, status=status.HTTP_201_CREATED, headers=headers)
#
# def update(self, request, *args, **kwargs):
# talk = self.get_object()
# self.check_object_permissions(request, talk)
#
# serializer = self.get_serializer(talk, data=request.data, partial=True)
# serializer.is_valid(raise_exception=True)
# self.perform_update(serializer)
#
# return Response(serializer.data, status=status.HTTP_200_OK)
#
# def vote(self, request, up=True):
# talk = self.get_object()
#
# if up:
# talk.votes.up(request.user.id)
# else:
# talk.votes.down(request.user.id)
#
# return Response({'votes_count': talk.votes.count()}, status=status.HTTP_200_OK)
#
# @detail_route(methods=['put'])
# def upvote(self, request, *args, **kwargs):
# return self.vote(request, up=True)
#
# @detail_route(methods=['put'])
# def downvote(self, request, *args, **kwargs):
# return self.vote(request, up=False)
. Output only the next line. | talks_router = routers.NestedSimpleRouter( |
Using the snippet: <|code_start|> queryset = News.objects.all()
filter_backends = (TeachersListFilterBackend, ClassNumberFilterBackend, FullWordSearchFilter)
word_fields = ('title',)
def get_serializer_context(self):
context = super().get_serializer_context()
context['class_number'] = self.kwargs['class_number']
return context
class NewsTeachersViewSet(NewsDefaultViewSet):
permission_classes_by_action = {
'list': (IsAuthenticated, IsTeacher),
'retrieve': (IsAuthenticated, IsTeacher),
'create': (IsAuthenticated, IsTeacher),
'update': (IsAuthenticated, IsTeacher, IsUserAuthor),
'destroy': (IsAuthenticated, IsTeacher, IsUserAuthor)
}
filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
word_fields = ('title',)
def get_permissions(self):
return [
permission()
for permission
in self.permission_classes_by_action[self.action]
]
def get_clazz_info(self):
<|code_end|>
, determine the next line of code. You have imports:
from rest_framework import generics, viewsets
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsStudent, IsTeacher, IsUserAuthor
from .models import News
from .serializers import NewsSerializer, CommentSerializer, CommentReadSerializer
from .filters import TeachersListFilterBackend, ClassNumberFilterBackend
and context (class names, function names, or code) available:
# Path: students/permissions.py
# class IsStudent(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('student')
#
# def has_permission(self, request, view):
# return Student.objects.filter(user=request.user).exists()
#
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsUserAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user
#
# Path: news/models.py
# class News(AbstractPost):
# title = models.CharField(max_length=100, blank=False)
# content = models.TextField(max_length=10000, blank=False)
# class_number = models.IntegerField(
# default=8,
# validators=[Class.CLASS_NUMBER_VALIDATORS],
# choices=Class.CLASS_NUMBERS
# )
# class_letter = models.CharField(
# max_length=1,
# blank=True,
# choices=Class.CLASS_LETTERS
# )
#
# def __str__(self):
# return '{} ({})'.format(self.title, self.posted_on.date())
#
# class Meta:
# ordering = ['-last_edited_on']
# verbose_name_plural = 'news'
#
# Path: news/serializers.py
# class NewsSerializer(AbstractPostSerializer):
# title = serializers.CharField(min_length=3, max_length=100)
# content = serializers.CharField(min_length=5, max_length=10000)
# comments = CommentSerializer(read_only=True, many=True)
#
# class Meta:
# model = News
# fields = AbstractPostSerializer.Meta.fields + (
# 'id', 'title', 'content', 'class_number', 'class_letter', 'comments'
# )
#
# def create(self, validated_data):
# author = self.context['request'].user
# validated_data['class_number'] = self.context['class_number']
# validated_data['class_letter'] = self.context.get('class_letter', '')
#
# news = News.objects.create(author=author, **validated_data)
#
# return news
#
# class CommentSerializer(AbstractPostSerializer):
# author_image = serializers.SerializerMethodField()
# content = serializers.CharField(max_length=2048)
#
# class Meta:
# model = Comment
# fields = AbstractPostSerializer.Meta.fields + ('id', 'author_image', 'content')
#
# def get_author_image(self, obj):
# author = obj.author
#
# try:
# field = author.student
# except AttributeError:
# field = author.teacher
#
# return field.profile_image_url
#
# def create(self, validated_data):
# news = self.context['news']
# request = self.context['request']
#
# author = request.user
#
# return Comment.objects.create(news=news, author=author, **validated_data)
#
# class CommentReadSerializer(CommentSerializer):
# author = UserInfoSerializer(read_only=True)
#
# Path: news/filters.py
# class TeachersListFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(author=request.user)
#
# class ClassNumberFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(class_number=view.kwargs['class_number'])
. Output only the next line. | return self.kwargs |
Using the snippet: <|code_start|> 'destroy': (IsAuthenticated, IsTeacher, IsUserAuthor)
}
filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
word_fields = ('title',)
def get_permissions(self):
return [
permission()
for permission
in self.permission_classes_by_action[self.action]
]
def get_clazz_info(self):
return self.kwargs
class CommentsViewSet(viewsets.ModelViewSet):
permission_classes_by_action = {
'list': (IsAuthenticated,),
'retrieve': (IsAuthenticated,),
'create': (IsAuthenticated,),
'update': (IsAuthenticated, IsUserAuthor),
'destroy': (IsAuthenticated, IsUserAuthor)
}
def get_permissions(self):
return [
permission()
for permission
in self.permission_classes_by_action[self.action]
<|code_end|>
, determine the next line of code. You have imports:
from rest_framework import generics, viewsets
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsStudent, IsTeacher, IsUserAuthor
from .models import News
from .serializers import NewsSerializer, CommentSerializer, CommentReadSerializer
from .filters import TeachersListFilterBackend, ClassNumberFilterBackend
and context (class names, function names, or code) available:
# Path: students/permissions.py
# class IsStudent(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('student')
#
# def has_permission(self, request, view):
# return Student.objects.filter(user=request.user).exists()
#
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsUserAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user
#
# Path: news/models.py
# class News(AbstractPost):
# title = models.CharField(max_length=100, blank=False)
# content = models.TextField(max_length=10000, blank=False)
# class_number = models.IntegerField(
# default=8,
# validators=[Class.CLASS_NUMBER_VALIDATORS],
# choices=Class.CLASS_NUMBERS
# )
# class_letter = models.CharField(
# max_length=1,
# blank=True,
# choices=Class.CLASS_LETTERS
# )
#
# def __str__(self):
# return '{} ({})'.format(self.title, self.posted_on.date())
#
# class Meta:
# ordering = ['-last_edited_on']
# verbose_name_plural = 'news'
#
# Path: news/serializers.py
# class NewsSerializer(AbstractPostSerializer):
# title = serializers.CharField(min_length=3, max_length=100)
# content = serializers.CharField(min_length=5, max_length=10000)
# comments = CommentSerializer(read_only=True, many=True)
#
# class Meta:
# model = News
# fields = AbstractPostSerializer.Meta.fields + (
# 'id', 'title', 'content', 'class_number', 'class_letter', 'comments'
# )
#
# def create(self, validated_data):
# author = self.context['request'].user
# validated_data['class_number'] = self.context['class_number']
# validated_data['class_letter'] = self.context.get('class_letter', '')
#
# news = News.objects.create(author=author, **validated_data)
#
# return news
#
# class CommentSerializer(AbstractPostSerializer):
# author_image = serializers.SerializerMethodField()
# content = serializers.CharField(max_length=2048)
#
# class Meta:
# model = Comment
# fields = AbstractPostSerializer.Meta.fields + ('id', 'author_image', 'content')
#
# def get_author_image(self, obj):
# author = obj.author
#
# try:
# field = author.student
# except AttributeError:
# field = author.teacher
#
# return field.profile_image_url
#
# def create(self, validated_data):
# news = self.context['news']
# request = self.context['request']
#
# author = request.user
#
# return Comment.objects.create(news=news, author=author, **validated_data)
#
# class CommentReadSerializer(CommentSerializer):
# author = UserInfoSerializer(read_only=True)
#
# Path: news/filters.py
# class TeachersListFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(author=request.user)
#
# class ClassNumberFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(class_number=view.kwargs['class_number'])
. Output only the next line. | ] |
Based on the snippet: <|code_start|> 'update': (IsAuthenticated, IsTeacher, IsUserAuthor),
'destroy': (IsAuthenticated, IsTeacher, IsUserAuthor)
}
filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
word_fields = ('title',)
def get_permissions(self):
return [
permission()
for permission
in self.permission_classes_by_action[self.action]
]
def get_clazz_info(self):
return self.kwargs
class CommentsViewSet(viewsets.ModelViewSet):
permission_classes_by_action = {
'list': (IsAuthenticated,),
'retrieve': (IsAuthenticated,),
'create': (IsAuthenticated,),
'update': (IsAuthenticated, IsUserAuthor),
'destroy': (IsAuthenticated, IsUserAuthor)
}
def get_permissions(self):
return [
permission()
for permission
<|code_end|>
, predict the immediate next line with the help of imports:
from rest_framework import generics, viewsets
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsStudent, IsTeacher, IsUserAuthor
from .models import News
from .serializers import NewsSerializer, CommentSerializer, CommentReadSerializer
from .filters import TeachersListFilterBackend, ClassNumberFilterBackend
and context (classes, functions, sometimes code) from other files:
# Path: students/permissions.py
# class IsStudent(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('student')
#
# def has_permission(self, request, view):
# return Student.objects.filter(user=request.user).exists()
#
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsUserAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user
#
# Path: news/models.py
# class News(AbstractPost):
# title = models.CharField(max_length=100, blank=False)
# content = models.TextField(max_length=10000, blank=False)
# class_number = models.IntegerField(
# default=8,
# validators=[Class.CLASS_NUMBER_VALIDATORS],
# choices=Class.CLASS_NUMBERS
# )
# class_letter = models.CharField(
# max_length=1,
# blank=True,
# choices=Class.CLASS_LETTERS
# )
#
# def __str__(self):
# return '{} ({})'.format(self.title, self.posted_on.date())
#
# class Meta:
# ordering = ['-last_edited_on']
# verbose_name_plural = 'news'
#
# Path: news/serializers.py
# class NewsSerializer(AbstractPostSerializer):
# title = serializers.CharField(min_length=3, max_length=100)
# content = serializers.CharField(min_length=5, max_length=10000)
# comments = CommentSerializer(read_only=True, many=True)
#
# class Meta:
# model = News
# fields = AbstractPostSerializer.Meta.fields + (
# 'id', 'title', 'content', 'class_number', 'class_letter', 'comments'
# )
#
# def create(self, validated_data):
# author = self.context['request'].user
# validated_data['class_number'] = self.context['class_number']
# validated_data['class_letter'] = self.context.get('class_letter', '')
#
# news = News.objects.create(author=author, **validated_data)
#
# return news
#
# class CommentSerializer(AbstractPostSerializer):
# author_image = serializers.SerializerMethodField()
# content = serializers.CharField(max_length=2048)
#
# class Meta:
# model = Comment
# fields = AbstractPostSerializer.Meta.fields + ('id', 'author_image', 'content')
#
# def get_author_image(self, obj):
# author = obj.author
#
# try:
# field = author.student
# except AttributeError:
# field = author.teacher
#
# return field.profile_image_url
#
# def create(self, validated_data):
# news = self.context['news']
# request = self.context['request']
#
# author = request.user
#
# return Comment.objects.create(news=news, author=author, **validated_data)
#
# class CommentReadSerializer(CommentSerializer):
# author = UserInfoSerializer(read_only=True)
#
# Path: news/filters.py
# class TeachersListFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(author=request.user)
#
# class ClassNumberFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(class_number=view.kwargs['class_number'])
. Output only the next line. | in self.permission_classes_by_action[self.action] |
Next line prediction: <|code_start|> common_news = News.objects.filter(class_number=class_number, class_letter='')
news = News.objects.filter(class_number=class_number, class_letter=class_letter)
return common_news | news
class NewsStudentsViewSet(NewsDefaultViewSet):
permission_classes_by_action = {
'list': (IsAuthenticated, IsStudent),
'retrieve': (IsAuthenticated, IsStudent),
'create': (IsAuthenticated, IsStudent),
'update': (IsAuthenticated, IsStudent, IsUserAuthor),
'destroy': (IsAuthenticated, IsStudent, IsUserAuthor)
}
filter_backends = (FullWordSearchFilter,)
word_fields = ('title', 'author__username')
def get_permissions(self):
return [
permission()
for permission
in self.permission_classes_by_action[self.action]
]
def get_clazz_info(self):
clazz = self.request.user.student.clazz
return {
'class_number': clazz.number,
'class_letter': clazz.letter
<|code_end|>
. Use current file imports:
(from rest_framework import generics, viewsets
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsStudent, IsTeacher, IsUserAuthor
from .models import News
from .serializers import NewsSerializer, CommentSerializer, CommentReadSerializer
from .filters import TeachersListFilterBackend, ClassNumberFilterBackend)
and context including class names, function names, or small code snippets from other files:
# Path: students/permissions.py
# class IsStudent(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('student')
#
# def has_permission(self, request, view):
# return Student.objects.filter(user=request.user).exists()
#
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsUserAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user
#
# Path: news/models.py
# class News(AbstractPost):
# title = models.CharField(max_length=100, blank=False)
# content = models.TextField(max_length=10000, blank=False)
# class_number = models.IntegerField(
# default=8,
# validators=[Class.CLASS_NUMBER_VALIDATORS],
# choices=Class.CLASS_NUMBERS
# )
# class_letter = models.CharField(
# max_length=1,
# blank=True,
# choices=Class.CLASS_LETTERS
# )
#
# def __str__(self):
# return '{} ({})'.format(self.title, self.posted_on.date())
#
# class Meta:
# ordering = ['-last_edited_on']
# verbose_name_plural = 'news'
#
# Path: news/serializers.py
# class NewsSerializer(AbstractPostSerializer):
# title = serializers.CharField(min_length=3, max_length=100)
# content = serializers.CharField(min_length=5, max_length=10000)
# comments = CommentSerializer(read_only=True, many=True)
#
# class Meta:
# model = News
# fields = AbstractPostSerializer.Meta.fields + (
# 'id', 'title', 'content', 'class_number', 'class_letter', 'comments'
# )
#
# def create(self, validated_data):
# author = self.context['request'].user
# validated_data['class_number'] = self.context['class_number']
# validated_data['class_letter'] = self.context.get('class_letter', '')
#
# news = News.objects.create(author=author, **validated_data)
#
# return news
#
# class CommentSerializer(AbstractPostSerializer):
# author_image = serializers.SerializerMethodField()
# content = serializers.CharField(max_length=2048)
#
# class Meta:
# model = Comment
# fields = AbstractPostSerializer.Meta.fields + ('id', 'author_image', 'content')
#
# def get_author_image(self, obj):
# author = obj.author
#
# try:
# field = author.student
# except AttributeError:
# field = author.teacher
#
# return field.profile_image_url
#
# def create(self, validated_data):
# news = self.context['news']
# request = self.context['request']
#
# author = request.user
#
# return Comment.objects.create(news=news, author=author, **validated_data)
#
# class CommentReadSerializer(CommentSerializer):
# author = UserInfoSerializer(read_only=True)
#
# Path: news/filters.py
# class TeachersListFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(author=request.user)
#
# class ClassNumberFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(class_number=view.kwargs['class_number'])
. Output only the next line. | } |
Given snippet: <|code_start|> queryset = News.objects.all()
filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
word_fields = ('title',)
class NewsTeachersClassNumberList(generics.ListCreateAPIView):
permission_classes = (IsAuthenticated, IsTeacher)
serializer_class = NewsSerializer
queryset = News.objects.all()
filter_backends = (TeachersListFilterBackend, ClassNumberFilterBackend, FullWordSearchFilter)
word_fields = ('title',)
def get_serializer_context(self):
context = super().get_serializer_context()
context['class_number'] = self.kwargs['class_number']
return context
class NewsTeachersViewSet(NewsDefaultViewSet):
permission_classes_by_action = {
'list': (IsAuthenticated, IsTeacher),
'retrieve': (IsAuthenticated, IsTeacher),
'create': (IsAuthenticated, IsTeacher),
'update': (IsAuthenticated, IsTeacher, IsUserAuthor),
'destroy': (IsAuthenticated, IsTeacher, IsUserAuthor)
}
filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
word_fields = ('title',)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from rest_framework import generics, viewsets
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsStudent, IsTeacher, IsUserAuthor
from .models import News
from .serializers import NewsSerializer, CommentSerializer, CommentReadSerializer
from .filters import TeachersListFilterBackend, ClassNumberFilterBackend
and context:
# Path: students/permissions.py
# class IsStudent(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('student')
#
# def has_permission(self, request, view):
# return Student.objects.filter(user=request.user).exists()
#
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsUserAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user
#
# Path: news/models.py
# class News(AbstractPost):
# title = models.CharField(max_length=100, blank=False)
# content = models.TextField(max_length=10000, blank=False)
# class_number = models.IntegerField(
# default=8,
# validators=[Class.CLASS_NUMBER_VALIDATORS],
# choices=Class.CLASS_NUMBERS
# )
# class_letter = models.CharField(
# max_length=1,
# blank=True,
# choices=Class.CLASS_LETTERS
# )
#
# def __str__(self):
# return '{} ({})'.format(self.title, self.posted_on.date())
#
# class Meta:
# ordering = ['-last_edited_on']
# verbose_name_plural = 'news'
#
# Path: news/serializers.py
# class NewsSerializer(AbstractPostSerializer):
# title = serializers.CharField(min_length=3, max_length=100)
# content = serializers.CharField(min_length=5, max_length=10000)
# comments = CommentSerializer(read_only=True, many=True)
#
# class Meta:
# model = News
# fields = AbstractPostSerializer.Meta.fields + (
# 'id', 'title', 'content', 'class_number', 'class_letter', 'comments'
# )
#
# def create(self, validated_data):
# author = self.context['request'].user
# validated_data['class_number'] = self.context['class_number']
# validated_data['class_letter'] = self.context.get('class_letter', '')
#
# news = News.objects.create(author=author, **validated_data)
#
# return news
#
# class CommentSerializer(AbstractPostSerializer):
# author_image = serializers.SerializerMethodField()
# content = serializers.CharField(max_length=2048)
#
# class Meta:
# model = Comment
# fields = AbstractPostSerializer.Meta.fields + ('id', 'author_image', 'content')
#
# def get_author_image(self, obj):
# author = obj.author
#
# try:
# field = author.student
# except AttributeError:
# field = author.teacher
#
# return field.profile_image_url
#
# def create(self, validated_data):
# news = self.context['news']
# request = self.context['request']
#
# author = request.user
#
# return Comment.objects.create(news=news, author=author, **validated_data)
#
# class CommentReadSerializer(CommentSerializer):
# author = UserInfoSerializer(read_only=True)
#
# Path: news/filters.py
# class TeachersListFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(author=request.user)
#
# class ClassNumberFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(class_number=view.kwargs['class_number'])
which might include code, classes, or functions. Output only the next line. | def get_permissions(self): |
Here is a snippet: <|code_start|> permission()
for permission
in self.permission_classes_by_action[self.action]
]
def get_clazz_info(self):
clazz = self.request.user.student.clazz
return {
'class_number': clazz.number,
'class_letter': clazz.letter
}
class NewsTeachersList(generics.ListAPIView):
permission_classes = (IsAuthenticated, IsTeacher)
serializer_class = NewsSerializer
queryset = News.objects.all()
filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
word_fields = ('title',)
class NewsTeachersClassNumberList(generics.ListCreateAPIView):
permission_classes = (IsAuthenticated, IsTeacher)
serializer_class = NewsSerializer
queryset = News.objects.all()
filter_backends = (TeachersListFilterBackend, ClassNumberFilterBackend, FullWordSearchFilter)
word_fields = ('title',)
def get_serializer_context(self):
<|code_end|>
. Write the next line using the current file imports:
from rest_framework import generics, viewsets
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsStudent, IsTeacher, IsUserAuthor
from .models import News
from .serializers import NewsSerializer, CommentSerializer, CommentReadSerializer
from .filters import TeachersListFilterBackend, ClassNumberFilterBackend
and context from other files:
# Path: students/permissions.py
# class IsStudent(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('student')
#
# def has_permission(self, request, view):
# return Student.objects.filter(user=request.user).exists()
#
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsUserAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user
#
# Path: news/models.py
# class News(AbstractPost):
# title = models.CharField(max_length=100, blank=False)
# content = models.TextField(max_length=10000, blank=False)
# class_number = models.IntegerField(
# default=8,
# validators=[Class.CLASS_NUMBER_VALIDATORS],
# choices=Class.CLASS_NUMBERS
# )
# class_letter = models.CharField(
# max_length=1,
# blank=True,
# choices=Class.CLASS_LETTERS
# )
#
# def __str__(self):
# return '{} ({})'.format(self.title, self.posted_on.date())
#
# class Meta:
# ordering = ['-last_edited_on']
# verbose_name_plural = 'news'
#
# Path: news/serializers.py
# class NewsSerializer(AbstractPostSerializer):
# title = serializers.CharField(min_length=3, max_length=100)
# content = serializers.CharField(min_length=5, max_length=10000)
# comments = CommentSerializer(read_only=True, many=True)
#
# class Meta:
# model = News
# fields = AbstractPostSerializer.Meta.fields + (
# 'id', 'title', 'content', 'class_number', 'class_letter', 'comments'
# )
#
# def create(self, validated_data):
# author = self.context['request'].user
# validated_data['class_number'] = self.context['class_number']
# validated_data['class_letter'] = self.context.get('class_letter', '')
#
# news = News.objects.create(author=author, **validated_data)
#
# return news
#
# class CommentSerializer(AbstractPostSerializer):
# author_image = serializers.SerializerMethodField()
# content = serializers.CharField(max_length=2048)
#
# class Meta:
# model = Comment
# fields = AbstractPostSerializer.Meta.fields + ('id', 'author_image', 'content')
#
# def get_author_image(self, obj):
# author = obj.author
#
# try:
# field = author.student
# except AttributeError:
# field = author.teacher
#
# return field.profile_image_url
#
# def create(self, validated_data):
# news = self.context['news']
# request = self.context['request']
#
# author = request.user
#
# return Comment.objects.create(news=news, author=author, **validated_data)
#
# class CommentReadSerializer(CommentSerializer):
# author = UserInfoSerializer(read_only=True)
#
# Path: news/filters.py
# class TeachersListFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(author=request.user)
#
# class ClassNumberFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(class_number=view.kwargs['class_number'])
, which may include functions, classes, or code. Output only the next line. | context = super().get_serializer_context() |
Given the code snippet: <|code_start|>class NewsDefaultViewSet(viewsets.ModelViewSet):
serializer_class = NewsSerializer
def get_clazz_info(self):
raise NotImplementedError()
def get_serializer_context(self):
context = super().get_serializer_context()
return dict(context, **self.get_clazz_info())
def get_queryset(self):
class_info = self.get_clazz_info()
class_number = class_info['class_number']
class_letter = class_info['class_letter']
common_news = News.objects.filter(class_number=class_number, class_letter='')
news = News.objects.filter(class_number=class_number, class_letter=class_letter)
return common_news | news
class NewsStudentsViewSet(NewsDefaultViewSet):
permission_classes_by_action = {
'list': (IsAuthenticated, IsStudent),
'retrieve': (IsAuthenticated, IsStudent),
'create': (IsAuthenticated, IsStudent),
'update': (IsAuthenticated, IsStudent, IsUserAuthor),
'destroy': (IsAuthenticated, IsStudent, IsUserAuthor)
}
<|code_end|>
, generate the next line using the imports in this file:
from rest_framework import generics, viewsets
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsStudent, IsTeacher, IsUserAuthor
from .models import News
from .serializers import NewsSerializer, CommentSerializer, CommentReadSerializer
from .filters import TeachersListFilterBackend, ClassNumberFilterBackend
and context (functions, classes, or occasionally code) from other files:
# Path: students/permissions.py
# class IsStudent(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('student')
#
# def has_permission(self, request, view):
# return Student.objects.filter(user=request.user).exists()
#
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsUserAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user
#
# Path: news/models.py
# class News(AbstractPost):
# title = models.CharField(max_length=100, blank=False)
# content = models.TextField(max_length=10000, blank=False)
# class_number = models.IntegerField(
# default=8,
# validators=[Class.CLASS_NUMBER_VALIDATORS],
# choices=Class.CLASS_NUMBERS
# )
# class_letter = models.CharField(
# max_length=1,
# blank=True,
# choices=Class.CLASS_LETTERS
# )
#
# def __str__(self):
# return '{} ({})'.format(self.title, self.posted_on.date())
#
# class Meta:
# ordering = ['-last_edited_on']
# verbose_name_plural = 'news'
#
# Path: news/serializers.py
# class NewsSerializer(AbstractPostSerializer):
# title = serializers.CharField(min_length=3, max_length=100)
# content = serializers.CharField(min_length=5, max_length=10000)
# comments = CommentSerializer(read_only=True, many=True)
#
# class Meta:
# model = News
# fields = AbstractPostSerializer.Meta.fields + (
# 'id', 'title', 'content', 'class_number', 'class_letter', 'comments'
# )
#
# def create(self, validated_data):
# author = self.context['request'].user
# validated_data['class_number'] = self.context['class_number']
# validated_data['class_letter'] = self.context.get('class_letter', '')
#
# news = News.objects.create(author=author, **validated_data)
#
# return news
#
# class CommentSerializer(AbstractPostSerializer):
# author_image = serializers.SerializerMethodField()
# content = serializers.CharField(max_length=2048)
#
# class Meta:
# model = Comment
# fields = AbstractPostSerializer.Meta.fields + ('id', 'author_image', 'content')
#
# def get_author_image(self, obj):
# author = obj.author
#
# try:
# field = author.student
# except AttributeError:
# field = author.teacher
#
# return field.profile_image_url
#
# def create(self, validated_data):
# news = self.context['news']
# request = self.context['request']
#
# author = request.user
#
# return Comment.objects.create(news=news, author=author, **validated_data)
#
# class CommentReadSerializer(CommentSerializer):
# author = UserInfoSerializer(read_only=True)
#
# Path: news/filters.py
# class TeachersListFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(author=request.user)
#
# class ClassNumberFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(class_number=view.kwargs['class_number'])
. Output only the next line. | filter_backends = (FullWordSearchFilter,) |
Given the following code snippet before the placeholder: <|code_start|>class NewsTeachersClassNumberList(generics.ListCreateAPIView):
permission_classes = (IsAuthenticated, IsTeacher)
serializer_class = NewsSerializer
queryset = News.objects.all()
filter_backends = (TeachersListFilterBackend, ClassNumberFilterBackend, FullWordSearchFilter)
word_fields = ('title',)
def get_serializer_context(self):
context = super().get_serializer_context()
context['class_number'] = self.kwargs['class_number']
return context
class NewsTeachersViewSet(NewsDefaultViewSet):
permission_classes_by_action = {
'list': (IsAuthenticated, IsTeacher),
'retrieve': (IsAuthenticated, IsTeacher),
'create': (IsAuthenticated, IsTeacher),
'update': (IsAuthenticated, IsTeacher, IsUserAuthor),
'destroy': (IsAuthenticated, IsTeacher, IsUserAuthor)
}
filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
word_fields = ('title',)
def get_permissions(self):
return [
permission()
for permission
in self.permission_classes_by_action[self.action]
<|code_end|>
, predict the next line using imports from the current file:
from rest_framework import generics, viewsets
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsStudent, IsTeacher, IsUserAuthor
from .models import News
from .serializers import NewsSerializer, CommentSerializer, CommentReadSerializer
from .filters import TeachersListFilterBackend, ClassNumberFilterBackend
and context including class names, function names, and sometimes code from other files:
# Path: students/permissions.py
# class IsStudent(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('student')
#
# def has_permission(self, request, view):
# return Student.objects.filter(user=request.user).exists()
#
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsUserAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user
#
# Path: news/models.py
# class News(AbstractPost):
# title = models.CharField(max_length=100, blank=False)
# content = models.TextField(max_length=10000, blank=False)
# class_number = models.IntegerField(
# default=8,
# validators=[Class.CLASS_NUMBER_VALIDATORS],
# choices=Class.CLASS_NUMBERS
# )
# class_letter = models.CharField(
# max_length=1,
# blank=True,
# choices=Class.CLASS_LETTERS
# )
#
# def __str__(self):
# return '{} ({})'.format(self.title, self.posted_on.date())
#
# class Meta:
# ordering = ['-last_edited_on']
# verbose_name_plural = 'news'
#
# Path: news/serializers.py
# class NewsSerializer(AbstractPostSerializer):
# title = serializers.CharField(min_length=3, max_length=100)
# content = serializers.CharField(min_length=5, max_length=10000)
# comments = CommentSerializer(read_only=True, many=True)
#
# class Meta:
# model = News
# fields = AbstractPostSerializer.Meta.fields + (
# 'id', 'title', 'content', 'class_number', 'class_letter', 'comments'
# )
#
# def create(self, validated_data):
# author = self.context['request'].user
# validated_data['class_number'] = self.context['class_number']
# validated_data['class_letter'] = self.context.get('class_letter', '')
#
# news = News.objects.create(author=author, **validated_data)
#
# return news
#
# class CommentSerializer(AbstractPostSerializer):
# author_image = serializers.SerializerMethodField()
# content = serializers.CharField(max_length=2048)
#
# class Meta:
# model = Comment
# fields = AbstractPostSerializer.Meta.fields + ('id', 'author_image', 'content')
#
# def get_author_image(self, obj):
# author = obj.author
#
# try:
# field = author.student
# except AttributeError:
# field = author.teacher
#
# return field.profile_image_url
#
# def create(self, validated_data):
# news = self.context['news']
# request = self.context['request']
#
# author = request.user
#
# return Comment.objects.create(news=news, author=author, **validated_data)
#
# class CommentReadSerializer(CommentSerializer):
# author = UserInfoSerializer(read_only=True)
#
# Path: news/filters.py
# class TeachersListFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(author=request.user)
#
# class ClassNumberFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(class_number=view.kwargs['class_number'])
. Output only the next line. | ] |
Predict the next line after this snippet: <|code_start|> 'update': (IsAuthenticated, IsStudent, IsUserAuthor),
'destroy': (IsAuthenticated, IsStudent, IsUserAuthor)
}
filter_backends = (FullWordSearchFilter,)
word_fields = ('title', 'author__username')
def get_permissions(self):
return [
permission()
for permission
in self.permission_classes_by_action[self.action]
]
def get_clazz_info(self):
clazz = self.request.user.student.clazz
return {
'class_number': clazz.number,
'class_letter': clazz.letter
}
class NewsTeachersList(generics.ListAPIView):
permission_classes = (IsAuthenticated, IsTeacher)
serializer_class = NewsSerializer
queryset = News.objects.all()
filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
word_fields = ('title',)
<|code_end|>
using the current file's imports:
from rest_framework import generics, viewsets
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsStudent, IsTeacher, IsUserAuthor
from .models import News
from .serializers import NewsSerializer, CommentSerializer, CommentReadSerializer
from .filters import TeachersListFilterBackend, ClassNumberFilterBackend
and any relevant context from other files:
# Path: students/permissions.py
# class IsStudent(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('student')
#
# def has_permission(self, request, view):
# return Student.objects.filter(user=request.user).exists()
#
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsUserAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user
#
# Path: news/models.py
# class News(AbstractPost):
# title = models.CharField(max_length=100, blank=False)
# content = models.TextField(max_length=10000, blank=False)
# class_number = models.IntegerField(
# default=8,
# validators=[Class.CLASS_NUMBER_VALIDATORS],
# choices=Class.CLASS_NUMBERS
# )
# class_letter = models.CharField(
# max_length=1,
# blank=True,
# choices=Class.CLASS_LETTERS
# )
#
# def __str__(self):
# return '{} ({})'.format(self.title, self.posted_on.date())
#
# class Meta:
# ordering = ['-last_edited_on']
# verbose_name_plural = 'news'
#
# Path: news/serializers.py
# class NewsSerializer(AbstractPostSerializer):
# title = serializers.CharField(min_length=3, max_length=100)
# content = serializers.CharField(min_length=5, max_length=10000)
# comments = CommentSerializer(read_only=True, many=True)
#
# class Meta:
# model = News
# fields = AbstractPostSerializer.Meta.fields + (
# 'id', 'title', 'content', 'class_number', 'class_letter', 'comments'
# )
#
# def create(self, validated_data):
# author = self.context['request'].user
# validated_data['class_number'] = self.context['class_number']
# validated_data['class_letter'] = self.context.get('class_letter', '')
#
# news = News.objects.create(author=author, **validated_data)
#
# return news
#
# class CommentSerializer(AbstractPostSerializer):
# author_image = serializers.SerializerMethodField()
# content = serializers.CharField(max_length=2048)
#
# class Meta:
# model = Comment
# fields = AbstractPostSerializer.Meta.fields + ('id', 'author_image', 'content')
#
# def get_author_image(self, obj):
# author = obj.author
#
# try:
# field = author.student
# except AttributeError:
# field = author.teacher
#
# return field.profile_image_url
#
# def create(self, validated_data):
# news = self.context['news']
# request = self.context['request']
#
# author = request.user
#
# return Comment.objects.create(news=news, author=author, **validated_data)
#
# class CommentReadSerializer(CommentSerializer):
# author = UserInfoSerializer(read_only=True)
#
# Path: news/filters.py
# class TeachersListFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(author=request.user)
#
# class ClassNumberFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# return queryset.filter(class_number=view.kwargs['class_number'])
. Output only the next line. | class NewsTeachersClassNumberList(generics.ListCreateAPIView): |
Given the code snippet: <|code_start|>
app_name = 'homeworks'
router = routers.SimpleRouter()
router.register(r'homeworks', HomeworksViewSet, base_name='homeworks')
homework_submissions_router = routers.NestedSimpleRouter(router, r'homeworks', lookup='homeworks')
homework_submissions_router.register(r'submissions', SubmissionsViewSet, base_name='submissions')
urlpatterns = router.urls
<|code_end|>
, generate the next line using the imports in this file:
from rest_framework_nested import routers
from .views import HomeworksViewSet, SubmissionsViewSet
and context (functions, classes, or occasionally code) from other files:
# Path: homeworks/views.py
# class HomeworksViewSet(viewsets.ModelViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated,),
# 'retrieve': (IsAuthenticated,),
# 'create': (IsAuthenticated, IsTeacher),
# 'update': (IsAuthenticated, IsTeacher, IsTeacherAuthor),
# 'destroy': (IsAuthenticated, IsTeacher, IsTeacherAuthor)
# }
# queryset = Homework.objects.filter(deadline__gte=datetime.now())
# filter_backends = (HomeworksFilterBackend, FullWordSearchFilter)
# word_fields = ('topic', 'subject__title', 'author__user__username')
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_serializer_class(self):
# return HomeworkReadSerializer if self.request.method in ('GET',) else HomeworkSerializer
#
# def create(self, request, *args, **kwargs):
# clazz_data = request.data.get('clazz', {})
# clazz = get_object_or_404(Class, **clazz_data)
# context = {'request': request, 'clazz': clazz}
#
# serializer = self.get_serializer_class()(data=request.data, context=context)
# serializer.is_valid(raise_exception=True)
# self.perform_create(serializer)
#
# headers = self.get_success_headers(serializer.data)
#
# return Response(serializer.validated_data, status=status.HTTP_201_CREATED, headers=headers)
#
# class SubmissionsViewSet(viewsets.ModelViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated,),
# 'retrieve': (IsAuthenticated, IsValidStudent),
# 'create': (IsAuthenticated, IsStudent, HasOnlyOneSubmission),
# 'update': (IsAuthenticated, IsValidStudent, IsNotChecked),
# }
# filter_backends = (SubmissionsFilterBackend, FullWordSearchFilter)
# word_fields = ('student__user__username',)
# pagination_class = None
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_serializer_class(self):
# return SubmissionReadSerializer if self.request.method in ('GET',) else SubmissionSerializer
#
# def get_related_homework(self):
# return get_object_or_404(Homework, id=self.kwargs['homeworks_pk'])
#
# def get_queryset(self):
# homework = self.get_related_homework()
# return homework.submissions.all()
#
# def get_object(self):
# return get_object_or_404(self.get_queryset(), id=self.kwargs['pk'])
#
# def retrieve(self, request, *args, **kwargs):
# submission = self.get_object()
#
# if IsStudent().has_permission(request, self):
# self.check_object_permissions(request, submission)
#
# serializer = self.get_serializer(submission)
# headers = self.get_success_headers(serializer.data)
#
# return Response(serializer.data, status=status.HTTP_200_OK, headers=headers)
#
# def create(self, request, *args, **kwargs):
# homework = self.get_related_homework()
# self.check_object_permissions(request, homework)
#
# context = {'request': request, 'homework': homework}
#
# serializer = self.get_serializer_class()(context=context, data=request.data)
# serializer.is_valid(raise_exception=True)
# self.perform_create(serializer)
#
# headers = self.get_success_headers(serializer.data)
#
# return Response(serializer.validated_data, status=status.HTTP_201_CREATED, headers=headers)
#
# def update(self, request, *args, **kwargs):
# submission = self.get_object()
#
# if IsStudent().has_permission(request, self):
# self.check_object_permissions(request, submission)
#
# serializer = self.get_serializer(submission, data=request.data, partial=True)
# serializer.is_valid(raise_exception=True)
# self.perform_update(serializer)
#
# headers = self.get_success_headers(serializer.data)
#
# return Response(serializer.validated_data, status=status.HTTP_200_OK, headers=headers)
. Output only the next line. | urlpatterns += homework_submissions_router.urls |
Using the snippet: <|code_start|>
app_name = 'homeworks'
router = routers.SimpleRouter()
router.register(r'homeworks', HomeworksViewSet, base_name='homeworks')
homework_submissions_router = routers.NestedSimpleRouter(router, r'homeworks', lookup='homeworks')
homework_submissions_router.register(r'submissions', SubmissionsViewSet, base_name='submissions')
urlpatterns = router.urls
<|code_end|>
, determine the next line of code. You have imports:
from rest_framework_nested import routers
from .views import HomeworksViewSet, SubmissionsViewSet
and context (class names, function names, or code) available:
# Path: homeworks/views.py
# class HomeworksViewSet(viewsets.ModelViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated,),
# 'retrieve': (IsAuthenticated,),
# 'create': (IsAuthenticated, IsTeacher),
# 'update': (IsAuthenticated, IsTeacher, IsTeacherAuthor),
# 'destroy': (IsAuthenticated, IsTeacher, IsTeacherAuthor)
# }
# queryset = Homework.objects.filter(deadline__gte=datetime.now())
# filter_backends = (HomeworksFilterBackend, FullWordSearchFilter)
# word_fields = ('topic', 'subject__title', 'author__user__username')
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_serializer_class(self):
# return HomeworkReadSerializer if self.request.method in ('GET',) else HomeworkSerializer
#
# def create(self, request, *args, **kwargs):
# clazz_data = request.data.get('clazz', {})
# clazz = get_object_or_404(Class, **clazz_data)
# context = {'request': request, 'clazz': clazz}
#
# serializer = self.get_serializer_class()(data=request.data, context=context)
# serializer.is_valid(raise_exception=True)
# self.perform_create(serializer)
#
# headers = self.get_success_headers(serializer.data)
#
# return Response(serializer.validated_data, status=status.HTTP_201_CREATED, headers=headers)
#
# class SubmissionsViewSet(viewsets.ModelViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated,),
# 'retrieve': (IsAuthenticated, IsValidStudent),
# 'create': (IsAuthenticated, IsStudent, HasOnlyOneSubmission),
# 'update': (IsAuthenticated, IsValidStudent, IsNotChecked),
# }
# filter_backends = (SubmissionsFilterBackend, FullWordSearchFilter)
# word_fields = ('student__user__username',)
# pagination_class = None
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_serializer_class(self):
# return SubmissionReadSerializer if self.request.method in ('GET',) else SubmissionSerializer
#
# def get_related_homework(self):
# return get_object_or_404(Homework, id=self.kwargs['homeworks_pk'])
#
# def get_queryset(self):
# homework = self.get_related_homework()
# return homework.submissions.all()
#
# def get_object(self):
# return get_object_or_404(self.get_queryset(), id=self.kwargs['pk'])
#
# def retrieve(self, request, *args, **kwargs):
# submission = self.get_object()
#
# if IsStudent().has_permission(request, self):
# self.check_object_permissions(request, submission)
#
# serializer = self.get_serializer(submission)
# headers = self.get_success_headers(serializer.data)
#
# return Response(serializer.data, status=status.HTTP_200_OK, headers=headers)
#
# def create(self, request, *args, **kwargs):
# homework = self.get_related_homework()
# self.check_object_permissions(request, homework)
#
# context = {'request': request, 'homework': homework}
#
# serializer = self.get_serializer_class()(context=context, data=request.data)
# serializer.is_valid(raise_exception=True)
# self.perform_create(serializer)
#
# headers = self.get_success_headers(serializer.data)
#
# return Response(serializer.validated_data, status=status.HTTP_201_CREATED, headers=headers)
#
# def update(self, request, *args, **kwargs):
# submission = self.get_object()
#
# if IsStudent().has_permission(request, self):
# self.check_object_permissions(request, submission)
#
# serializer = self.get_serializer(submission, data=request.data, partial=True)
# serializer.is_valid(raise_exception=True)
# self.perform_update(serializer)
#
# headers = self.get_success_headers(serializer.data)
#
# return Response(serializer.validated_data, status=status.HTTP_200_OK, headers=headers)
. Output only the next line. | urlpatterns += homework_submissions_router.urls |
Here is a snippet: <|code_start|>
class Homework(models.Model):
topic = models.CharField(default='Homework', max_length=50)
subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
clazz = models.ForeignKey(Class, on_delete=models.CASCADE)
deadline = models.DateField(auto_now=False)
details = models.TextField(max_length=256, blank=True)
author = models.ForeignKey(Teacher, null=True, related_name='homeworks', on_delete=models.CASCADE)
def __str__(self):
return '{} ({}) - {}'.format(self.topic, self.subject, self.clazz)
class Meta:
ordering = ['deadline', 'clazz', 'subject']
class Submission(BaseAbstractPost):
homework = models.ForeignKey(Homework, related_name='submissions', on_delete=models.CASCADE)
student = models.ForeignKey(Student, related_name='submissions', on_delete=models.CASCADE)
content = models.TextField(max_length=2048)
solution_url = models.URLField(blank=True)
checked = models.BooleanField(default=False)
def __str__(self):
return '{} - {} ({})'.format(self.student, self.homework, self.posted_on)
<|code_end|>
. Write the next line using the current file imports:
from django.db import models
from students.models import Class, Subject, Teacher, Student
from news.models import BaseAbstractPost
and context from other files:
# Path: students/models.py
# class Class(models.Model):
# CLASS_NUMBERS = (
# (8, 8),
# (9, 9),
# (10, 10),
# (11, 11),
# (12, 12),
# )
# CLASS_NUMBER_VALIDATORS = [MinValueValidator(8), MaxValueValidator(12)]
#
# CLASS_LETTERS = (
# ('A', 'A'),
# ('B', 'B'),
# ('V', 'V'),
# ('G', 'G'),
# )
#
# number = models.IntegerField(validators=CLASS_NUMBER_VALIDATORS, choices=CLASS_NUMBERS)
# letter = models.CharField(max_length=1, choices=CLASS_LETTERS)
#
# def __str__(self):
# return '{}{}'.format(self.number, self.letter)
#
# class Meta:
# ordering = ['number', 'letter']
# verbose_name_plural = 'classes'
#
# class Subject(models.Model):
# title = models.CharField(unique=True, max_length=50)
#
# def __str__(self):
# return self.title
#
# class Meta:
# ordering = ['title']
#
# class Teacher(Account):
# subject = models.ForeignKey(Subject, related_name='teachers', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.subject)
#
# class Student(Account):
# clazz = models.ForeignKey(Class, related_name='students', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.clazz)
#
# Path: news/models.py
# class BaseAbstractPost(models.Model):
# posted_on = models.DateTimeField(auto_now_add=True)
# edited = models.BooleanField(default=False)
# last_edited_on = models.DateTimeField(auto_now=True)
#
# class Meta:
# abstract = True
, which may include functions, classes, or code. Output only the next line. | class Meta: |
Next line prediction: <|code_start|>
class Homework(models.Model):
topic = models.CharField(default='Homework', max_length=50)
subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
clazz = models.ForeignKey(Class, on_delete=models.CASCADE)
deadline = models.DateField(auto_now=False)
details = models.TextField(max_length=256, blank=True)
author = models.ForeignKey(Teacher, null=True, related_name='homeworks', on_delete=models.CASCADE)
def __str__(self):
return '{} ({}) - {}'.format(self.topic, self.subject, self.clazz)
class Meta:
ordering = ['deadline', 'clazz', 'subject']
class Submission(BaseAbstractPost):
homework = models.ForeignKey(Homework, related_name='submissions', on_delete=models.CASCADE)
student = models.ForeignKey(Student, related_name='submissions', on_delete=models.CASCADE)
<|code_end|>
. Use current file imports:
(from django.db import models
from students.models import Class, Subject, Teacher, Student
from news.models import BaseAbstractPost)
and context including class names, function names, or small code snippets from other files:
# Path: students/models.py
# class Class(models.Model):
# CLASS_NUMBERS = (
# (8, 8),
# (9, 9),
# (10, 10),
# (11, 11),
# (12, 12),
# )
# CLASS_NUMBER_VALIDATORS = [MinValueValidator(8), MaxValueValidator(12)]
#
# CLASS_LETTERS = (
# ('A', 'A'),
# ('B', 'B'),
# ('V', 'V'),
# ('G', 'G'),
# )
#
# number = models.IntegerField(validators=CLASS_NUMBER_VALIDATORS, choices=CLASS_NUMBERS)
# letter = models.CharField(max_length=1, choices=CLASS_LETTERS)
#
# def __str__(self):
# return '{}{}'.format(self.number, self.letter)
#
# class Meta:
# ordering = ['number', 'letter']
# verbose_name_plural = 'classes'
#
# class Subject(models.Model):
# title = models.CharField(unique=True, max_length=50)
#
# def __str__(self):
# return self.title
#
# class Meta:
# ordering = ['title']
#
# class Teacher(Account):
# subject = models.ForeignKey(Subject, related_name='teachers', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.subject)
#
# class Student(Account):
# clazz = models.ForeignKey(Class, related_name='students', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.clazz)
#
# Path: news/models.py
# class BaseAbstractPost(models.Model):
# posted_on = models.DateTimeField(auto_now_add=True)
# edited = models.BooleanField(default=False)
# last_edited_on = models.DateTimeField(auto_now=True)
#
# class Meta:
# abstract = True
. Output only the next line. | content = models.TextField(max_length=2048) |
Given snippet: <|code_start|>
class Homework(models.Model):
topic = models.CharField(default='Homework', max_length=50)
subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
clazz = models.ForeignKey(Class, on_delete=models.CASCADE)
deadline = models.DateField(auto_now=False)
details = models.TextField(max_length=256, blank=True)
author = models.ForeignKey(Teacher, null=True, related_name='homeworks', on_delete=models.CASCADE)
def __str__(self):
return '{} ({}) - {}'.format(self.topic, self.subject, self.clazz)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.db import models
from students.models import Class, Subject, Teacher, Student
from news.models import BaseAbstractPost
and context:
# Path: students/models.py
# class Class(models.Model):
# CLASS_NUMBERS = (
# (8, 8),
# (9, 9),
# (10, 10),
# (11, 11),
# (12, 12),
# )
# CLASS_NUMBER_VALIDATORS = [MinValueValidator(8), MaxValueValidator(12)]
#
# CLASS_LETTERS = (
# ('A', 'A'),
# ('B', 'B'),
# ('V', 'V'),
# ('G', 'G'),
# )
#
# number = models.IntegerField(validators=CLASS_NUMBER_VALIDATORS, choices=CLASS_NUMBERS)
# letter = models.CharField(max_length=1, choices=CLASS_LETTERS)
#
# def __str__(self):
# return '{}{}'.format(self.number, self.letter)
#
# class Meta:
# ordering = ['number', 'letter']
# verbose_name_plural = 'classes'
#
# class Subject(models.Model):
# title = models.CharField(unique=True, max_length=50)
#
# def __str__(self):
# return self.title
#
# class Meta:
# ordering = ['title']
#
# class Teacher(Account):
# subject = models.ForeignKey(Subject, related_name='teachers', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.subject)
#
# class Student(Account):
# clazz = models.ForeignKey(Class, related_name='students', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.clazz)
#
# Path: news/models.py
# class BaseAbstractPost(models.Model):
# posted_on = models.DateTimeField(auto_now_add=True)
# edited = models.BooleanField(default=False)
# last_edited_on = models.DateTimeField(auto_now=True)
#
# class Meta:
# abstract = True
which might include code, classes, or functions. Output only the next line. | class Meta: |
Continue the code snippet: <|code_start|>
class Homework(models.Model):
topic = models.CharField(default='Homework', max_length=50)
subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
clazz = models.ForeignKey(Class, on_delete=models.CASCADE)
deadline = models.DateField(auto_now=False)
details = models.TextField(max_length=256, blank=True)
author = models.ForeignKey(Teacher, null=True, related_name='homeworks', on_delete=models.CASCADE)
def __str__(self):
return '{} ({}) - {}'.format(self.topic, self.subject, self.clazz)
class Meta:
ordering = ['deadline', 'clazz', 'subject']
class Submission(BaseAbstractPost):
homework = models.ForeignKey(Homework, related_name='submissions', on_delete=models.CASCADE)
student = models.ForeignKey(Student, related_name='submissions', on_delete=models.CASCADE)
content = models.TextField(max_length=2048)
solution_url = models.URLField(blank=True)
<|code_end|>
. Use current file imports:
from django.db import models
from students.models import Class, Subject, Teacher, Student
from news.models import BaseAbstractPost
and context (classes, functions, or code) from other files:
# Path: students/models.py
# class Class(models.Model):
# CLASS_NUMBERS = (
# (8, 8),
# (9, 9),
# (10, 10),
# (11, 11),
# (12, 12),
# )
# CLASS_NUMBER_VALIDATORS = [MinValueValidator(8), MaxValueValidator(12)]
#
# CLASS_LETTERS = (
# ('A', 'A'),
# ('B', 'B'),
# ('V', 'V'),
# ('G', 'G'),
# )
#
# number = models.IntegerField(validators=CLASS_NUMBER_VALIDATORS, choices=CLASS_NUMBERS)
# letter = models.CharField(max_length=1, choices=CLASS_LETTERS)
#
# def __str__(self):
# return '{}{}'.format(self.number, self.letter)
#
# class Meta:
# ordering = ['number', 'letter']
# verbose_name_plural = 'classes'
#
# class Subject(models.Model):
# title = models.CharField(unique=True, max_length=50)
#
# def __str__(self):
# return self.title
#
# class Meta:
# ordering = ['title']
#
# class Teacher(Account):
# subject = models.ForeignKey(Subject, related_name='teachers', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.subject)
#
# class Student(Account):
# clazz = models.ForeignKey(Class, related_name='students', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.clazz)
#
# Path: news/models.py
# class BaseAbstractPost(models.Model):
# posted_on = models.DateTimeField(auto_now_add=True)
# edited = models.BooleanField(default=False)
# last_edited_on = models.DateTimeField(auto_now=True)
#
# class Meta:
# abstract = True
. Output only the next line. | checked = models.BooleanField(default=False) |
Using the snippet: <|code_start|>
class Homework(models.Model):
topic = models.CharField(default='Homework', max_length=50)
subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
clazz = models.ForeignKey(Class, on_delete=models.CASCADE)
deadline = models.DateField(auto_now=False)
details = models.TextField(max_length=256, blank=True)
author = models.ForeignKey(Teacher, null=True, related_name='homeworks', on_delete=models.CASCADE)
def __str__(self):
return '{} ({}) - {}'.format(self.topic, self.subject, self.clazz)
class Meta:
ordering = ['deadline', 'clazz', 'subject']
class Submission(BaseAbstractPost):
homework = models.ForeignKey(Homework, related_name='submissions', on_delete=models.CASCADE)
student = models.ForeignKey(Student, related_name='submissions', on_delete=models.CASCADE)
content = models.TextField(max_length=2048)
solution_url = models.URLField(blank=True)
checked = models.BooleanField(default=False)
def __str__(self):
return '{} - {} ({})'.format(self.student, self.homework, self.posted_on)
class Meta:
<|code_end|>
, determine the next line of code. You have imports:
from django.db import models
from students.models import Class, Subject, Teacher, Student
from news.models import BaseAbstractPost
and context (class names, function names, or code) available:
# Path: students/models.py
# class Class(models.Model):
# CLASS_NUMBERS = (
# (8, 8),
# (9, 9),
# (10, 10),
# (11, 11),
# (12, 12),
# )
# CLASS_NUMBER_VALIDATORS = [MinValueValidator(8), MaxValueValidator(12)]
#
# CLASS_LETTERS = (
# ('A', 'A'),
# ('B', 'B'),
# ('V', 'V'),
# ('G', 'G'),
# )
#
# number = models.IntegerField(validators=CLASS_NUMBER_VALIDATORS, choices=CLASS_NUMBERS)
# letter = models.CharField(max_length=1, choices=CLASS_LETTERS)
#
# def __str__(self):
# return '{}{}'.format(self.number, self.letter)
#
# class Meta:
# ordering = ['number', 'letter']
# verbose_name_plural = 'classes'
#
# class Subject(models.Model):
# title = models.CharField(unique=True, max_length=50)
#
# def __str__(self):
# return self.title
#
# class Meta:
# ordering = ['title']
#
# class Teacher(Account):
# subject = models.ForeignKey(Subject, related_name='teachers', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.subject)
#
# class Student(Account):
# clazz = models.ForeignKey(Class, related_name='students', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.clazz)
#
# Path: news/models.py
# class BaseAbstractPost(models.Model):
# posted_on = models.DateTimeField(auto_now_add=True)
# edited = models.BooleanField(default=False)
# last_edited_on = models.DateTimeField(auto_now=True)
#
# class Meta:
# abstract = True
. Output only the next line. | ordering = ['-posted_on', '-last_edited_on'] |
Given the code snippet: <|code_start|>
class Material(models.Model):
title = models.CharField(max_length=150, blank=True)
section = models.CharField(max_length=150, blank=True)
<|code_end|>
, generate the next line using the imports in this file:
from django.db import models
from students.models import Subject, Teacher, Class
and context (functions, classes, or occasionally code) from other files:
# Path: students/models.py
# class Subject(models.Model):
# title = models.CharField(unique=True, max_length=50)
#
# def __str__(self):
# return self.title
#
# class Meta:
# ordering = ['title']
#
# class Teacher(Account):
# subject = models.ForeignKey(Subject, related_name='teachers', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.subject)
#
# class Class(models.Model):
# CLASS_NUMBERS = (
# (8, 8),
# (9, 9),
# (10, 10),
# (11, 11),
# (12, 12),
# )
# CLASS_NUMBER_VALIDATORS = [MinValueValidator(8), MaxValueValidator(12)]
#
# CLASS_LETTERS = (
# ('A', 'A'),
# ('B', 'B'),
# ('V', 'V'),
# ('G', 'G'),
# )
#
# number = models.IntegerField(validators=CLASS_NUMBER_VALIDATORS, choices=CLASS_NUMBERS)
# letter = models.CharField(max_length=1, choices=CLASS_LETTERS)
#
# def __str__(self):
# return '{}{}'.format(self.number, self.letter)
#
# class Meta:
# ordering = ['number', 'letter']
# verbose_name_plural = 'classes'
. Output only the next line. | content = models.TextField(blank=False) |
Predict the next line after this snippet: <|code_start|>
class Material(models.Model):
title = models.CharField(max_length=150, blank=True)
section = models.CharField(max_length=150, blank=True)
<|code_end|>
using the current file's imports:
from django.db import models
from students.models import Subject, Teacher, Class
and any relevant context from other files:
# Path: students/models.py
# class Subject(models.Model):
# title = models.CharField(unique=True, max_length=50)
#
# def __str__(self):
# return self.title
#
# class Meta:
# ordering = ['title']
#
# class Teacher(Account):
# subject = models.ForeignKey(Subject, related_name='teachers', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.subject)
#
# class Class(models.Model):
# CLASS_NUMBERS = (
# (8, 8),
# (9, 9),
# (10, 10),
# (11, 11),
# (12, 12),
# )
# CLASS_NUMBER_VALIDATORS = [MinValueValidator(8), MaxValueValidator(12)]
#
# CLASS_LETTERS = (
# ('A', 'A'),
# ('B', 'B'),
# ('V', 'V'),
# ('G', 'G'),
# )
#
# number = models.IntegerField(validators=CLASS_NUMBER_VALIDATORS, choices=CLASS_NUMBERS)
# letter = models.CharField(max_length=1, choices=CLASS_LETTERS)
#
# def __str__(self):
# return '{}{}'.format(self.number, self.letter)
#
# class Meta:
# ordering = ['number', 'letter']
# verbose_name_plural = 'classes'
. Output only the next line. | content = models.TextField(blank=False) |
Here is a snippet: <|code_start|>
class ExamsViewSet(viewsets.ModelViewSet):
permission_classes_by_action = {
'list': (IsAuthenticated,),
'retrieve': (IsAuthenticated,),
'create': (IsAuthenticated, IsTeacher),
'update': (IsAuthenticated, IsTeacher, IsTeacherAuthor),
'destroy': (IsAuthenticated, IsTeacher, IsTeacherAuthor)
}
queryset = Exam.objects.filter(date__gte=datetime.now())
filter_backends = (ExamsFilterBackend, FullWordSearchFilter)
word_fields = ('topic',)
def get_permissions(self):
return [
permission()
for permission
in self.permission_classes_by_action[self.action]
<|code_end|>
. Write the next line using the current file imports:
from datetime import datetime
from rest_framework import viewsets, status
from rest_framework.generics import get_object_or_404
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsTeacher, IsTeacherAuthor
from .serializers import ExamSerializer, ExamReadSerializer
from .models import Exam
from .filters import ExamsFilterBackend
and context from other files:
# Path: students/permissions.py
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsTeacherAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user.teacher
#
# Path: exams/serializers.py
# class ExamSerializer(serializers.ModelSerializer):
# clazz = ClassSerializer()
# topic = serializers.CharField(required=True, max_length=60)
# details = serializers.CharField(max_length=10000, allow_blank=True, required=False)
#
# class Meta:
# model = Exam
# fields = ('id', 'subject', 'date', 'clazz', 'topic', 'details', 'author')
# depth = 1
#
# def create(self, validated_data):
# request = self.context['request']
#
# author = request.user.teacher
# subject = author.subject
# clazz = get_object_or_404(Class, **validated_data.pop('clazz'))
#
# exam = Exam.objects.create(subject=subject, author=author, clazz=clazz, **validated_data)
#
# recipient_list = User.objects.filter(student__clazz=clazz)
# for user in recipient_list:
# send_creation_email(user, model=exam)
#
# return exam
#
# def update(self, instance, validated_data):
# instance.__dict__.update(**validated_data)
# instance.save()
#
# return instance
#
# class ExamReadSerializer(ExamSerializer):
# subject = SubjectSerializer(read_only=True)
# clazz = ClassSerializer(read_only=True)
# author = TeacherAuthorSerializer(read_only=True)
#
# Path: exams/models.py
# class Exam(models.Model):
# subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
# date = models.DateField(auto_now=False, validators=[validate_date])
# clazz = models.ForeignKey(Class, on_delete=models.CASCADE)
# topic = models.CharField(max_length=60)
# details = models.TextField(max_length=10000, blank=True)
# author = models.ForeignKey(Teacher, null=True, related_name='exams', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} - {} ({})'.format(self.subject, self.clazz, self.date)
#
# class Meta:
# ordering = ['date', 'subject', 'clazz']
#
# Path: exams/filters.py
# class ExamsFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# if IsTeacher().has_permission(request, self):
# return queryset.filter(subject=request.user.teacher.subject)
#
# return queryset.filter(clazz=request.user.student.clazz)
, which may include functions, classes, or code. Output only the next line. | ] |
Continue the code snippet: <|code_start|>
class ExamsViewSet(viewsets.ModelViewSet):
permission_classes_by_action = {
'list': (IsAuthenticated,),
'retrieve': (IsAuthenticated,),
'create': (IsAuthenticated, IsTeacher),
'update': (IsAuthenticated, IsTeacher, IsTeacherAuthor),
'destroy': (IsAuthenticated, IsTeacher, IsTeacherAuthor)
<|code_end|>
. Use current file imports:
from datetime import datetime
from rest_framework import viewsets, status
from rest_framework.generics import get_object_or_404
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsTeacher, IsTeacherAuthor
from .serializers import ExamSerializer, ExamReadSerializer
from .models import Exam
from .filters import ExamsFilterBackend
and context (classes, functions, or code) from other files:
# Path: students/permissions.py
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsTeacherAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user.teacher
#
# Path: exams/serializers.py
# class ExamSerializer(serializers.ModelSerializer):
# clazz = ClassSerializer()
# topic = serializers.CharField(required=True, max_length=60)
# details = serializers.CharField(max_length=10000, allow_blank=True, required=False)
#
# class Meta:
# model = Exam
# fields = ('id', 'subject', 'date', 'clazz', 'topic', 'details', 'author')
# depth = 1
#
# def create(self, validated_data):
# request = self.context['request']
#
# author = request.user.teacher
# subject = author.subject
# clazz = get_object_or_404(Class, **validated_data.pop('clazz'))
#
# exam = Exam.objects.create(subject=subject, author=author, clazz=clazz, **validated_data)
#
# recipient_list = User.objects.filter(student__clazz=clazz)
# for user in recipient_list:
# send_creation_email(user, model=exam)
#
# return exam
#
# def update(self, instance, validated_data):
# instance.__dict__.update(**validated_data)
# instance.save()
#
# return instance
#
# class ExamReadSerializer(ExamSerializer):
# subject = SubjectSerializer(read_only=True)
# clazz = ClassSerializer(read_only=True)
# author = TeacherAuthorSerializer(read_only=True)
#
# Path: exams/models.py
# class Exam(models.Model):
# subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
# date = models.DateField(auto_now=False, validators=[validate_date])
# clazz = models.ForeignKey(Class, on_delete=models.CASCADE)
# topic = models.CharField(max_length=60)
# details = models.TextField(max_length=10000, blank=True)
# author = models.ForeignKey(Teacher, null=True, related_name='exams', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} - {} ({})'.format(self.subject, self.clazz, self.date)
#
# class Meta:
# ordering = ['date', 'subject', 'clazz']
#
# Path: exams/filters.py
# class ExamsFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# if IsTeacher().has_permission(request, self):
# return queryset.filter(subject=request.user.teacher.subject)
#
# return queryset.filter(clazz=request.user.student.clazz)
. Output only the next line. | } |
Based on the snippet: <|code_start|>
class ExamsViewSet(viewsets.ModelViewSet):
permission_classes_by_action = {
'list': (IsAuthenticated,),
'retrieve': (IsAuthenticated,),
'create': (IsAuthenticated, IsTeacher),
'update': (IsAuthenticated, IsTeacher, IsTeacherAuthor),
'destroy': (IsAuthenticated, IsTeacher, IsTeacherAuthor)
}
queryset = Exam.objects.filter(date__gte=datetime.now())
filter_backends = (ExamsFilterBackend, FullWordSearchFilter)
word_fields = ('topic',)
def get_permissions(self):
return [
permission()
for permission
in self.permission_classes_by_action[self.action]
]
def get_serializer_class(self):
return ExamReadSerializer if self.request.method in ('GET',) else ExamSerializer
def create(self, request, *args, **kwargs):
<|code_end|>
, predict the immediate next line with the help of imports:
from datetime import datetime
from rest_framework import viewsets, status
from rest_framework.generics import get_object_or_404
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsTeacher, IsTeacherAuthor
from .serializers import ExamSerializer, ExamReadSerializer
from .models import Exam
from .filters import ExamsFilterBackend
and context (classes, functions, sometimes code) from other files:
# Path: students/permissions.py
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsTeacherAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user.teacher
#
# Path: exams/serializers.py
# class ExamSerializer(serializers.ModelSerializer):
# clazz = ClassSerializer()
# topic = serializers.CharField(required=True, max_length=60)
# details = serializers.CharField(max_length=10000, allow_blank=True, required=False)
#
# class Meta:
# model = Exam
# fields = ('id', 'subject', 'date', 'clazz', 'topic', 'details', 'author')
# depth = 1
#
# def create(self, validated_data):
# request = self.context['request']
#
# author = request.user.teacher
# subject = author.subject
# clazz = get_object_or_404(Class, **validated_data.pop('clazz'))
#
# exam = Exam.objects.create(subject=subject, author=author, clazz=clazz, **validated_data)
#
# recipient_list = User.objects.filter(student__clazz=clazz)
# for user in recipient_list:
# send_creation_email(user, model=exam)
#
# return exam
#
# def update(self, instance, validated_data):
# instance.__dict__.update(**validated_data)
# instance.save()
#
# return instance
#
# class ExamReadSerializer(ExamSerializer):
# subject = SubjectSerializer(read_only=True)
# clazz = ClassSerializer(read_only=True)
# author = TeacherAuthorSerializer(read_only=True)
#
# Path: exams/models.py
# class Exam(models.Model):
# subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
# date = models.DateField(auto_now=False, validators=[validate_date])
# clazz = models.ForeignKey(Class, on_delete=models.CASCADE)
# topic = models.CharField(max_length=60)
# details = models.TextField(max_length=10000, blank=True)
# author = models.ForeignKey(Teacher, null=True, related_name='exams', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} - {} ({})'.format(self.subject, self.clazz, self.date)
#
# class Meta:
# ordering = ['date', 'subject', 'clazz']
#
# Path: exams/filters.py
# class ExamsFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# if IsTeacher().has_permission(request, self):
# return queryset.filter(subject=request.user.teacher.subject)
#
# return queryset.filter(clazz=request.user.student.clazz)
. Output only the next line. | context = {'request': request} |
Predict the next line after this snippet: <|code_start|>
class ExamsViewSet(viewsets.ModelViewSet):
permission_classes_by_action = {
'list': (IsAuthenticated,),
'retrieve': (IsAuthenticated,),
'create': (IsAuthenticated, IsTeacher),
'update': (IsAuthenticated, IsTeacher, IsTeacherAuthor),
'destroy': (IsAuthenticated, IsTeacher, IsTeacherAuthor)
}
queryset = Exam.objects.filter(date__gte=datetime.now())
filter_backends = (ExamsFilterBackend, FullWordSearchFilter)
word_fields = ('topic',)
def get_permissions(self):
return [
permission()
for permission
in self.permission_classes_by_action[self.action]
]
def get_serializer_class(self):
return ExamReadSerializer if self.request.method in ('GET',) else ExamSerializer
def create(self, request, *args, **kwargs):
context = {'request': request}
serializer = self.get_serializer(data=request.data, context=context)
serializer.is_valid(raise_exception=True)
<|code_end|>
using the current file's imports:
from datetime import datetime
from rest_framework import viewsets, status
from rest_framework.generics import get_object_or_404
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsTeacher, IsTeacherAuthor
from .serializers import ExamSerializer, ExamReadSerializer
from .models import Exam
from .filters import ExamsFilterBackend
and any relevant context from other files:
# Path: students/permissions.py
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsTeacherAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user.teacher
#
# Path: exams/serializers.py
# class ExamSerializer(serializers.ModelSerializer):
# clazz = ClassSerializer()
# topic = serializers.CharField(required=True, max_length=60)
# details = serializers.CharField(max_length=10000, allow_blank=True, required=False)
#
# class Meta:
# model = Exam
# fields = ('id', 'subject', 'date', 'clazz', 'topic', 'details', 'author')
# depth = 1
#
# def create(self, validated_data):
# request = self.context['request']
#
# author = request.user.teacher
# subject = author.subject
# clazz = get_object_or_404(Class, **validated_data.pop('clazz'))
#
# exam = Exam.objects.create(subject=subject, author=author, clazz=clazz, **validated_data)
#
# recipient_list = User.objects.filter(student__clazz=clazz)
# for user in recipient_list:
# send_creation_email(user, model=exam)
#
# return exam
#
# def update(self, instance, validated_data):
# instance.__dict__.update(**validated_data)
# instance.save()
#
# return instance
#
# class ExamReadSerializer(ExamSerializer):
# subject = SubjectSerializer(read_only=True)
# clazz = ClassSerializer(read_only=True)
# author = TeacherAuthorSerializer(read_only=True)
#
# Path: exams/models.py
# class Exam(models.Model):
# subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
# date = models.DateField(auto_now=False, validators=[validate_date])
# clazz = models.ForeignKey(Class, on_delete=models.CASCADE)
# topic = models.CharField(max_length=60)
# details = models.TextField(max_length=10000, blank=True)
# author = models.ForeignKey(Teacher, null=True, related_name='exams', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} - {} ({})'.format(self.subject, self.clazz, self.date)
#
# class Meta:
# ordering = ['date', 'subject', 'clazz']
#
# Path: exams/filters.py
# class ExamsFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# if IsTeacher().has_permission(request, self):
# return queryset.filter(subject=request.user.teacher.subject)
#
# return queryset.filter(clazz=request.user.student.clazz)
. Output only the next line. | self.perform_create(serializer) |
Given the following code snippet before the placeholder: <|code_start|>
class ExamsViewSet(viewsets.ModelViewSet):
permission_classes_by_action = {
'list': (IsAuthenticated,),
<|code_end|>
, predict the next line using imports from the current file:
from datetime import datetime
from rest_framework import viewsets, status
from rest_framework.generics import get_object_or_404
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsTeacher, IsTeacherAuthor
from .serializers import ExamSerializer, ExamReadSerializer
from .models import Exam
from .filters import ExamsFilterBackend
and context including class names, function names, and sometimes code from other files:
# Path: students/permissions.py
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsTeacherAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user.teacher
#
# Path: exams/serializers.py
# class ExamSerializer(serializers.ModelSerializer):
# clazz = ClassSerializer()
# topic = serializers.CharField(required=True, max_length=60)
# details = serializers.CharField(max_length=10000, allow_blank=True, required=False)
#
# class Meta:
# model = Exam
# fields = ('id', 'subject', 'date', 'clazz', 'topic', 'details', 'author')
# depth = 1
#
# def create(self, validated_data):
# request = self.context['request']
#
# author = request.user.teacher
# subject = author.subject
# clazz = get_object_or_404(Class, **validated_data.pop('clazz'))
#
# exam = Exam.objects.create(subject=subject, author=author, clazz=clazz, **validated_data)
#
# recipient_list = User.objects.filter(student__clazz=clazz)
# for user in recipient_list:
# send_creation_email(user, model=exam)
#
# return exam
#
# def update(self, instance, validated_data):
# instance.__dict__.update(**validated_data)
# instance.save()
#
# return instance
#
# class ExamReadSerializer(ExamSerializer):
# subject = SubjectSerializer(read_only=True)
# clazz = ClassSerializer(read_only=True)
# author = TeacherAuthorSerializer(read_only=True)
#
# Path: exams/models.py
# class Exam(models.Model):
# subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
# date = models.DateField(auto_now=False, validators=[validate_date])
# clazz = models.ForeignKey(Class, on_delete=models.CASCADE)
# topic = models.CharField(max_length=60)
# details = models.TextField(max_length=10000, blank=True)
# author = models.ForeignKey(Teacher, null=True, related_name='exams', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} - {} ({})'.format(self.subject, self.clazz, self.date)
#
# class Meta:
# ordering = ['date', 'subject', 'clazz']
#
# Path: exams/filters.py
# class ExamsFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# if IsTeacher().has_permission(request, self):
# return queryset.filter(subject=request.user.teacher.subject)
#
# return queryset.filter(clazz=request.user.student.clazz)
. Output only the next line. | 'retrieve': (IsAuthenticated,), |
Next line prediction: <|code_start|> permission_classes_by_action = {
'list': (IsAuthenticated,),
'retrieve': (IsAuthenticated,),
'create': (IsAuthenticated, IsTeacher),
'update': (IsAuthenticated, IsTeacher, IsTeacherAuthor),
'destroy': (IsAuthenticated, IsTeacher, IsTeacherAuthor)
}
queryset = Exam.objects.filter(date__gte=datetime.now())
filter_backends = (ExamsFilterBackend, FullWordSearchFilter)
word_fields = ('topic',)
def get_permissions(self):
return [
permission()
for permission
in self.permission_classes_by_action[self.action]
]
def get_serializer_class(self):
return ExamReadSerializer if self.request.method in ('GET',) else ExamSerializer
def create(self, request, *args, **kwargs):
context = {'request': request}
serializer = self.get_serializer(data=request.data, context=context)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)
<|code_end|>
. Use current file imports:
(from datetime import datetime
from rest_framework import viewsets, status
from rest_framework.generics import get_object_or_404
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated
from rest_framework_word_filter import FullWordSearchFilter
from students.permissions import IsTeacher, IsTeacherAuthor
from .serializers import ExamSerializer, ExamReadSerializer
from .models import Exam
from .filters import ExamsFilterBackend)
and context including class names, function names, or small code snippets from other files:
# Path: students/permissions.py
# class IsTeacher(permissions.BasePermission):
# message = ROLE_DEFAULT_MESSAGE.format('teacher')
#
# def has_permission(self, request, view):
# return Teacher.objects.filter(user=request.user).exists()
#
# class IsTeacherAuthor(permissions.BasePermission):
# message = AUTHOR_DEFAULT_MESSAGE
#
# def has_object_permission(self, request, view, obj):
# return obj.author == request.user.teacher
#
# Path: exams/serializers.py
# class ExamSerializer(serializers.ModelSerializer):
# clazz = ClassSerializer()
# topic = serializers.CharField(required=True, max_length=60)
# details = serializers.CharField(max_length=10000, allow_blank=True, required=False)
#
# class Meta:
# model = Exam
# fields = ('id', 'subject', 'date', 'clazz', 'topic', 'details', 'author')
# depth = 1
#
# def create(self, validated_data):
# request = self.context['request']
#
# author = request.user.teacher
# subject = author.subject
# clazz = get_object_or_404(Class, **validated_data.pop('clazz'))
#
# exam = Exam.objects.create(subject=subject, author=author, clazz=clazz, **validated_data)
#
# recipient_list = User.objects.filter(student__clazz=clazz)
# for user in recipient_list:
# send_creation_email(user, model=exam)
#
# return exam
#
# def update(self, instance, validated_data):
# instance.__dict__.update(**validated_data)
# instance.save()
#
# return instance
#
# class ExamReadSerializer(ExamSerializer):
# subject = SubjectSerializer(read_only=True)
# clazz = ClassSerializer(read_only=True)
# author = TeacherAuthorSerializer(read_only=True)
#
# Path: exams/models.py
# class Exam(models.Model):
# subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
# date = models.DateField(auto_now=False, validators=[validate_date])
# clazz = models.ForeignKey(Class, on_delete=models.CASCADE)
# topic = models.CharField(max_length=60)
# details = models.TextField(max_length=10000, blank=True)
# author = models.ForeignKey(Teacher, null=True, related_name='exams', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} - {} ({})'.format(self.subject, self.clazz, self.date)
#
# class Meta:
# ordering = ['date', 'subject', 'clazz']
#
# Path: exams/filters.py
# class ExamsFilterBackend(filters.BaseFilterBackend):
# def filter_queryset(self, request, queryset, view):
# if IsTeacher().has_permission(request, self):
# return queryset.filter(subject=request.user.teacher.subject)
#
# return queryset.filter(clazz=request.user.student.clazz)
. Output only the next line. | return Response(serializer.validated_data, status=status.HTTP_201_CREATED, headers=headers) |
Predict the next line after this snippet: <|code_start|>
app_name = 'news'
students_url_pattern = r'news/students'
teachers_default_url_pattern = r'news/teachers'
teachers_detail_url_pattern = r'(?P<class_number>[8]|[9]|1[0-2])/(?P<class_letter>[A-Z])'
teachers_url_pattern = r'{default_pattern}/{detail_pattern}'.format(
default_pattern=teachers_default_url_pattern,
detail_pattern=teachers_detail_url_pattern
)
students_router = routers.SimpleRouter()
students_router.register(students_url_pattern, NewsStudentsViewSet, base_name='students_news')
teachers_router = routers.SimpleRouter()
teachers_router.register(teachers_url_pattern, NewsTeachersViewSet, base_name='teachers_news')
students_comments_router = routers.NestedSimpleRouter(
students_router, students_url_pattern, lookup='students_news'
)
students_comments_router.register(r'comments', CommentsViewSet, base_name='students_news_comments')
teachers_comments_router = routers.NestedSimpleRouter(
teachers_router, teachers_url_pattern, lookup='teachers_news'
)
teachers_comments_router.register(r'comments', CommentsViewSet, base_name='teachers_news_comments')
urlpatterns = [
url(r'^news/teachers/$', NewsTeachersList.as_view(), name='teachers_news_list'),
<|code_end|>
using the current file's imports:
from django.conf.urls import url
from rest_framework_nested import routers
from .views import (
NewsStudentsViewSet,
NewsTeachersList, NewsTeachersClassNumberList, NewsTeachersViewSet,
CommentsViewSet
)
and any relevant context from other files:
# Path: news/views.py
# class NewsStudentsViewSet(NewsDefaultViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated, IsStudent),
# 'retrieve': (IsAuthenticated, IsStudent),
# 'create': (IsAuthenticated, IsStudent),
# 'update': (IsAuthenticated, IsStudent, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsStudent, IsUserAuthor)
# }
# filter_backends = (FullWordSearchFilter,)
# word_fields = ('title', 'author__username')
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_clazz_info(self):
# clazz = self.request.user.student.clazz
#
# return {
# 'class_number': clazz.number,
# 'class_letter': clazz.letter
# }
#
# class NewsTeachersList(generics.ListAPIView):
# permission_classes = (IsAuthenticated, IsTeacher)
# serializer_class = NewsSerializer
# queryset = News.objects.all()
# filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# class NewsTeachersClassNumberList(generics.ListCreateAPIView):
# permission_classes = (IsAuthenticated, IsTeacher)
# serializer_class = NewsSerializer
# queryset = News.objects.all()
# filter_backends = (TeachersListFilterBackend, ClassNumberFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# def get_serializer_context(self):
# context = super().get_serializer_context()
# context['class_number'] = self.kwargs['class_number']
#
# return context
#
# class NewsTeachersViewSet(NewsDefaultViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated, IsTeacher),
# 'retrieve': (IsAuthenticated, IsTeacher),
# 'create': (IsAuthenticated, IsTeacher),
# 'update': (IsAuthenticated, IsTeacher, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsTeacher, IsUserAuthor)
# }
# filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_clazz_info(self):
# return self.kwargs
#
# class CommentsViewSet(viewsets.ModelViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated,),
# 'retrieve': (IsAuthenticated,),
# 'create': (IsAuthenticated,),
# 'update': (IsAuthenticated, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsUserAuthor)
# }
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_serializer_class(self):
# return CommentReadSerializer if self.request.method in ('GET',) else CommentSerializer
#
# def get_news_pk(self):
# return self.kwargs.get('students_news_pk', self.kwargs.get('teachers_news_pk'))
#
# def get_related_news(self):
# return generics.get_object_or_404(News, id=self.get_news_pk())
#
# def get_serializer_context(self):
# context = super().get_serializer_context()
# context['news'] = self.get_related_news()
#
# return context
#
# def get_queryset(self):
# news = self.get_related_news()
#
# return news.comments.all()
. Output only the next line. | url(r'^news/teachers/(?P<class_number>[8]|[9]|1[0-2])/$', |
Given the following code snippet before the placeholder: <|code_start|>
app_name = 'news'
students_url_pattern = r'news/students'
teachers_default_url_pattern = r'news/teachers'
teachers_detail_url_pattern = r'(?P<class_number>[8]|[9]|1[0-2])/(?P<class_letter>[A-Z])'
teachers_url_pattern = r'{default_pattern}/{detail_pattern}'.format(
default_pattern=teachers_default_url_pattern,
detail_pattern=teachers_detail_url_pattern
)
students_router = routers.SimpleRouter()
students_router.register(students_url_pattern, NewsStudentsViewSet, base_name='students_news')
teachers_router = routers.SimpleRouter()
teachers_router.register(teachers_url_pattern, NewsTeachersViewSet, base_name='teachers_news')
students_comments_router = routers.NestedSimpleRouter(
<|code_end|>
, predict the next line using imports from the current file:
from django.conf.urls import url
from rest_framework_nested import routers
from .views import (
NewsStudentsViewSet,
NewsTeachersList, NewsTeachersClassNumberList, NewsTeachersViewSet,
CommentsViewSet
)
and context including class names, function names, and sometimes code from other files:
# Path: news/views.py
# class NewsStudentsViewSet(NewsDefaultViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated, IsStudent),
# 'retrieve': (IsAuthenticated, IsStudent),
# 'create': (IsAuthenticated, IsStudent),
# 'update': (IsAuthenticated, IsStudent, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsStudent, IsUserAuthor)
# }
# filter_backends = (FullWordSearchFilter,)
# word_fields = ('title', 'author__username')
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_clazz_info(self):
# clazz = self.request.user.student.clazz
#
# return {
# 'class_number': clazz.number,
# 'class_letter': clazz.letter
# }
#
# class NewsTeachersList(generics.ListAPIView):
# permission_classes = (IsAuthenticated, IsTeacher)
# serializer_class = NewsSerializer
# queryset = News.objects.all()
# filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# class NewsTeachersClassNumberList(generics.ListCreateAPIView):
# permission_classes = (IsAuthenticated, IsTeacher)
# serializer_class = NewsSerializer
# queryset = News.objects.all()
# filter_backends = (TeachersListFilterBackend, ClassNumberFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# def get_serializer_context(self):
# context = super().get_serializer_context()
# context['class_number'] = self.kwargs['class_number']
#
# return context
#
# class NewsTeachersViewSet(NewsDefaultViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated, IsTeacher),
# 'retrieve': (IsAuthenticated, IsTeacher),
# 'create': (IsAuthenticated, IsTeacher),
# 'update': (IsAuthenticated, IsTeacher, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsTeacher, IsUserAuthor)
# }
# filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_clazz_info(self):
# return self.kwargs
#
# class CommentsViewSet(viewsets.ModelViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated,),
# 'retrieve': (IsAuthenticated,),
# 'create': (IsAuthenticated,),
# 'update': (IsAuthenticated, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsUserAuthor)
# }
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_serializer_class(self):
# return CommentReadSerializer if self.request.method in ('GET',) else CommentSerializer
#
# def get_news_pk(self):
# return self.kwargs.get('students_news_pk', self.kwargs.get('teachers_news_pk'))
#
# def get_related_news(self):
# return generics.get_object_or_404(News, id=self.get_news_pk())
#
# def get_serializer_context(self):
# context = super().get_serializer_context()
# context['news'] = self.get_related_news()
#
# return context
#
# def get_queryset(self):
# news = self.get_related_news()
#
# return news.comments.all()
. Output only the next line. | students_router, students_url_pattern, lookup='students_news' |
Given the code snippet: <|code_start|> default_pattern=teachers_default_url_pattern,
detail_pattern=teachers_detail_url_pattern
)
students_router = routers.SimpleRouter()
students_router.register(students_url_pattern, NewsStudentsViewSet, base_name='students_news')
teachers_router = routers.SimpleRouter()
teachers_router.register(teachers_url_pattern, NewsTeachersViewSet, base_name='teachers_news')
students_comments_router = routers.NestedSimpleRouter(
students_router, students_url_pattern, lookup='students_news'
)
students_comments_router.register(r'comments', CommentsViewSet, base_name='students_news_comments')
teachers_comments_router = routers.NestedSimpleRouter(
teachers_router, teachers_url_pattern, lookup='teachers_news'
)
teachers_comments_router.register(r'comments', CommentsViewSet, base_name='teachers_news_comments')
urlpatterns = [
url(r'^news/teachers/$', NewsTeachersList.as_view(), name='teachers_news_list'),
url(r'^news/teachers/(?P<class_number>[8]|[9]|1[0-2])/$',
NewsTeachersClassNumberList.as_view(),
name='teachers_class_number_list')
]
urlpatterns += students_router.urls
urlpatterns += teachers_router.urls
urlpatterns += students_comments_router.urls
<|code_end|>
, generate the next line using the imports in this file:
from django.conf.urls import url
from rest_framework_nested import routers
from .views import (
NewsStudentsViewSet,
NewsTeachersList, NewsTeachersClassNumberList, NewsTeachersViewSet,
CommentsViewSet
)
and context (functions, classes, or occasionally code) from other files:
# Path: news/views.py
# class NewsStudentsViewSet(NewsDefaultViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated, IsStudent),
# 'retrieve': (IsAuthenticated, IsStudent),
# 'create': (IsAuthenticated, IsStudent),
# 'update': (IsAuthenticated, IsStudent, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsStudent, IsUserAuthor)
# }
# filter_backends = (FullWordSearchFilter,)
# word_fields = ('title', 'author__username')
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_clazz_info(self):
# clazz = self.request.user.student.clazz
#
# return {
# 'class_number': clazz.number,
# 'class_letter': clazz.letter
# }
#
# class NewsTeachersList(generics.ListAPIView):
# permission_classes = (IsAuthenticated, IsTeacher)
# serializer_class = NewsSerializer
# queryset = News.objects.all()
# filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# class NewsTeachersClassNumberList(generics.ListCreateAPIView):
# permission_classes = (IsAuthenticated, IsTeacher)
# serializer_class = NewsSerializer
# queryset = News.objects.all()
# filter_backends = (TeachersListFilterBackend, ClassNumberFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# def get_serializer_context(self):
# context = super().get_serializer_context()
# context['class_number'] = self.kwargs['class_number']
#
# return context
#
# class NewsTeachersViewSet(NewsDefaultViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated, IsTeacher),
# 'retrieve': (IsAuthenticated, IsTeacher),
# 'create': (IsAuthenticated, IsTeacher),
# 'update': (IsAuthenticated, IsTeacher, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsTeacher, IsUserAuthor)
# }
# filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_clazz_info(self):
# return self.kwargs
#
# class CommentsViewSet(viewsets.ModelViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated,),
# 'retrieve': (IsAuthenticated,),
# 'create': (IsAuthenticated,),
# 'update': (IsAuthenticated, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsUserAuthor)
# }
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_serializer_class(self):
# return CommentReadSerializer if self.request.method in ('GET',) else CommentSerializer
#
# def get_news_pk(self):
# return self.kwargs.get('students_news_pk', self.kwargs.get('teachers_news_pk'))
#
# def get_related_news(self):
# return generics.get_object_or_404(News, id=self.get_news_pk())
#
# def get_serializer_context(self):
# context = super().get_serializer_context()
# context['news'] = self.get_related_news()
#
# return context
#
# def get_queryset(self):
# news = self.get_related_news()
#
# return news.comments.all()
. Output only the next line. | urlpatterns += teachers_comments_router.urls |
Given the following code snippet before the placeholder: <|code_start|>
app_name = 'news'
students_url_pattern = r'news/students'
teachers_default_url_pattern = r'news/teachers'
teachers_detail_url_pattern = r'(?P<class_number>[8]|[9]|1[0-2])/(?P<class_letter>[A-Z])'
teachers_url_pattern = r'{default_pattern}/{detail_pattern}'.format(
default_pattern=teachers_default_url_pattern,
detail_pattern=teachers_detail_url_pattern
)
students_router = routers.SimpleRouter()
students_router.register(students_url_pattern, NewsStudentsViewSet, base_name='students_news')
teachers_router = routers.SimpleRouter()
teachers_router.register(teachers_url_pattern, NewsTeachersViewSet, base_name='teachers_news')
<|code_end|>
, predict the next line using imports from the current file:
from django.conf.urls import url
from rest_framework_nested import routers
from .views import (
NewsStudentsViewSet,
NewsTeachersList, NewsTeachersClassNumberList, NewsTeachersViewSet,
CommentsViewSet
)
and context including class names, function names, and sometimes code from other files:
# Path: news/views.py
# class NewsStudentsViewSet(NewsDefaultViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated, IsStudent),
# 'retrieve': (IsAuthenticated, IsStudent),
# 'create': (IsAuthenticated, IsStudent),
# 'update': (IsAuthenticated, IsStudent, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsStudent, IsUserAuthor)
# }
# filter_backends = (FullWordSearchFilter,)
# word_fields = ('title', 'author__username')
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_clazz_info(self):
# clazz = self.request.user.student.clazz
#
# return {
# 'class_number': clazz.number,
# 'class_letter': clazz.letter
# }
#
# class NewsTeachersList(generics.ListAPIView):
# permission_classes = (IsAuthenticated, IsTeacher)
# serializer_class = NewsSerializer
# queryset = News.objects.all()
# filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# class NewsTeachersClassNumberList(generics.ListCreateAPIView):
# permission_classes = (IsAuthenticated, IsTeacher)
# serializer_class = NewsSerializer
# queryset = News.objects.all()
# filter_backends = (TeachersListFilterBackend, ClassNumberFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# def get_serializer_context(self):
# context = super().get_serializer_context()
# context['class_number'] = self.kwargs['class_number']
#
# return context
#
# class NewsTeachersViewSet(NewsDefaultViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated, IsTeacher),
# 'retrieve': (IsAuthenticated, IsTeacher),
# 'create': (IsAuthenticated, IsTeacher),
# 'update': (IsAuthenticated, IsTeacher, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsTeacher, IsUserAuthor)
# }
# filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_clazz_info(self):
# return self.kwargs
#
# class CommentsViewSet(viewsets.ModelViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated,),
# 'retrieve': (IsAuthenticated,),
# 'create': (IsAuthenticated,),
# 'update': (IsAuthenticated, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsUserAuthor)
# }
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_serializer_class(self):
# return CommentReadSerializer if self.request.method in ('GET',) else CommentSerializer
#
# def get_news_pk(self):
# return self.kwargs.get('students_news_pk', self.kwargs.get('teachers_news_pk'))
#
# def get_related_news(self):
# return generics.get_object_or_404(News, id=self.get_news_pk())
#
# def get_serializer_context(self):
# context = super().get_serializer_context()
# context['news'] = self.get_related_news()
#
# return context
#
# def get_queryset(self):
# news = self.get_related_news()
#
# return news.comments.all()
. Output only the next line. | students_comments_router = routers.NestedSimpleRouter( |
Given snippet: <|code_start|>
app_name = 'news'
students_url_pattern = r'news/students'
teachers_default_url_pattern = r'news/teachers'
teachers_detail_url_pattern = r'(?P<class_number>[8]|[9]|1[0-2])/(?P<class_letter>[A-Z])'
teachers_url_pattern = r'{default_pattern}/{detail_pattern}'.format(
default_pattern=teachers_default_url_pattern,
detail_pattern=teachers_detail_url_pattern
)
students_router = routers.SimpleRouter()
students_router.register(students_url_pattern, NewsStudentsViewSet, base_name='students_news')
teachers_router = routers.SimpleRouter()
teachers_router.register(teachers_url_pattern, NewsTeachersViewSet, base_name='teachers_news')
students_comments_router = routers.NestedSimpleRouter(
students_router, students_url_pattern, lookup='students_news'
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.conf.urls import url
from rest_framework_nested import routers
from .views import (
NewsStudentsViewSet,
NewsTeachersList, NewsTeachersClassNumberList, NewsTeachersViewSet,
CommentsViewSet
)
and context:
# Path: news/views.py
# class NewsStudentsViewSet(NewsDefaultViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated, IsStudent),
# 'retrieve': (IsAuthenticated, IsStudent),
# 'create': (IsAuthenticated, IsStudent),
# 'update': (IsAuthenticated, IsStudent, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsStudent, IsUserAuthor)
# }
# filter_backends = (FullWordSearchFilter,)
# word_fields = ('title', 'author__username')
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_clazz_info(self):
# clazz = self.request.user.student.clazz
#
# return {
# 'class_number': clazz.number,
# 'class_letter': clazz.letter
# }
#
# class NewsTeachersList(generics.ListAPIView):
# permission_classes = (IsAuthenticated, IsTeacher)
# serializer_class = NewsSerializer
# queryset = News.objects.all()
# filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# class NewsTeachersClassNumberList(generics.ListCreateAPIView):
# permission_classes = (IsAuthenticated, IsTeacher)
# serializer_class = NewsSerializer
# queryset = News.objects.all()
# filter_backends = (TeachersListFilterBackend, ClassNumberFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# def get_serializer_context(self):
# context = super().get_serializer_context()
# context['class_number'] = self.kwargs['class_number']
#
# return context
#
# class NewsTeachersViewSet(NewsDefaultViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated, IsTeacher),
# 'retrieve': (IsAuthenticated, IsTeacher),
# 'create': (IsAuthenticated, IsTeacher),
# 'update': (IsAuthenticated, IsTeacher, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsTeacher, IsUserAuthor)
# }
# filter_backends = (TeachersListFilterBackend, FullWordSearchFilter)
# word_fields = ('title',)
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_clazz_info(self):
# return self.kwargs
#
# class CommentsViewSet(viewsets.ModelViewSet):
# permission_classes_by_action = {
# 'list': (IsAuthenticated,),
# 'retrieve': (IsAuthenticated,),
# 'create': (IsAuthenticated,),
# 'update': (IsAuthenticated, IsUserAuthor),
# 'destroy': (IsAuthenticated, IsUserAuthor)
# }
#
# def get_permissions(self):
# return [
# permission()
# for permission
# in self.permission_classes_by_action[self.action]
# ]
#
# def get_serializer_class(self):
# return CommentReadSerializer if self.request.method in ('GET',) else CommentSerializer
#
# def get_news_pk(self):
# return self.kwargs.get('students_news_pk', self.kwargs.get('teachers_news_pk'))
#
# def get_related_news(self):
# return generics.get_object_or_404(News, id=self.get_news_pk())
#
# def get_serializer_context(self):
# context = super().get_serializer_context()
# context['news'] = self.get_related_news()
#
# return context
#
# def get_queryset(self):
# news = self.get_related_news()
#
# return news.comments.all()
which might include code, classes, or functions. Output only the next line. | ) |
Predict the next line for this snippet: <|code_start|>
def test_exams_detail_with_authenticated_user(self):
self.client.force_authenticate(user=self.student_user)
response = self.client.get(reverse(self.detail_view_name, kwargs={'pk': self.exam1.id}))
self.assertIsNotNone(response.data)
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_exams_list_with_expired_date(self):
self.client.force_authenticate(user=self.student_user)
new_date = datetime.strptime('Jun 2 2000 1:50PM', '%b %d %Y %I:%M%p').date()
self.exam1.date = new_date
self.exam1.save()
self.exam2.date = new_date
self.exam2.save()
response = self.client.get(reverse(self.list_view_name))
self.assertEqual(response.data['results'], [])
self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_exams_detail_with_invalid_id(self):
self.client.force_authenticate(user=self.student_user)
response = self.client.get(reverse(self.detail_view_name, kwargs={'pk': self.exam2.id + 1}))
self.assertEqual(response.data['detail'], 'Not found.')
<|code_end|>
with the help of current file imports:
from datetime import datetime
from django.contrib.auth.models import User
from rest_framework.test import APITestCase, APIClient
from rest_framework.reverse import reverse
from rest_framework import status
from students.models import Class, Subject, Teacher, Student
from .serializers import ExamSerializer
from .models import Exam
and context from other files:
# Path: students/models.py
# class Class(models.Model):
# CLASS_NUMBERS = (
# (8, 8),
# (9, 9),
# (10, 10),
# (11, 11),
# (12, 12),
# )
# CLASS_NUMBER_VALIDATORS = [MinValueValidator(8), MaxValueValidator(12)]
#
# CLASS_LETTERS = (
# ('A', 'A'),
# ('B', 'B'),
# ('V', 'V'),
# ('G', 'G'),
# )
#
# number = models.IntegerField(validators=CLASS_NUMBER_VALIDATORS, choices=CLASS_NUMBERS)
# letter = models.CharField(max_length=1, choices=CLASS_LETTERS)
#
# def __str__(self):
# return '{}{}'.format(self.number, self.letter)
#
# class Meta:
# ordering = ['number', 'letter']
# verbose_name_plural = 'classes'
#
# class Subject(models.Model):
# title = models.CharField(unique=True, max_length=50)
#
# def __str__(self):
# return self.title
#
# class Meta:
# ordering = ['title']
#
# class Teacher(Account):
# subject = models.ForeignKey(Subject, related_name='teachers', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.subject)
#
# class Student(Account):
# clazz = models.ForeignKey(Class, related_name='students', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.clazz)
#
# Path: exams/serializers.py
# class ExamSerializer(serializers.ModelSerializer):
# clazz = ClassSerializer()
# topic = serializers.CharField(required=True, max_length=60)
# details = serializers.CharField(max_length=10000, allow_blank=True, required=False)
#
# class Meta:
# model = Exam
# fields = ('id', 'subject', 'date', 'clazz', 'topic', 'details', 'author')
# depth = 1
#
# def create(self, validated_data):
# request = self.context['request']
#
# author = request.user.teacher
# subject = author.subject
# clazz = get_object_or_404(Class, **validated_data.pop('clazz'))
#
# exam = Exam.objects.create(subject=subject, author=author, clazz=clazz, **validated_data)
#
# recipient_list = User.objects.filter(student__clazz=clazz)
# for user in recipient_list:
# send_creation_email(user, model=exam)
#
# return exam
#
# def update(self, instance, validated_data):
# instance.__dict__.update(**validated_data)
# instance.save()
#
# return instance
#
# Path: exams/models.py
# class Exam(models.Model):
# subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
# date = models.DateField(auto_now=False, validators=[validate_date])
# clazz = models.ForeignKey(Class, on_delete=models.CASCADE)
# topic = models.CharField(max_length=60)
# details = models.TextField(max_length=10000, blank=True)
# author = models.ForeignKey(Teacher, null=True, related_name='exams', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} - {} ({})'.format(self.subject, self.clazz, self.date)
#
# class Meta:
# ordering = ['date', 'subject', 'clazz']
, which may contain function names, class names, or code. Output only the next line. | self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) |
Here is a snippet: <|code_start|> reverse(self.detail_view_name, kwargs={'pk': self.exam1.id}), put_data, format='json'
)
self.assertEqual(
response.data['detail'],
'Only teachers are allowed to view and modify this content.'
)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_exams_update_with_empty_topic(self):
self.client.force_authenticate(user=self.teacher_user)
self.exam1.topic = ''
put_data = self.serializer_class(self.exam1).data
response = self.client.put(
reverse(self.detail_view_name, kwargs={'pk': self.exam1.id}), put_data, format='json'
)
self.assertEqual(response.data['topic'], ['This field may not be blank.'])
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_exams_update_with_too_long_topic(self):
self.client.force_authenticate(user=self.teacher_user)
self.exam1.topic = 'test topic' * 20
put_data = self.serializer_class(self.exam1).data
response = self.client.put(
reverse(self.detail_view_name, kwargs={'pk': self.exam1.id}), put_data, format='json'
)
<|code_end|>
. Write the next line using the current file imports:
from datetime import datetime
from django.contrib.auth.models import User
from rest_framework.test import APITestCase, APIClient
from rest_framework.reverse import reverse
from rest_framework import status
from students.models import Class, Subject, Teacher, Student
from .serializers import ExamSerializer
from .models import Exam
and context from other files:
# Path: students/models.py
# class Class(models.Model):
# CLASS_NUMBERS = (
# (8, 8),
# (9, 9),
# (10, 10),
# (11, 11),
# (12, 12),
# )
# CLASS_NUMBER_VALIDATORS = [MinValueValidator(8), MaxValueValidator(12)]
#
# CLASS_LETTERS = (
# ('A', 'A'),
# ('B', 'B'),
# ('V', 'V'),
# ('G', 'G'),
# )
#
# number = models.IntegerField(validators=CLASS_NUMBER_VALIDATORS, choices=CLASS_NUMBERS)
# letter = models.CharField(max_length=1, choices=CLASS_LETTERS)
#
# def __str__(self):
# return '{}{}'.format(self.number, self.letter)
#
# class Meta:
# ordering = ['number', 'letter']
# verbose_name_plural = 'classes'
#
# class Subject(models.Model):
# title = models.CharField(unique=True, max_length=50)
#
# def __str__(self):
# return self.title
#
# class Meta:
# ordering = ['title']
#
# class Teacher(Account):
# subject = models.ForeignKey(Subject, related_name='teachers', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.subject)
#
# class Student(Account):
# clazz = models.ForeignKey(Class, related_name='students', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.clazz)
#
# Path: exams/serializers.py
# class ExamSerializer(serializers.ModelSerializer):
# clazz = ClassSerializer()
# topic = serializers.CharField(required=True, max_length=60)
# details = serializers.CharField(max_length=10000, allow_blank=True, required=False)
#
# class Meta:
# model = Exam
# fields = ('id', 'subject', 'date', 'clazz', 'topic', 'details', 'author')
# depth = 1
#
# def create(self, validated_data):
# request = self.context['request']
#
# author = request.user.teacher
# subject = author.subject
# clazz = get_object_or_404(Class, **validated_data.pop('clazz'))
#
# exam = Exam.objects.create(subject=subject, author=author, clazz=clazz, **validated_data)
#
# recipient_list = User.objects.filter(student__clazz=clazz)
# for user in recipient_list:
# send_creation_email(user, model=exam)
#
# return exam
#
# def update(self, instance, validated_data):
# instance.__dict__.update(**validated_data)
# instance.save()
#
# return instance
#
# Path: exams/models.py
# class Exam(models.Model):
# subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
# date = models.DateField(auto_now=False, validators=[validate_date])
# clazz = models.ForeignKey(Class, on_delete=models.CASCADE)
# topic = models.CharField(max_length=60)
# details = models.TextField(max_length=10000, blank=True)
# author = models.ForeignKey(Teacher, null=True, related_name='exams', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} - {} ({})'.format(self.subject, self.clazz, self.date)
#
# class Meta:
# ordering = ['date', 'subject', 'clazz']
, which may include functions, classes, or code. Output only the next line. | self.assertEqual( |
Given snippet: <|code_start|>class ExamsViewSetTestCase(APITestCase):
def setUp(self):
self.client = APIClient()
self.list_view_name = 'exams:exams-list'
self.detail_view_name = 'exams:exams-detail'
self.serializer_class = ExamSerializer
self.subject1 = Subject.objects.create(title='Maths')
self.subject2 = Subject.objects.create(title='Bulgarian Language')
self.teacher_user = User.objects.create(username='teacher', password='123456')
self.teacher = Teacher.objects.create(user=self.teacher_user, subject=self.subject1)
self.student_user = User.objects.create(username='test', password='pass')
self.clazz = Class.objects.create(number=10, letter='A')
self.student = Student.objects.create(user=self.student_user, clazz=self.clazz)
self.date = datetime.strptime('Jun 2 2020 1:50PM', '%b %d %Y %I:%M%p').date()
self.exam1 = Exam.objects.create(
subject=self.subject1,
date=self.date,
clazz=self.clazz,
topic='test topic 1',
details='detailed information',
author=self.teacher
)
self.exam2 = Exam.objects.create(
subject=self.subject2,
date=self.date,
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from datetime import datetime
from django.contrib.auth.models import User
from rest_framework.test import APITestCase, APIClient
from rest_framework.reverse import reverse
from rest_framework import status
from students.models import Class, Subject, Teacher, Student
from .serializers import ExamSerializer
from .models import Exam
and context:
# Path: students/models.py
# class Class(models.Model):
# CLASS_NUMBERS = (
# (8, 8),
# (9, 9),
# (10, 10),
# (11, 11),
# (12, 12),
# )
# CLASS_NUMBER_VALIDATORS = [MinValueValidator(8), MaxValueValidator(12)]
#
# CLASS_LETTERS = (
# ('A', 'A'),
# ('B', 'B'),
# ('V', 'V'),
# ('G', 'G'),
# )
#
# number = models.IntegerField(validators=CLASS_NUMBER_VALIDATORS, choices=CLASS_NUMBERS)
# letter = models.CharField(max_length=1, choices=CLASS_LETTERS)
#
# def __str__(self):
# return '{}{}'.format(self.number, self.letter)
#
# class Meta:
# ordering = ['number', 'letter']
# verbose_name_plural = 'classes'
#
# class Subject(models.Model):
# title = models.CharField(unique=True, max_length=50)
#
# def __str__(self):
# return self.title
#
# class Meta:
# ordering = ['title']
#
# class Teacher(Account):
# subject = models.ForeignKey(Subject, related_name='teachers', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.subject)
#
# class Student(Account):
# clazz = models.ForeignKey(Class, related_name='students', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} ({})'.format(self.user.username, self.clazz)
#
# Path: exams/serializers.py
# class ExamSerializer(serializers.ModelSerializer):
# clazz = ClassSerializer()
# topic = serializers.CharField(required=True, max_length=60)
# details = serializers.CharField(max_length=10000, allow_blank=True, required=False)
#
# class Meta:
# model = Exam
# fields = ('id', 'subject', 'date', 'clazz', 'topic', 'details', 'author')
# depth = 1
#
# def create(self, validated_data):
# request = self.context['request']
#
# author = request.user.teacher
# subject = author.subject
# clazz = get_object_or_404(Class, **validated_data.pop('clazz'))
#
# exam = Exam.objects.create(subject=subject, author=author, clazz=clazz, **validated_data)
#
# recipient_list = User.objects.filter(student__clazz=clazz)
# for user in recipient_list:
# send_creation_email(user, model=exam)
#
# return exam
#
# def update(self, instance, validated_data):
# instance.__dict__.update(**validated_data)
# instance.save()
#
# return instance
#
# Path: exams/models.py
# class Exam(models.Model):
# subject = models.ForeignKey(Subject, on_delete=models.CASCADE)
# date = models.DateField(auto_now=False, validators=[validate_date])
# clazz = models.ForeignKey(Class, on_delete=models.CASCADE)
# topic = models.CharField(max_length=60)
# details = models.TextField(max_length=10000, blank=True)
# author = models.ForeignKey(Teacher, null=True, related_name='exams', on_delete=models.CASCADE)
#
# def __str__(self):
# return '{} - {} ({})'.format(self.subject, self.clazz, self.date)
#
# class Meta:
# ordering = ['date', 'subject', 'clazz']
which might include code, classes, or functions. Output only the next line. | clazz=self.clazz, |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.