Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Next line prediction: <|code_start|># terminal_mv.py
#
# Copyright (C) 2014-2016 Kano Computing Ltd.
# License: http://www.gnu.org/licenses/gpl-2.0.txt GNU GPL v2
#
# A terminal for one of the challenges
class TerminalMv(TerminalCd):
terminal_commands = ["ls", "cat", "cd", "mv"]
def do_mv(self, line):
if "*" in line:
launch_application(self._location.get_real_path(), line, "mv")
else:
shell_command(self._location.get_real_path(), line, "mv")
def complete_mv(self, text, line, begidx, endidx):
completions = self._autocomplete_files(text, line, begidx, endidx)
<|code_end|>
. Use current file imports:
(from linux_story.commands_real import shell_command, launch_application
from linux_story.story.terminals.terminal_cd import TerminalCd)
and context including class names, function names, or small code snippets from other files:
# Path: linux_story/commands_real.py
# def shell_command(real_loc, line, command_word=""):
# """
# Suitable for launching commands which don't involve curses.
#
# Args:
# real_loc (str): the current location of the user.
# line (str): line user typed not including the command word.
# command_word (str): command you want to run (e.g. ls).
#
# Returns:
# bool: False if error, True otherwise.
# """
#
# if command_word:
# line = command_word + " " + line
#
# line = line.replace('~', fake_home_dir)
# args = line.split(" ")
#
# # run the command
# p = subprocess.Popen(args, cwd=real_loc,
# stdout=subprocess.PIPE,
# stderr=subprocess.PIPE)
# stdout, stderr = p.communicate()
#
# if stderr:
# print stderr.strip().replace(fake_home_dir, '~')
# return False
#
# if stdout:
# if command_word == "cat":
# print stdout
#
# else:
# print stdout.strip()
#
# # notifying the SoundManager about the command that was run
# sounds_manager.on_command_run(args)
#
# # should this return stdout?
# return True
#
# def launch_application(real_path, line, command_word=""):
# '''
# This is appropriate for commands which use curses (e.g. less).
#
# Args:
# real_path (str): the current location of the user.
# line (str): the line (not including the command word) the user entered.
# command_word (str): the command that we want to launch.
#
# Returns:
# None.
# '''
#
# line = line.replace('~', fake_home_dir)
# line = " ".join([command_word] + line.split(" "))
#
# p = subprocess.Popen(line, cwd=real_path, shell=True)
# stdout, stderr = p.communicate()
#
# if stdout:
# print stdout.strip()
#
# if stderr:
# print stderr.strip()
#
# Path: linux_story/story/terminals/terminal_cd.py
# class TerminalCd(TerminalCat):
# terminal_commands = ["ls", "cat", "cd"]
#
# def do_cd(self, line):
# if self.__check_cd(line):
# self._set_command_blocked(False)
# new_path = cd(self._location.get_real_path(), line)
# if not not_locked(new_path):
# self._set_command_blocked(True)
# print (
# _("bash: cd: " + line + ": Permission denied")
# )
# elif new_path:
# self._location.set_real_path(new_path)
# self._set_prompt()
# else:
# self._set_command_blocked(True)
# print (_("Nice try! But you entered an unexpected destination path."))
#
# def complete_cd(self, text, line, begidx, endidx):
# try:
# return self._autocomplete_files(text, line, begidx, endidx, only_dirs=True)
# except Exception as e:
# print str(e)
#
# def __check_cd(self, line):
# """If returns True, that means that cd will bring the user closer
# to their destination, so cd should be allowed to run with the
# user's choice of path.
# """
#
# # Get the current list of the paths that we're allowed to go on
# route = route_between_paths(self._location.get_fake_path(), self._location.get_end_dir())
#
# if not route and self._dirs_to_attempt:
# route = route_between_paths(self._location.get_fake_path(), self._dirs_to_attempt)
#
# if line:
# if line.startswith("~"):
# new_path = line
# else:
# new_path = os.path.join(self._location.get_fake_path(), line)
# else:
# # If the user didn't enter a path, assume they want to go to
# # home folder
# new_path = '~'
#
# new_path = os.path.abspath(os.path.expanduser(new_path))
# if new_path in route:
# return True
#
# return False
. Output only the next line. | return completions |
Here is a snippet: <|code_start|> "challenge": 24,
"step": 4
},
{
"challenge": 26,
"step": 1,
"exists": False
},
{
"challenge": 27,
"step": 1
},
{
"challenge": 28,
"step": 1,
"exists": False
}
]
},
{
"name": "Bernard",
"contents": get_story_file("Bernard"),
"challenges": [
{
"challenge": 23,
"step": 1
},
{
"challenge": 30,
"step": 1,
<|code_end|>
. Write the next line using the current file imports:
from linux_story.common import get_story_file
and context from other files:
# Path: linux_story/common.py
# def get_story_file(name):
# return os.path.join(fallback_story_files_dir, name)
, which may include functions, classes, or code. Output only the next line. | "exists": False |
Continue the code snippet: <|code_start|>#!/usr/bin/env python
#
# Copyright (C) 2014, 2015 Kano Computing Ltd.
# License: http://www.gnu.org/licenses/gpl-2.0.txt GNU GPL v2
#
# A terminal for one of the challenges
class TerminalChmod(TerminalNano):
terminal_commands = [
"ls", "cat", "cd", "mv", "echo", "mkdir", "nano", "chmod"
]
def do_chmod(self, line):
shell_command(self._location.get_real_path(), line, "chmod")
<|code_end|>
. Use current file imports:
from linux_story.commands_real import shell_command
from linux_story.story.terminals.terminal_nano import TerminalNano
and context (classes, functions, or code) from other files:
# Path: linux_story/commands_real.py
# def shell_command(real_loc, line, command_word=""):
# """
# Suitable for launching commands which don't involve curses.
#
# Args:
# real_loc (str): the current location of the user.
# line (str): line user typed not including the command word.
# command_word (str): command you want to run (e.g. ls).
#
# Returns:
# bool: False if error, True otherwise.
# """
#
# if command_word:
# line = command_word + " " + line
#
# line = line.replace('~', fake_home_dir)
# args = line.split(" ")
#
# # run the command
# p = subprocess.Popen(args, cwd=real_loc,
# stdout=subprocess.PIPE,
# stderr=subprocess.PIPE)
# stdout, stderr = p.communicate()
#
# if stderr:
# print stderr.strip().replace(fake_home_dir, '~')
# return False
#
# if stdout:
# if command_word == "cat":
# print stdout
#
# else:
# print stdout.strip()
#
# # notifying the SoundManager about the command that was run
# sounds_manager.on_command_run(args)
#
# # should this return stdout?
# return True
#
# Path: linux_story/story/terminals/terminal_nano.py
# class TerminalNano(TerminalMkdir):
# terminal_commands = ["ls", "cat", "cd", "mv", "echo", "mkdir", "nano"]
#
# def __init__(self, step, location, dirs_to_attempt, client):
# self._step_nano = step.get_nano_logic()
#
# TerminalMkdir.__init__(self, step, location, dirs_to_attempt, client)
#
# def do_nano(self, line):
#
# ##########################################
# # set up step_nano
# self._step_nano.set_nano_running(True)
# self._step_nano.opened_nano(line)
#
# # Read contents of the file
# text = self.read_goal_contents()
# self._step_nano.set_nano_content(text)
# ##########################################
#
# # Read nano in a separate thread
# t = threading.Thread(target=self.try_and_get_pipe_contents)
# t.daemon = True
# t.start()
#
# # If the line is given, it is the filepath of the file we are
# # adjusting.
# # if line:
# # self.set_last_nano_filepath(line)
#
# nano(self._location.get_real_path(), line)
#
# def try_and_get_pipe_contents(self):
# try:
# self._step_nano.get_pipe_contents()
# except Exception as e:
# logger.error(
# "\nFailed to get nano contents, exception {}".format(str(e))
# )
# self._step.send_hint("\nFailed to get nano contents, {}".format(str(e)))
#
# def read_goal_contents(self):
# text = ""
# end_path = generate_real_path(self._step_nano.get_goal_nano_filepath())
#
# if os.path.exists(end_path):
# # check contents of file contains the self.end_text
# f = open(end_path, "r")
# text = f.read()
# f.close()
#
# return text
. Output only the next line. | def complete_chmod(self, text, line, begidx, endidx): |
Continue the code snippet: <|code_start|> ]
},
{
"name": "grapes",
"contents": get_story_file("grapes")
},
{
"name": "milk",
"contents": get_story_file("milk")
},
{
"name": "pie",
"contents": get_story_file("pie")
},
{
"name": "sandwich",
"contents": get_story_file("sandwich")
},
{
"name": "newspaper",
"contents": get_story_file("newspaper")
},
{
"name": "oven",
"contents": get_story_file("oven")
},
{
"name": "table",
"contents": get_story_file("table")
},
<|code_end|>
. Use current file imports:
from linux_story.common import get_story_file
and context (classes, functions, or code) from other files:
# Path: linux_story/common.py
# def get_story_file(name):
# return os.path.join(fallback_story_files_dir, name)
. Output only the next line. | { |
Next line prediction: <|code_start|># test_helper_functions.py
#
# Copyright (C) 2014-2016 Kano Computing Ltd.
# License: http://www.gnu.org/licenses/gpl-2.0.txt GNU GPL v2
#
# Test helper functions
@pytest.yield_fixture
def test_env():
with EnvironmentVarGuard() as env:
yield env
def test_wrap_in_box():
output = wrap_in_box([
'{{gb:This is a long string}}',
'Short {{lb:string}}',
])
assert output == [
<|code_end|>
. Use current file imports:
(import pytest
from test.test_support import EnvironmentVarGuard
from linux_story.helper_functions import wrap_in_box, get_language_dirs)
and context including class names, function names, or small code snippets from other files:
# Path: linux_story/helper_functions.py
# def wrap_in_box(lines):
# """Wrap lines in an ascii box"""
#
# def reduction(memo, line):
# line_length = len(strip_formatting(line))
# return memo if line_length < memo else line_length
#
# def format_line(line):
# num_padding = max_characters - len(strip_formatting(line))
# return "| {} |".format(line + (" " * num_padding))
#
# max_characters = reduce(reduction, lines, 0)
# outer_line = " {} ".format("-" * (max_characters + 2))
#
# new_lines = map(format_line, lines)
#
# return [outer_line] + new_lines + [outer_line + "\n"]
#
# def get_language_dirs():
# """
# Get possible language directories to be searched for, based on
# the environment variables: LANGUAGE, LC_ALL, LC_MESSAGES and LANG.
# The result is memoized for future use.
#
# This function is inspired by python gettext.py.
#
# Returns:
# dirs (array) - an array of language directories
# """
#
# global language_dirs
# if language_dirs is not None:
# return language_dirs
#
# languages = []
# for envar in ('LANGUAGE', 'LC_ALL', 'LC_MESSAGES', 'LANG'):
# val = os.environ.get(envar)
# if val:
# languages = val.split(':')
# break
# if 'C' in languages:
# languages.remove('C')
#
# # now normalize and expand the languages
# nelangs = []
# for lang in languages:
# for nelang in gettext._expand_lang(lang):
# if nelang not in nelangs:
# nelangs.append(nelang)
#
# language_dirs = nelangs
# return language_dirs
. Output only the next line. | " ----------------------- ", |
Next line prediction: <|code_start|>
@pytest.yield_fixture
def test_env():
with EnvironmentVarGuard() as env:
yield env
def test_wrap_in_box():
output = wrap_in_box([
'{{gb:This is a long string}}',
'Short {{lb:string}}',
])
assert output == [
" ----------------------- ",
"| {{gb:This is a long string}} |",
"| Short {{lb:string}} |",
" ----------------------- \n",
]
def test_get_language_dirs(test_env):
test_env['LANG'] = 'en_GB.UTF-8'
language_dirs = get_language_dirs()
assert language_dirs == [
'en_GB.UTF-8',
'en_GB',
<|code_end|>
. Use current file imports:
(import pytest
from test.test_support import EnvironmentVarGuard
from linux_story.helper_functions import wrap_in_box, get_language_dirs)
and context including class names, function names, or small code snippets from other files:
# Path: linux_story/helper_functions.py
# def wrap_in_box(lines):
# """Wrap lines in an ascii box"""
#
# def reduction(memo, line):
# line_length = len(strip_formatting(line))
# return memo if line_length < memo else line_length
#
# def format_line(line):
# num_padding = max_characters - len(strip_formatting(line))
# return "| {} |".format(line + (" " * num_padding))
#
# max_characters = reduce(reduction, lines, 0)
# outer_line = " {} ".format("-" * (max_characters + 2))
#
# new_lines = map(format_line, lines)
#
# return [outer_line] + new_lines + [outer_line + "\n"]
#
# def get_language_dirs():
# """
# Get possible language directories to be searched for, based on
# the environment variables: LANGUAGE, LC_ALL, LC_MESSAGES and LANG.
# The result is memoized for future use.
#
# This function is inspired by python gettext.py.
#
# Returns:
# dirs (array) - an array of language directories
# """
#
# global language_dirs
# if language_dirs is not None:
# return language_dirs
#
# languages = []
# for envar in ('LANGUAGE', 'LC_ALL', 'LC_MESSAGES', 'LANG'):
# val = os.environ.get(envar)
# if val:
# languages = val.split(':')
# break
# if 'C' in languages:
# languages.remove('C')
#
# # now normalize and expand the languages
# nelangs = []
# for lang in languages:
# for nelang in gettext._expand_lang(lang):
# if nelang not in nelangs:
# nelangs.append(nelang)
#
# language_dirs = nelangs
# return language_dirs
. Output only the next line. | 'en.UTF-8', |
Predict the next line after this snippet: <|code_start|># clearing.py
#
# Copyright (C) 2014-2017 Kano Computing Ltd.
# License: http://www.gnu.org/licenses/gpl-2.0.txt GNU GPL v2
#
house = {
"name": "house",
"children": [
{
"name": "Swordmaster",
"contents": get_story_file("swordmaster"),
"challenges": [
{
"challenge": 0,
"step": 1,
<|code_end|>
using the current file's imports:
from linux_story.common import get_story_file
and any relevant context from other files:
# Path: linux_story/common.py
# def get_story_file(name):
# return os.path.join(fallback_story_files_dir, name)
. Output only the next line. | "exists": False |
Based on the snippet: <|code_start|>
chest = {
"name": "chest",
"children": [
{
"name": "scroll",
"contents": get_story_file("scroll"),
},
{
"name": "torn-note",
"contents": get_story_file("torn-note")
}
],
"challenges": [
{
"challenge": 0,
"step": 1,
"exists": False
},
{
"challenge": 44,
<|code_end|>
, predict the immediate next line with the help of imports:
from linux_story.common import get_story_file
and context (classes, functions, sometimes code) from other files:
# Path: linux_story/common.py
# def get_story_file(name):
# return os.path.join(fallback_story_files_dir, name)
. Output only the next line. | "step": 5 |
Predict the next line after this snippet: <|code_start|> _("What would you like to ask him?"),
_("\n{{yb:1: \"How did you create your tools?\"}}"),
_("{{yb:2: \"What's the next big tool you want to create?\"}}"),
_("{{yb:3: \"Are you going into hiding now?\"}}"),
_("{{yb:4: \"What's in your basement?\"}}"),
_("\nUse {{yb:echo}} to ask him a question.")
]
start_dir = "~/town/east/shed-shop"
end_dir = "~/town/east/shed-shop"
hints = [
_("{{rb:Use}} {{yb:echo 1}}{{rb:,}} {{yb:echo 2}}{{rb:,}} {{yb:echo 3}} {{rb:or}} {{yb:echo 4}}")
]
companion_speech = _("Eleanor: {{Bb:\"I have a question - does he have candy in his basement?\"}}")
commands = [
"echo 2"
]
def check_command(self, line):
if line == "echo 1":
text = (
_("\nBernard: {{Bb:\"Ah, trade secret. *wink*\"}}")
)
<|code_end|>
using the current file's imports:
from linux_story.common import get_story_file
from linux_story.step_helper_functions import unblock_cd_commands
from linux_story.helper_functions import wrap_in_box
from linux_story.story.challenges.CompanionMisc import StepTemplateMkdir, StepTemplateNano
and any relevant context from other files:
# Path: linux_story/common.py
# def get_story_file(name):
# return os.path.join(fallback_story_files_dir, name)
#
# Path: linux_story/step_helper_functions.py
# def unblock_cd_commands(line):
# if line.startswith("mkdir") or \
# (line.startswith("mv") and not line.strip() == 'mv --help'):
# print _('Nice try! But you do not need that command for this challenge')
# return True
# return False
#
# Path: linux_story/helper_functions.py
# def wrap_in_box(lines):
# """Wrap lines in an ascii box"""
#
# def reduction(memo, line):
# line_length = len(strip_formatting(line))
# return memo if line_length < memo else line_length
#
# def format_line(line):
# num_padding = max_characters - len(strip_formatting(line))
# return "| {} |".format(line + (" " * num_padding))
#
# max_characters = reduce(reduction, lines, 0)
# outer_line = " {} ".format("-" * (max_characters + 2))
#
# new_lines = map(format_line, lines)
#
# return [outer_line] + new_lines + [outer_line + "\n"]
#
# Path: linux_story/story/challenges/CompanionMisc.py
# class StepTemplateMkdir(StepTemplateEleanorBernard):
# TerminalClass = TerminalMkdirBernard
#
# class StepTemplateNano(StepTemplateEleanorBernard):
# TerminalClass = TerminalNanoBernard
. Output only the next line. | self.send_hint(text) |
Given the following code snippet before the placeholder: <|code_start|># challenge_27.py
#
# Copyright (C) 2014-2016 Kano Computing Ltd.
# License: http://www.gnu.org/licenses/gpl-2.0.txt GNU GPL v2
#
# A chapter of the story
# ----------------------------------------------------------------------------------------
class Step1(StepTemplateMkdir):
story = [
_("You are back in {{bb:Bernard}}'s place.\n"),
_("{{lb:Listen}} to what {{bb:Bernard}} has to say.")
]
start_dir = "~/town/east/shed-shop"
<|code_end|>
, predict the next line using imports from the current file:
from linux_story.common import get_story_file
from linux_story.step_helper_functions import unblock_cd_commands
from linux_story.helper_functions import wrap_in_box
from linux_story.story.challenges.CompanionMisc import StepTemplateMkdir, StepTemplateNano
and context including class names, function names, and sometimes code from other files:
# Path: linux_story/common.py
# def get_story_file(name):
# return os.path.join(fallback_story_files_dir, name)
#
# Path: linux_story/step_helper_functions.py
# def unblock_cd_commands(line):
# if line.startswith("mkdir") or \
# (line.startswith("mv") and not line.strip() == 'mv --help'):
# print _('Nice try! But you do not need that command for this challenge')
# return True
# return False
#
# Path: linux_story/helper_functions.py
# def wrap_in_box(lines):
# """Wrap lines in an ascii box"""
#
# def reduction(memo, line):
# line_length = len(strip_formatting(line))
# return memo if line_length < memo else line_length
#
# def format_line(line):
# num_padding = max_characters - len(strip_formatting(line))
# return "| {} |".format(line + (" " * num_padding))
#
# max_characters = reduce(reduction, lines, 0)
# outer_line = " {} ".format("-" * (max_characters + 2))
#
# new_lines = map(format_line, lines)
#
# return [outer_line] + new_lines + [outer_line + "\n"]
#
# Path: linux_story/story/challenges/CompanionMisc.py
# class StepTemplateMkdir(StepTemplateEleanorBernard):
# TerminalClass = TerminalMkdirBernard
#
# class StepTemplateNano(StepTemplateEleanorBernard):
# TerminalClass = TerminalNanoBernard
. Output only the next line. | end_dir = "~/town/east/shed-shop" |
Given the following code snippet before the placeholder: <|code_start|> self._nano.set_goal_nano_filepath("~/town/east/shed-shop/best-horn-in-the-world.sh")
def check_command(self, line):
if line == "cat Eleanor":
self.send_hint("\n" + self.companion_speech)
else:
return self._nano.check_nano_input()
def check_nano_contents(self):
return self._nano.check_nano_content_default()
def next(self):
return 27, 3
class Step3(StepTemplateNano):
story = [
_("Now time to test your script!"),
_("Use {{yb:./best-horn-in-the-world.sh}} to run it.")
]
start_dir = "~/town/east/shed-shop"
end_dir = "~/town/east/shed-shop"
commands = [
"./best-horn-in-the-world.sh"
]
companion_speech = _("Eleanor: {{Bb:Will it be loud?}}")
hints = [
<|code_end|>
, predict the next line using imports from the current file:
from linux_story.common import get_story_file
from linux_story.step_helper_functions import unblock_cd_commands
from linux_story.helper_functions import wrap_in_box
from linux_story.story.challenges.CompanionMisc import StepTemplateMkdir, StepTemplateNano
and context including class names, function names, and sometimes code from other files:
# Path: linux_story/common.py
# def get_story_file(name):
# return os.path.join(fallback_story_files_dir, name)
#
# Path: linux_story/step_helper_functions.py
# def unblock_cd_commands(line):
# if line.startswith("mkdir") or \
# (line.startswith("mv") and not line.strip() == 'mv --help'):
# print _('Nice try! But you do not need that command for this challenge')
# return True
# return False
#
# Path: linux_story/helper_functions.py
# def wrap_in_box(lines):
# """Wrap lines in an ascii box"""
#
# def reduction(memo, line):
# line_length = len(strip_formatting(line))
# return memo if line_length < memo else line_length
#
# def format_line(line):
# num_padding = max_characters - len(strip_formatting(line))
# return "| {} |".format(line + (" " * num_padding))
#
# max_characters = reduce(reduction, lines, 0)
# outer_line = " {} ".format("-" * (max_characters + 2))
#
# new_lines = map(format_line, lines)
#
# return [outer_line] + new_lines + [outer_line + "\n"]
#
# Path: linux_story/story/challenges/CompanionMisc.py
# class StepTemplateMkdir(StepTemplateEleanorBernard):
# TerminalClass = TerminalMkdirBernard
#
# class StepTemplateNano(StepTemplateEleanorBernard):
# TerminalClass = TerminalNanoBernard
. Output only the next line. | _("{{rb:Use}} {{yb:./best-horn-in-the-world.sh}} {{rb:to run the script.}}") |
Predict the next line for this snippet: <|code_start|># challenge_27.py
#
# Copyright (C) 2014-2016 Kano Computing Ltd.
# License: http://www.gnu.org/licenses/gpl-2.0.txt GNU GPL v2
#
# A chapter of the story
# ----------------------------------------------------------------------------------------
class Step1(StepTemplateMkdir):
story = [
_("You are back in {{bb:Bernard}}'s place.\n"),
_("{{lb:Listen}} to what {{bb:Bernard}} has to say.")
]
start_dir = "~/town/east/shed-shop"
end_dir = "~/town/east/shed-shop"
<|code_end|>
with the help of current file imports:
from linux_story.common import get_story_file
from linux_story.step_helper_functions import unblock_cd_commands
from linux_story.helper_functions import wrap_in_box
from linux_story.story.challenges.CompanionMisc import StepTemplateMkdir, StepTemplateNano
and context from other files:
# Path: linux_story/common.py
# def get_story_file(name):
# return os.path.join(fallback_story_files_dir, name)
#
# Path: linux_story/step_helper_functions.py
# def unblock_cd_commands(line):
# if line.startswith("mkdir") or \
# (line.startswith("mv") and not line.strip() == 'mv --help'):
# print _('Nice try! But you do not need that command for this challenge')
# return True
# return False
#
# Path: linux_story/helper_functions.py
# def wrap_in_box(lines):
# """Wrap lines in an ascii box"""
#
# def reduction(memo, line):
# line_length = len(strip_formatting(line))
# return memo if line_length < memo else line_length
#
# def format_line(line):
# num_padding = max_characters - len(strip_formatting(line))
# return "| {} |".format(line + (" " * num_padding))
#
# max_characters = reduce(reduction, lines, 0)
# outer_line = " {} ".format("-" * (max_characters + 2))
#
# new_lines = map(format_line, lines)
#
# return [outer_line] + new_lines + [outer_line + "\n"]
#
# Path: linux_story/story/challenges/CompanionMisc.py
# class StepTemplateMkdir(StepTemplateEleanorBernard):
# TerminalClass = TerminalMkdirBernard
#
# class StepTemplateNano(StepTemplateEleanorBernard):
# TerminalClass = TerminalNanoBernard
, which may contain function names, class names, or code. Output only the next line. | hints = [ |
Next line prediction: <|code_start|> return 27, 3
class Step3(StepTemplateNano):
story = [
_("Now time to test your script!"),
_("Use {{yb:./best-horn-in-the-world.sh}} to run it.")
]
start_dir = "~/town/east/shed-shop"
end_dir = "~/town/east/shed-shop"
commands = [
"./best-horn-in-the-world.sh"
]
companion_speech = _("Eleanor: {{Bb:Will it be loud?}}")
hints = [
_("{{rb:Use}} {{yb:./best-horn-in-the-world.sh}} {{rb:to run the script.}}")
]
def next(self):
return 27, 4
class Step4(StepTemplateNano):
# Allow the user to ask all the questions within the same Step?
story = [
_("{{gb:Congratulations, the script now prints \"Honk!\"}}"),
<|code_end|>
. Use current file imports:
(from linux_story.common import get_story_file
from linux_story.step_helper_functions import unblock_cd_commands
from linux_story.helper_functions import wrap_in_box
from linux_story.story.challenges.CompanionMisc import StepTemplateMkdir, StepTemplateNano)
and context including class names, function names, or small code snippets from other files:
# Path: linux_story/common.py
# def get_story_file(name):
# return os.path.join(fallback_story_files_dir, name)
#
# Path: linux_story/step_helper_functions.py
# def unblock_cd_commands(line):
# if line.startswith("mkdir") or \
# (line.startswith("mv") and not line.strip() == 'mv --help'):
# print _('Nice try! But you do not need that command for this challenge')
# return True
# return False
#
# Path: linux_story/helper_functions.py
# def wrap_in_box(lines):
# """Wrap lines in an ascii box"""
#
# def reduction(memo, line):
# line_length = len(strip_formatting(line))
# return memo if line_length < memo else line_length
#
# def format_line(line):
# num_padding = max_characters - len(strip_formatting(line))
# return "| {} |".format(line + (" " * num_padding))
#
# max_characters = reduce(reduction, lines, 0)
# outer_line = " {} ".format("-" * (max_characters + 2))
#
# new_lines = map(format_line, lines)
#
# return [outer_line] + new_lines + [outer_line + "\n"]
#
# Path: linux_story/story/challenges/CompanionMisc.py
# class StepTemplateMkdir(StepTemplateEleanorBernard):
# TerminalClass = TerminalMkdirBernard
#
# class StepTemplateNano(StepTemplateEleanorBernard):
# TerminalClass = TerminalNanoBernard
. Output only the next line. | _("\nBernard: {{Bb:\"The tool is working! Wonderful! " +\ |
Continue the code snippet: <|code_start|>
def write_wordlist(self, wordlist, *path):
wordlist.output('tsv', filename=self.get_path(*path, 'words'), ignore='all',
prettify=False)
print(self.get_path(*path))
def pinyin(self, chars):
py = []
for char in chars:
p = sinopy.pinyin(char)
if '?' in p or sinopy.is_chinese(p):
p = ''
py += [p]
return ' '.join(py)
def sixtuple(self, chars, debug=False):
assert len(chars) == 6
if not debug:
mch =''.join(sinopy.sixtuple2baxter(chars))
return mch
else:
return sinopy.sixtuple2baxter(chars, debug=True)
def structure(self, string):
ct = sinopy.parse_chinese_morphemes(string)
return ' '.join([b for a, b in zip(ct, 'imnft') if a != '-'])
def chinese(self, string):
return sinopy.is_chinese(string)
<|code_end|>
. Use current file imports:
from clldutils.dsv import UnicodeReader
from clldutils.misc import cached_property
from pycddb.util import cddb_path, load_languages, get_transformer
from collections import OrderedDict
from pyconcepticon.api import Concepticon, Conceptlist
from clldutils.path import Path, import_module
from lingpy import *
from sinopy import sinopy
import json
import os
and context (classes, functions, or code) from other files:
# Path: pycddb/util.py
# def cddb_path(*comps):
# return os.path.join(os.path.dirname(__file__), os.pardir, *comps)
#
# def load_languages(delimiter='\t', return_type='dict'):
#
# with UnicodeReader(cddb_path('varieties', 'languages.tsv'), delimiter='\t') as reader:
# data = list(reader)
#
# if return_type == 'dict':
# out = {}
# for line in data[1:]:
# out[line[0]] = OrderedDict(zip(
# [h.lower() for h in data[0]],
# line))
# return out
# else:
# return data
#
# def get_transformer(profile, exception=None):
#
# profile = lp.csv2list(cddb_path('profiles', profile), strip_lines=False)
# for i, line in enumerate(profile):
# profile[i] = [unicodedata.normalize('NFD', clpa.normalize(x)) for x in line]
# tokenizer = Tokenizer(profile, errors_replace=lambda x: "«{0}»".format(x))
#
# return lambda x, y: unicodedata.normalize(
# 'NFC',
# tokenizer.transform(clpa.normalize(x), column=y, separator=' + ')
# )
. Output only the next line. | def gbk_and_big5(self, chars): |
Predict the next line for this snippet: <|code_start|> idx = 0
header = [h.lower() for h in data[0]]
if key in header:
idx = header.index(key.lower())
for line in data[1:]:
d[line[idx]] = OrderedDict(zip(
[prefix+'_'+h if prefix else h for h in header],
line))
return d
def csv2list(path):
with UnicodeReader(path, delimiter='\t') as reader:
data = list(reader)
header = [h.lower() for h in data[0]]
return [dict(zip(header,line)) for line in data[1:]]
def json2dict(path):
with open(path) as f:
return json.load(f)
def data_path(path):
return lambda *x: cddb_path('datasets', path, *x)
class Dataset(object):
def __init__(self, name, data_path=data_path, base='cddb',
_languages=_languages, _path=cddb_path):
self.id = name
self.get_path = data_path(name)
<|code_end|>
with the help of current file imports:
from clldutils.dsv import UnicodeReader
from clldutils.misc import cached_property
from pycddb.util import cddb_path, load_languages, get_transformer
from collections import OrderedDict
from pyconcepticon.api import Concepticon, Conceptlist
from clldutils.path import Path, import_module
from lingpy import *
from sinopy import sinopy
import json
import os
and context from other files:
# Path: pycddb/util.py
# def cddb_path(*comps):
# return os.path.join(os.path.dirname(__file__), os.pardir, *comps)
#
# def load_languages(delimiter='\t', return_type='dict'):
#
# with UnicodeReader(cddb_path('varieties', 'languages.tsv'), delimiter='\t') as reader:
# data = list(reader)
#
# if return_type == 'dict':
# out = {}
# for line in data[1:]:
# out[line[0]] = OrderedDict(zip(
# [h.lower() for h in data[0]],
# line))
# return out
# else:
# return data
#
# def get_transformer(profile, exception=None):
#
# profile = lp.csv2list(cddb_path('profiles', profile), strip_lines=False)
# for i, line in enumerate(profile):
# profile[i] = [unicodedata.normalize('NFD', clpa.normalize(x)) for x in line]
# tokenizer = Tokenizer(profile, errors_replace=lambda x: "«{0}»".format(x))
#
# return lambda x, y: unicodedata.normalize(
# 'NFC',
# tokenizer.transform(clpa.normalize(x), column=y, separator=' + ')
# )
, which may contain function names, class names, or code. Output only the next line. | self.path = self.get_path('') |
Predict the next line after this snippet: <|code_start|>#from pylexibank.util import with_sys_path
_languages = load_languages(return_type='dict')
def csv2dict(path, key='id', prefix=''):
d = {}
with UnicodeReader(path, delimiter='\t') as reader:
<|code_end|>
using the current file's imports:
from clldutils.dsv import UnicodeReader
from clldutils.misc import cached_property
from pycddb.util import cddb_path, load_languages, get_transformer
from collections import OrderedDict
from pyconcepticon.api import Concepticon, Conceptlist
from clldutils.path import Path, import_module
from lingpy import *
from sinopy import sinopy
import json
import os
and any relevant context from other files:
# Path: pycddb/util.py
# def cddb_path(*comps):
# return os.path.join(os.path.dirname(__file__), os.pardir, *comps)
#
# def load_languages(delimiter='\t', return_type='dict'):
#
# with UnicodeReader(cddb_path('varieties', 'languages.tsv'), delimiter='\t') as reader:
# data = list(reader)
#
# if return_type == 'dict':
# out = {}
# for line in data[1:]:
# out[line[0]] = OrderedDict(zip(
# [h.lower() for h in data[0]],
# line))
# return out
# else:
# return data
#
# def get_transformer(profile, exception=None):
#
# profile = lp.csv2list(cddb_path('profiles', profile), strip_lines=False)
# for i, line in enumerate(profile):
# profile[i] = [unicodedata.normalize('NFD', clpa.normalize(x)) for x in line]
# tokenizer = Tokenizer(profile, errors_replace=lambda x: "«{0}»".format(x))
#
# return lambda x, y: unicodedata.normalize(
# 'NFC',
# tokenizer.transform(clpa.normalize(x), column=y, separator=' + ')
# )
. Output only the next line. | data = list(reader) |
Predict the next line after this snippet: <|code_start|>
def md_sources():
sources = sorted(glob(cddb_path('datasets', '*', '__init__.py')))
text = '# Datasets in the CDDB\n'
text += ' | ' .join(['DATASET', 'LANGUAGES', 'WORDS', 'CHARACTERS',
'STRUCTURES', 'TREES', 'INVENTORIES']) + '\n'
text += ' | '.join(7 * ['---'])+'\n'
for i, s in enumerate(sources):
src = os.path.split(os.path.split(s)[0])[1]
dset = Dataset(src)
words = len(dset.words) if dset.words else 0
words_langs = dset.words.height if dset.words else 0
chars = dset.characters.height if dset.characters else 0
chars_langs = dset.characters.width if dset.characters else 0
concepts = dset.words.height if dset.words else 0
structs = dset.structures.height if dset.structures else 0
structs_langs = dset.structures.height if dset.structures else 0
text += ' | '.join([
'[{0}](http://bibliography.lingpy.org?key={0})'.format(src),
str(len(dset.languages)),
'{0} words, {1} conc., {2} lngs'.format(words, concepts, words_langs),
'{0} chars, {1} lngs.'.format(chars, chars_langs),
'{0} feat., {1} lngs.'.format(structs, structs_langs),
'',
''])+'\n'
text += '\n'
with open(cddb_path('datasets/README.md'), 'w') as f:
<|code_end|>
using the current file's imports:
from pycddb.dataset import *
from pycddb.util import cddb_path
from glob import glob
import os
and any relevant context from other files:
# Path: pycddb/util.py
# def cddb_path(*comps):
# return os.path.join(os.path.dirname(__file__), os.pardir, *comps)
. Output only the next line. | f.write(text) |
Using the snippet: <|code_start|>
@test.functional
class TestARS(test.Case):
def testNormal(self):
mu = 5.
sigma = 1.
ars = ARS(Gauss(mu, sigma))
<|code_end|>
, determine the next line of code. You have imports:
import numpy
import csb.test as test
from csb.statistics.ars import ARS, Gauss
and context (class names, function names, or code) available:
# Path: csb/statistics/ars.py
# class ARS(object):
#
# from numpy import inf
#
# def __init__(self, logp):
#
# self.logp = logp
#
# def initialize(self, x, z0=-inf, zmax=inf):
#
# from numpy import array
#
# self.hull = Envelope(array(x), *self.logp(array(x)))
# self.hull.z0 = z0
# self.hull.zk = zmax
#
# def sample(self, maxiter=100):
#
# from numpy.random import random
#
# for i in range(maxiter):
#
# x = self.hull.sample()
# l = self.hull.l(x)
# u = self.hull.u(x)
# w = random()
#
# if w <= exp(l - u): return x
#
# h, dh = self.logp(x)
#
# if w <= exp(h - u): return x
#
# self.hull.insert(x, h, dh)
#
# class Gauss(LogProb):
#
# def __init__(self, mu, sigma=1.):
#
# self.mu = float(mu)
# self.sigma = float(sigma)
#
# def __call__(self, x):
#
# return -0.5 * (x - self.mu) ** 2 / self.sigma ** 2, \
# - (x - self.mu) / self.sigma ** 2
. Output only the next line. | ars.initialize([mu - 1., mu + 1.1], z0=-10., zmax=30) |
Continue the code snippet: <|code_start|>
@test.functional
class TestARS(test.Case):
def testNormal(self):
mu = 5.
sigma = 1.
ars = ARS(Gauss(mu, sigma))
ars.initialize([mu - 1., mu + 1.1], z0=-10., zmax=30)
samples = numpy.array([ars.sample() for i in range(10000)])
self.assertAlmostEqual(mu, numpy.mean(samples), delta=0.5)
<|code_end|>
. Use current file imports:
import numpy
import csb.test as test
from csb.statistics.ars import ARS, Gauss
and context (classes, functions, or code) from other files:
# Path: csb/statistics/ars.py
# class ARS(object):
#
# from numpy import inf
#
# def __init__(self, logp):
#
# self.logp = logp
#
# def initialize(self, x, z0=-inf, zmax=inf):
#
# from numpy import array
#
# self.hull = Envelope(array(x), *self.logp(array(x)))
# self.hull.z0 = z0
# self.hull.zk = zmax
#
# def sample(self, maxiter=100):
#
# from numpy.random import random
#
# for i in range(maxiter):
#
# x = self.hull.sample()
# l = self.hull.l(x)
# u = self.hull.u(x)
# w = random()
#
# if w <= exp(l - u): return x
#
# h, dh = self.logp(x)
#
# if w <= exp(h - u): return x
#
# self.hull.insert(x, h, dh)
#
# class Gauss(LogProb):
#
# def __init__(self, mu, sigma=1.):
#
# self.mu = float(mu)
# self.sigma = float(sigma)
#
# def __call__(self, x):
#
# return -0.5 * (x - self.mu) ** 2 / self.sigma ** 2, \
# - (x - self.mu) / self.sigma ** 2
. Output only the next line. | self.assertAlmostEqual(sigma, numpy.std(samples), delta=0.5) |
Predict the next line after this snippet: <|code_start|> def testBoltzmann(self):
e = numpy.linspace(-50, 1000, 1000)
be = BoltzmannEnsemble(beta=1,)
te = be.energy(e)
for i in range(len(e)):
self.assertEqual(e[i], te[i])
be = BoltzmannEnsemble(beta=0.001,)
te = be.energy(e)
for i in range(len(e)):
self.assertEqual(e[i] * 0.001, te[i])
def testTsallis(self):
e = numpy.linspace(-50, 1000, 1000)
tsallis = TsallisEnsemble(q=1.,)
te = tsallis.energy(e)
for i in range(len(e)):
self.assertEqual(e[i], te[i])
tsallis = TsallisEnsemble(q=1.1, e_min= -50.)
te = tsallis.energy(e)
q = 1.1
ee = q / (q - 1.) * csb.numeric.log(1 + (q - 1) * (e + 50.)) - 50
for i in range(len(e)):
<|code_end|>
using the current file's imports:
import numpy
import csb.numeric
import csb.test as test
from csb.statmech.ensembles import BoltzmannEnsemble, TsallisEnsemble, CompositeEnsemble
and any relevant context from other files:
# Path: csb/statmech/ensembles.py
# class BoltzmannEnsemble(StatisticalEnsemble):
#
# def __init__(self, beta=1.):
#
# self._beta = float(beta)
#
# @property
# def beta(self):
# """
# Inverse temperature
# """
# return self._beta
# @beta.setter
# def beta(self, value):
# value = float(value)
# if value <= 0.:
# raise ValueError("Inverse temperature {0} < 0".formate(value))
# self._beta = value
#
# def energy(self, raw_energies):
# return raw_energies * self._beta
#
# class TsallisEnsemble(StatisticalEnsemble):
#
# def __init__(self, q=1., e_min=0.):
#
# self._q = q
# self._e_min = e_min
#
# @property
# def q(self):
# """
# q-analoge of the temperature
# """
# return self._q
# @q.setter
# def q(self, value):
# if value <= 0.:
# raise ValueError("Inverse temperature {0} < 0".formate(value))
# self._q = value
#
# @property
# def e_min(self):
# """
# lower bound of the energy
# """
# return self._e_min
# @e_min.setter
# def e_min(self, value):
# self._e_min = value
#
# def energy(self, raw_energies):
# q = self.q
# e_min = self.e_min
#
# if (q < 1 + 1e-10):
# return raw_energies * q
# else:
# return log(1 + (raw_energies - e_min) * (q - 1)) * q / (q - 1) + e_min
#
# class CompositeEnsemble(StatisticalEnsemble):
#
# def __init__(self, ensembles=[]):
#
# self._ensembles = ensembles
#
# @property
# def ensembles(self):
# """
# Collection of statistical ensembles
# """
# return self._ensembles
# @ensembles.setter
# def ensembles(self, value):
# if not isinstance(value, list):
# if len(value) > 0:
# if not isinstance(value[0], StatisticalEnsemble):
# raise ValueError("Not a list of statistical ensembles")
# else:
# self._enesmbles = value
# else:
# self._enesmbles = value
#
# def energy(self, raw_energies):
# return sum([self._ensembles[i].energy(raw_energies[i])
# for i in range(len(self.ensembles))], 0)
#
# def gradient(self, raw_energies):
# return sum([self._ensembles[i].gradient(raw_energies[i])
# for i in range(len(self.ensembles))], 0)
. Output only the next line. | self.assertAlmostEqual(ee[i], te[i], delta=1e-5) |
Given snippet: <|code_start|>
tsallis = TsallisEnsemble(q=1.1, e_min= -50.)
te = tsallis.energy(e)
q = 1.1
ee = q / (q - 1.) * csb.numeric.log(1 + (q - 1) * (e + 50.)) - 50
for i in range(len(e)):
self.assertAlmostEqual(ee[i], te[i], delta=1e-5)
def testComposite(self):
e1 = numpy.linspace(-50, 1000, 1000)
e2 = numpy.linspace(-30, 3000, 1000)
q = 1.1
beta = 0.1
ee = q / (q - 1.) * csb.numeric.log(1 + (q - 1) * (e1 + 50.)) - 50
ee += e2 * beta
ce = CompositeEnsemble([TsallisEnsemble(q=q, e_min= -50.),
BoltzmannEnsemble(beta=beta,)])
cee = ce.energy([e1, e2])
for i in range(len(e1)):
self.assertAlmostEqual(ee[i], cee[i], delta=1e-5)
if __name__ == '__main__':
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import numpy
import csb.numeric
import csb.test as test
from csb.statmech.ensembles import BoltzmannEnsemble, TsallisEnsemble, CompositeEnsemble
and context:
# Path: csb/statmech/ensembles.py
# class BoltzmannEnsemble(StatisticalEnsemble):
#
# def __init__(self, beta=1.):
#
# self._beta = float(beta)
#
# @property
# def beta(self):
# """
# Inverse temperature
# """
# return self._beta
# @beta.setter
# def beta(self, value):
# value = float(value)
# if value <= 0.:
# raise ValueError("Inverse temperature {0} < 0".formate(value))
# self._beta = value
#
# def energy(self, raw_energies):
# return raw_energies * self._beta
#
# class TsallisEnsemble(StatisticalEnsemble):
#
# def __init__(self, q=1., e_min=0.):
#
# self._q = q
# self._e_min = e_min
#
# @property
# def q(self):
# """
# q-analoge of the temperature
# """
# return self._q
# @q.setter
# def q(self, value):
# if value <= 0.:
# raise ValueError("Inverse temperature {0} < 0".formate(value))
# self._q = value
#
# @property
# def e_min(self):
# """
# lower bound of the energy
# """
# return self._e_min
# @e_min.setter
# def e_min(self, value):
# self._e_min = value
#
# def energy(self, raw_energies):
# q = self.q
# e_min = self.e_min
#
# if (q < 1 + 1e-10):
# return raw_energies * q
# else:
# return log(1 + (raw_energies - e_min) * (q - 1)) * q / (q - 1) + e_min
#
# class CompositeEnsemble(StatisticalEnsemble):
#
# def __init__(self, ensembles=[]):
#
# self._ensembles = ensembles
#
# @property
# def ensembles(self):
# """
# Collection of statistical ensembles
# """
# return self._ensembles
# @ensembles.setter
# def ensembles(self, value):
# if not isinstance(value, list):
# if len(value) > 0:
# if not isinstance(value[0], StatisticalEnsemble):
# raise ValueError("Not a list of statistical ensembles")
# else:
# self._enesmbles = value
# else:
# self._enesmbles = value
#
# def energy(self, raw_energies):
# return sum([self._ensembles[i].energy(raw_energies[i])
# for i in range(len(self.ensembles))], 0)
#
# def gradient(self, raw_energies):
# return sum([self._ensembles[i].gradient(raw_energies[i])
# for i in range(len(self.ensembles))], 0)
which might include code, classes, or functions. Output only the next line. | test.Console() |
Continue the code snippet: <|code_start|>
try:
__doc__ = open('README.rst', encoding="utf-8").read()
except IOError:
__doc__ = ""
NAME = ROOT
AUTHOR = "Michael Habeck et al."
EMAIL = "ivan.kalev@gmail.com"
URL = "http://github.com/csb-toolbox"
SUMMARY = "Computational Structural Biology Toolbox"
DESCRIPTION = __doc__
LICENSE = 'MIT'
REQUIREMENTS = open("requirements.txt", encoding="utf-8").readlines()
DEV_REQUIREMENTS = []
if sys.version_info[0] == 2:
DEV_REQUIREMENTS.append("epydoc")
v = {}
exec(open(ROOT + "/__init__.py", encoding="utf-8").read(), v)
VERSION = v["Version"]()
<|code_end|>
. Use current file imports:
import sys
from setuptools import setup, find_packages
from csb.build import ROOT
from io import open
and context (classes, functions, or code) from other files:
# Path: csb/build.py
# ROOT = 'csb'
. Output only the next line. | def build(): |
Predict the next line after this snippet: <|code_start|> pass
def on_epoch_end(self, epoch, epoch_log):
pass
def on_batch_begin(self, batch):
pass
def on_batch_end(self, batch, batch_log):
pass
def set_params(self, params):
self.params = params
def set_model(self, model):
self.model = model
def train(self):
self.training = True
def eval(self):
self.training = False
def _set_unused_metric_mode(self, mode='none'):
if mode in ('all', 'always', 'both'):
mode = 'all'
elif mode in ('none', 'neither', 'never'):
mode = 'none'
assert mode in ('none', 'train', 'test', 'all')
self._allow_unused_metric_training = False
<|code_end|>
using the current file's imports:
import os
import csv
import numpy as np
import json
from collections import OrderedDict, defaultdict
from util.util_print import str_error, str_warning
from .Progbar import Progbar
from os.path import join, dirname
from torch.utils.tensorboard import SummaryWriter
from .html_template import TABLE_HEADER as template
and any relevant context from other files:
# Path: util/util_print.py
# class bcolors:
# HEADER = '\033[95m'
# OKBLUE = '\033[94m'
# OKGREEN = '\033[92m'
# WARNING = '\033[93m'
# FAIL = '\033[91m'
# ENDC = '\033[0m'
# BOLD = '\033[1m'
# UNDERLINE = '\033[4m'
#
# Path: loggers/Progbar.py
# class Progbar(object):
# """Displays a progress bar.
# # Arguments
# target: Total number of steps expected, None if unknown.
# interval: Minimum visual progress update interval (in seconds).
# """
#
# def __init__(self, target, width=30, verbose=1, interval=0.05, no_accum=False):
# self.width = width
# if target is None:
# target = -1
# self.target = target
# self.sum_values = {}
# self.step_values = {}
# self.unique_values = []
# self.start = time.time()
# self.last_update = 0
# self.interval = interval
# self.total_width = 0
# self.seen_so_far = 0
# self.verbose = verbose
# self.no_accume = no_accum
#
# def update(self, current, values=None, force=False):
# """Updates the progress bar.
# # Arguments
# current: Index of current step.
# values: List of tuples (name, value_for_last_step).
# The progress bar will display averages for these values.
# force: Whether to force visual progress update.
# """
# values = values or []
# for k, v in values:
# if k not in self.sum_values:
# self.sum_values[k] = [v * (current - self.seen_so_far),
# current - self.seen_so_far]
# self.unique_values.append(k)
# self.step_values[k] = v
# else:
# self.sum_values[k][0] += v * (current - self.seen_so_far)
# self.sum_values[k][1] += (current - self.seen_so_far)
# self.step_values[k] = v
#
# self.seen_so_far = current
#
# now = time.time()
# if self.verbose == 1:
# if not force and (now - self.last_update) < self.interval:
# return
#
# prev_total_width = self.total_width
# sys.stdout.write('\b' * prev_total_width)
# sys.stdout.write('\r')
#
# if self.target is not -1:
# numdigits = int(np.floor(np.log10(self.target))) + 1
# barstr = '%%%dd/%%%dd [' % (numdigits, numdigits)
# bar = barstr % (current, self.target)
# prog = float(current) / self.target
# prog_width = int(self.width * prog)
# if prog_width > 0:
# bar += ('=' * (prog_width - 1))
# if current < self.target:
# bar += '>'
# else:
# bar += '='
# bar += ('.' * (self.width - prog_width))
# bar += ']'
# sys.stdout.write(bar)
# self.total_width = len(bar)
#
# if current:
# time_per_unit = (now - self.start) / current
# else:
# time_per_unit = 0
# eta = time_per_unit * (self.target - current)
# info = ''
# if current < self.target and self.target is not -1:
# info += ' - ETA: %ds' % eta
# else:
# info += ' - %ds' % (now - self.start)
# for k in self.unique_values:
# info += ' - %s:' % k
# if isinstance(self.sum_values[k], list):
# if self.no_accume:
# avg = self.step_values[k]
# else:
# avg = np.mean(
# self.sum_values[k][0] / max(1, self.sum_values[k][1]))
# if abs(avg) > 1e-3:
# info += ' %.4f' % avg
# else:
# info += ' %.4e' % avg
# else:
# info += ' %s' % self.sum_values[k]
#
# self.total_width += len(info)
# if prev_total_width > self.total_width:
# info += ((prev_total_width - self.total_width) * ' ')
#
# sys.stdout.write(info)
# sys.stdout.flush()
#
# if current >= self.target:
# sys.stdout.write('\n')
#
# if self.verbose == 2:
# if current >= self.target:
# info = '%ds' % (now - self.start)
# for k in self.unique_values:
# info += ' - %s:' % k
# avg = np.mean(
# self.sum_values[k][0] / max(1, self.sum_values[k][1]))
# if avg > 1e-3:
# info += ' %.4f' % avg
# else:
# info += ' %.4e' % avg
# sys.stdout.write(info + "\n")
#
# self.last_update = now
#
# def add(self, n, values=None):
# self.update(self.seen_so_far + n, values)
. Output only the next line. | self._allow_unused_metric_testing = False |
Here is a snippet: <|code_start|>
""" MIT License
Copyright (c) 2019 Intel ISL (Intel Intelligent Systems Lab)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. """
class BaseModel(torch.nn.Module):
<|code_end|>
. Write the next line using the current file imports:
import torch
import torch.nn as nn
from .midas_blocks import FeatureFusionBlock, Interpolate, _make_encoder
and context from other files:
# Path: third_party/midas_blocks.py
# class FeatureFusionBlock(nn.Module):
# """Feature fusion block.
# """
#
# def __init__(self, features):
# """Init.
# Args:
# features (int): number of features
# """
# super(FeatureFusionBlock, self).__init__()
#
# self.resConfUnit1 = ResidualConvUnit(features)
# self.resConfUnit2 = ResidualConvUnit(features)
#
# def forward(self, *xs):
# """Forward pass.
# Returns:
# tensor: output
# """
# output = xs[0]
#
# if len(xs) == 2:
# output += self.resConfUnit1(xs[1])
#
# output = self.resConfUnit2(output)
#
# output = nn.functional.interpolate(
# output, scale_factor=2, mode="bilinear", align_corners=True
# )
#
# return output
#
# class Interpolate(nn.Module):
# """Interpolation module.
# """
#
# def __init__(self, scale_factor, mode):
# """Init.
# Args:
# scale_factor (float): scaling
# mode (str): interpolation mode
# """
# super(Interpolate, self).__init__()
#
# self.interp = nn.functional.interpolate
# self.scale_factor = scale_factor
# self.mode = mode
#
# def forward(self, x):
# """Forward pass.
# Args:
# x (tensor): input
# Returns:
# tensor: interpolated data
# """
#
# x = self.interp(
# x, scale_factor=self.scale_factor, mode=self.mode, align_corners=False
# )
#
# return x
#
# def _make_encoder(features, use_pretrained):
# pretrained = _make_pretrained_resnext101_wsl(use_pretrained)
# scratch = _make_scratch([256, 512, 1024, 2048], features)
#
# return pretrained, scratch
, which may include functions, classes, or code. Output only the next line. | def load(self, path): |
Given snippet: <|code_start|>
""" MIT License
Copyright (c) 2019 Intel ISL (Intel Intelligent Systems Lab)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. """
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import torch
import torch.nn as nn
from .midas_blocks import FeatureFusionBlock, Interpolate, _make_encoder
and context:
# Path: third_party/midas_blocks.py
# class FeatureFusionBlock(nn.Module):
# """Feature fusion block.
# """
#
# def __init__(self, features):
# """Init.
# Args:
# features (int): number of features
# """
# super(FeatureFusionBlock, self).__init__()
#
# self.resConfUnit1 = ResidualConvUnit(features)
# self.resConfUnit2 = ResidualConvUnit(features)
#
# def forward(self, *xs):
# """Forward pass.
# Returns:
# tensor: output
# """
# output = xs[0]
#
# if len(xs) == 2:
# output += self.resConfUnit1(xs[1])
#
# output = self.resConfUnit2(output)
#
# output = nn.functional.interpolate(
# output, scale_factor=2, mode="bilinear", align_corners=True
# )
#
# return output
#
# class Interpolate(nn.Module):
# """Interpolation module.
# """
#
# def __init__(self, scale_factor, mode):
# """Init.
# Args:
# scale_factor (float): scaling
# mode (str): interpolation mode
# """
# super(Interpolate, self).__init__()
#
# self.interp = nn.functional.interpolate
# self.scale_factor = scale_factor
# self.mode = mode
#
# def forward(self, x):
# """Forward pass.
# Args:
# x (tensor): input
# Returns:
# tensor: interpolated data
# """
#
# x = self.interp(
# x, scale_factor=self.scale_factor, mode=self.mode, align_corners=False
# )
#
# return x
#
# def _make_encoder(features, use_pretrained):
# pretrained = _make_pretrained_resnext101_wsl(use_pretrained)
# scratch = _make_scratch([256, 512, 1024, 2048], features)
#
# return pretrained, scratch
which might include code, classes, or functions. Output only the next line. | class BaseModel(torch.nn.Module): |
Based on the snippet: <|code_start|>
""" MIT License
Copyright (c) 2019 Intel ISL (Intel Intelligent Systems Lab)
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE. """
class BaseModel(torch.nn.Module):
<|code_end|>
, predict the immediate next line with the help of imports:
import torch
import torch.nn as nn
from .midas_blocks import FeatureFusionBlock, Interpolate, _make_encoder
and context (classes, functions, sometimes code) from other files:
# Path: third_party/midas_blocks.py
# class FeatureFusionBlock(nn.Module):
# """Feature fusion block.
# """
#
# def __init__(self, features):
# """Init.
# Args:
# features (int): number of features
# """
# super(FeatureFusionBlock, self).__init__()
#
# self.resConfUnit1 = ResidualConvUnit(features)
# self.resConfUnit2 = ResidualConvUnit(features)
#
# def forward(self, *xs):
# """Forward pass.
# Returns:
# tensor: output
# """
# output = xs[0]
#
# if len(xs) == 2:
# output += self.resConfUnit1(xs[1])
#
# output = self.resConfUnit2(output)
#
# output = nn.functional.interpolate(
# output, scale_factor=2, mode="bilinear", align_corners=True
# )
#
# return output
#
# class Interpolate(nn.Module):
# """Interpolation module.
# """
#
# def __init__(self, scale_factor, mode):
# """Init.
# Args:
# scale_factor (float): scaling
# mode (str): interpolation mode
# """
# super(Interpolate, self).__init__()
#
# self.interp = nn.functional.interpolate
# self.scale_factor = scale_factor
# self.mode = mode
#
# def forward(self, x):
# """Forward pass.
# Args:
# x (tensor): input
# Returns:
# tensor: interpolated data
# """
#
# x = self.interp(
# x, scale_factor=self.scale_factor, mode=self.mode, align_corners=False
# )
#
# return x
#
# def _make_encoder(features, use_pretrained):
# pretrained = _make_pretrained_resnext101_wsl(use_pretrained)
# scratch = _make_scratch([256, 512, 1024, 2048], features)
#
# return pretrained, scratch
. Output only the next line. | def load(self, path): |
Given snippet: <|code_start|>
if init_val is not None:
self.layers[-1].linear.bias.data.fill_(init_val)
def forward(self, x):
x = self.embed(x)
embed = x
for idl, l in enumerate(self.layers):
if idl % self.skip == 0 and idl > 0 and idl < len(self.layers) - 1:
x = torch.cat([x, embed], -1)
x = l(x)
return x
class MLP(nn.Module):
def __init__(self, in_ch=64, out_ch=3, depth=3, width=64, act_fn=nn.functional.relu, output_act=None, norm=None):
super().__init__()
layers = []
layers.append(DenseLayer(in_ch, width, act_fn, norm))
for d in range(depth - 1):
layers.append(DenseLayer(width, width, act_fn, norm))
layers.append(DenseLayer(width, out_ch, output_act, norm=None))
self.model = nn.Sequential(*layers)
def forward(self, x):
return self.model(x)
class DenseLayer(nn.Module):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import torch
from torch import nn
from .blocks import PeriodicEmbed
and context:
# Path: networks/blocks.py
# class PeriodicEmbed(nn.Module):
# def __init__(self, max_freq=5, N_freq=4, linspace=True):
# super().__init__()
# self.embed_functions = [torch.cos, torch.sin]
# if linspace:
# self.freqs = torch.linspace(1, max_freq + 1, steps=N_freq)
# else:
# exps = torch.linspace(0, N_freq - 1, steps=N_freq)
# self.freqs = 2**exps
#
# def forward(self, x):
# output = [x]
# for f in self.embed_functions:
# for freq in self.freqs:
# output.append(f(freq * x))
# return torch.cat(output, 1)
which might include code, classes, or functions. Output only the next line. | def __init__(self, in_ch, out_ch, act_fn=None, norm=None): |
Given the code snippet: <|code_start|> self.file_list = []
for g in gaps:
file_list = sorted(glob(join(data_path, f'shuffle_False_gap_{g:02d}_*.pt')))
self.file_list += file_list
frame_data_path = join(data_root, frame_prefix, track_name)
self.n_frames = len(sorted(glob(join(frame_data_path, '*.npz')))) + 0.0
else:
data_path = join(data_root, frame_prefix, track_name)
self.file_list = sorted(glob(join(data_path, '*.npz')))
self.n_frames = len(self.file_list) + 0.0
def __len__(self):
if self.mode != 'train':
return len(self.file_list)
else:
return len(self.file_list) * self.opt.repeat
def __getitem__(self, idx):
sample_loaded = {}
if self.opt.overfit:
idx = idx % self.opt.capat
else:
idx = idx % len(self.file_list)
if self.opt.subsample:
unit = 2.0
else:
<|code_end|>
, generate the next line using the imports in this file:
import numpy as np
import torch
from .base_dataset import Dataset as base_dataset
from glob import glob
from os.path import join
and context (functions, classes, or occasionally code) from other files:
# Path: datasets/base_dataset.py
# class Dataset(data.Dataset):
# @classmethod
# def add_arguments(cls, parser):
# return parser, set()
#
# def __init__(self, opt, mode='train', model=None):
# super().__init__()
# self.opt = opt
# self.mode = mode
#
# @staticmethod
# def convert_to_float32(sample_loaded):
# for k, v in sample_loaded.items():
# if isinstance(v, np.ndarray):
# sample_loaded[k] = torch.from_numpy(v).float()
. Output only the next line. | unit = 1.0 |
Here is a snippet: <|code_start|> self.add_module('up_%04d' % k, self.up_conv[-1])
ch_in = ch_in // 2
# This is for matching original unet implementation.
self.up_conv += [Block(ch_in * 2, ch_in, padding=1,
kernel_size=3, **conv_setup)]
self.add_module('up_%04d' % (k + 1), self.up_conv[-1])
conv_setup['activation'] = 'none'
conv_setup['norm'] = 'none'
self.output_conv = Conv2dBlock(
ch_in, out_channel, kernel_size=1, **conv_setup)
# self.add_module('output', self.up_conv[-1])
if output_activation == 'tanh':
self.final_act = nn.Tanh()
elif output_activation == 'sigmoid':
self.final_act = nn.Sigmoid()
else:
self.final_act = nn.Identity()
def forward(self, x):
feat = []
for module in self.down_conv:
x = module(x)
feat.append(x)
x = self.down_sample(x)
x = self.mid_conv(x)
for idm, module in enumerate(self.up_conv):
up_x = self.upsample(x)
f = feat[-(idm + 1)]
x = module(torch.cat([f, up_x], 1))
<|code_end|>
. Write the next line using the current file imports:
import torch
from torch import nn
from .blocks import Conv2dBlock, DoubleConv2dBlock
and context from other files:
# Path: networks/blocks.py
# class Conv2dBlock(nn.Module):
# def __init__(self, input_dim, output_dim, kernel_size, stride,
# padding=0, dilation=1, norm='weight', activation='relu', pad_type='zero', use_bias=True, *args, **karg):
# super(Conv2dBlock, self).__init__()
#
# self.conv = nn.Conv2d(input_dim, output_dim, kernel_size, stride,
# padding=0, dilation=dilation, bias=use_bias)
#
# # initialize padding
# if pad_type == 'reflect':
# self.pad = nn.ReflectionPad2d(padding)
# elif pad_type == 'zero':
# self.pad = nn.ZeroPad2d(padding)
# else:
# assert 0, "Unsupported padding type: {}".format(pad_type)
#
# # initialize normalization
# norm_dim = output_dim
# if norm == 'batch':
# self.norm = nn.BatchNorm2d(norm_dim)
# elif norm == 'inst':
# self.norm = nn.InstanceNorm2d(norm_dim, track_running_stats=False)
# elif norm == 'ln':
# self.norm = nn.LayerNorm(norm_dim)
# elif norm == 'none':
# self.norm = nn.Identity()
# elif norm == 'weight':
# self.conv = nn.utils.weight_norm(self.conv)
# self.norm = nn.Identity()
# else:
# assert 0, "Unsupported normalization: {}".format(norm)
#
# # initialize activation
# if activation == 'relu':
# self.activation = nn.ReLU(inplace=True)
# elif activation == 'lrelu':
# self.activation = nn.LeakyReLU(0.2, inplace=True)
# elif activation == 'prelu':
# self.activation = nn.PReLU()
# elif activation == 'selu':
# self.activation = nn.SELU(inplace=True)
# elif activation == 'tanh':
# self.activation = nn.Tanh()
# elif activation == 'none':
# self.activation = nn.Identity()
# else:
# assert 0, "Unsupported activation: {}".format(activation)
#
# def forward(self, x):
# x = self.conv(self.pad(x))
# x = self.norm(x)
# x = self.activation(x)
# return x
#
# class DoubleConv2dBlock(nn.Module):
# def __init__(self, input_dim, output_dim, kernel_size, stride=1,
# padding=0, dilation=1, norm='weight', activation='relu', pad_type='zero', use_bias=True, **kargs):
# super().__init__()
# self.model = nn.Sequential(Conv2dBlock(input_dim, output_dim, kernel_size, stride,
# padding, dilation, norm, activation, pad_type, use_bias),
# Conv2dBlock(output_dim, output_dim, kernel_size, stride,
# padding, dilation, norm, activation, pad_type, use_bias))
#
# def forward(self, x):
# return self.model(x)
, which may include functions, classes, or code. Output only the next line. | x = self.output_conv(x) |
Predict the next line after this snippet: <|code_start|># You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
class FCNUnet(nn.Module):
#
def __init__(self, conv_setup, n_down=4, feat=32, block_type='conv',
down_sample_type='avgpool', in_channel=2, out_channel=64, dialated_pool=False, output_activation=None):
super().__init__()
assert down_sample_type in ['avgpool', 'maxpool', 'none']
if block_type == 'conv':
Block = Conv2dBlock
elif block_type == 'double_conv':
Block = DoubleConv2dBlock
else:
raise NotImplementedError(f'block type {block_type} not supported')
# 2x downsampling using avgpool
if down_sample_type == 'avgpool':
self.down_sample = nn.AvgPool2d(kernel_size=3, stride=2, padding=1)
elif down_sample_type == 'maxpool':
self.down_sample = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
<|code_end|>
using the current file's imports:
import torch
from torch import nn
from .blocks import Conv2dBlock, DoubleConv2dBlock
and any relevant context from other files:
# Path: networks/blocks.py
# class Conv2dBlock(nn.Module):
# def __init__(self, input_dim, output_dim, kernel_size, stride,
# padding=0, dilation=1, norm='weight', activation='relu', pad_type='zero', use_bias=True, *args, **karg):
# super(Conv2dBlock, self).__init__()
#
# self.conv = nn.Conv2d(input_dim, output_dim, kernel_size, stride,
# padding=0, dilation=dilation, bias=use_bias)
#
# # initialize padding
# if pad_type == 'reflect':
# self.pad = nn.ReflectionPad2d(padding)
# elif pad_type == 'zero':
# self.pad = nn.ZeroPad2d(padding)
# else:
# assert 0, "Unsupported padding type: {}".format(pad_type)
#
# # initialize normalization
# norm_dim = output_dim
# if norm == 'batch':
# self.norm = nn.BatchNorm2d(norm_dim)
# elif norm == 'inst':
# self.norm = nn.InstanceNorm2d(norm_dim, track_running_stats=False)
# elif norm == 'ln':
# self.norm = nn.LayerNorm(norm_dim)
# elif norm == 'none':
# self.norm = nn.Identity()
# elif norm == 'weight':
# self.conv = nn.utils.weight_norm(self.conv)
# self.norm = nn.Identity()
# else:
# assert 0, "Unsupported normalization: {}".format(norm)
#
# # initialize activation
# if activation == 'relu':
# self.activation = nn.ReLU(inplace=True)
# elif activation == 'lrelu':
# self.activation = nn.LeakyReLU(0.2, inplace=True)
# elif activation == 'prelu':
# self.activation = nn.PReLU()
# elif activation == 'selu':
# self.activation = nn.SELU(inplace=True)
# elif activation == 'tanh':
# self.activation = nn.Tanh()
# elif activation == 'none':
# self.activation = nn.Identity()
# else:
# assert 0, "Unsupported activation: {}".format(activation)
#
# def forward(self, x):
# x = self.conv(self.pad(x))
# x = self.norm(x)
# x = self.activation(x)
# return x
#
# class DoubleConv2dBlock(nn.Module):
# def __init__(self, input_dim, output_dim, kernel_size, stride=1,
# padding=0, dilation=1, norm='weight', activation='relu', pad_type='zero', use_bias=True, **kargs):
# super().__init__()
# self.model = nn.Sequential(Conv2dBlock(input_dim, output_dim, kernel_size, stride,
# padding, dilation, norm, activation, pad_type, use_bias),
# Conv2dBlock(output_dim, output_dim, kernel_size, stride,
# padding, dilation, norm, activation, pad_type, use_bias))
#
# def forward(self, x):
# return self.model(x)
. Output only the next line. | else: |
Continue the code snippet: <|code_start|> if opt.tensorboard:
if opt.tensorboard_keyword != 'none':
[parent_dir, sub_dir] = logdir.split(f'/{opt.tensorboard_keyword}/')
tf_logdir = os.path.join(
parent_dir, opt.tensorboard_keyword, 'tensorboard', sub_dir)
else:
tf_logdir = os.path.join(
opt.logdir, 'tensorboard', exprdir, str(opt.expr_id))
if os.path.exists(tf_logdir) and opt.resume == 0:
os.system('rm -r ' + tf_logdir)
tensorboard_logger = loggers.TensorBoardLogger(
tf_logdir, opt.html_logger,
allow_unused_fields='all'
)
logger_list.append(
tensorboard_logger
)
logger = loggers.ComposeLogger(logger_list)
if opt.html_logger:
html_summary_filepath = os.path.join(opt.full_logdir, 'summary')
html_logger = loggers.HtmlLogger(html_summary_filepath)
logger_list.append(html_logger)
else:
# other procs do no log.
logger = loggers.ComposeLogger([loggers.TerminateOnNaN()])
# setting up models
_safe_print(str_stage, "Setting up models")
<|code_end|>
. Use current file imports:
import sys
import os
import time
import torch
import datasets
import models
import pandas as pd
import torch.multiprocessing as mp
import torch.distributed as dist
from options import options_train
from loggers import loggers
from util.util_print import str_error, str_stage, str_verbose, str_warning
from util import util_loadlib as loadlib
from subprocess import call
and context (classes, functions, or code) from other files:
# Path: options/options_train.py
# def add_general_arguments(parser):
# def overwrite(opt, opt_f_old, unique_params):
# def parse(add_additional_arguments=None):
#
# Path: loggers/loggers.py
# class BaseLogger(object):
# class _LogCumulator(BaseLogger):
# class ProgbarLogger(BaseLogger):
# class CsvLogger(BaseLogger):
# class BatchCsvLogger(BaseLogger):
# class ModelSaveLogger(BaseLogger):
# class TerminateOnNaN(BaseLogger):
# class TensorBoardLogger(BaseLogger):
# class HtmlLogger(BaseLogger):
# class ComposeLogger(BaseLogger):
# def __init__(self):
# def set_mute(self):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
# def _set_unused_metric_mode(self, mode='none'):
# def _allow_unused(self):
# def __init__(self):
# def on_epoch_begin(self, epoch):
# def on_batch_end(self, batch, batch_log):
# def get_epoch_log(self):
# def __init__(self, count_mode='samples', allow_unused_fields='none', interval=10, no_accum=False):
# def on_train_begin(self):
# def on_epoch_begin(self, epoch):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_batch_end(self, batch, batch_log=None):
# def on_train_end(self):
# def __init__(self, filepath, period=1, save_optimizer=False, save_best=False, prev_best=None):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def __init__(self, filepath, use_html_logger=False, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, summary_filepath, allow_unused_fields='none'):
# def on_train_begin(self):
# def flush(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, *args, **kargs):
# def content_to_html(self):
# def summary_to_html(self):
# def __init__(self, loggers):
# def get_tensorboard(self):
# def get_html_logger(self):
# def add_logger(self, logger):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
#
# Path: util/util_print.py
# class bcolors:
# HEADER = '\033[95m'
# OKBLUE = '\033[94m'
# OKGREEN = '\033[92m'
# WARNING = '\033[93m'
# FAIL = '\033[91m'
# ENDC = '\033[0m'
# BOLD = '\033[1m'
# UNDERLINE = '\033[4m'
#
# Path: util/util_loadlib.py
# def set_gpu(gpu, check=True):
# def _check_gpu_setting_in_use(gpu):
# def _check_gpu(gpu):
# def set_manual_seed(seed):
. Output only the next line. | Model = models.get_model(opt.net) |
Given the following code snippet before the placeholder: <|code_start|> # Old saved model does not have epoch as additional values
print(str(err))
epoch_loss_csv = os.path.join(logdir, 'epoch_loss.csv')
if opt.resume == -1:
try:
initial_epoch += pd.read_csv(epoch_loss_csv)[
'epoch'].max()
except pd.errors.ParserError:
with open(epoch_loss_csv, 'r') as f:
lines = f.readlines()
initial_epoch += max([int(l.split(',')[0])
for l in lines[1:]])
else:
initial_epoch += opt.resume
# wait until model is loaded.
if opt.multiprocess_distributed:
dist.barrier()
model.to(device)
_safe_print(model)
_safe_print("# model parameters: {:,d}".format(model.num_parameters()))
# convert to DDP and sync params
if opt.multiprocess_distributed:
for net in model._nets:
net = torch.nn.SyncBatchNorm.convert_sync_batchnorm(net)
net = torch.nn.parallel.DistributedDataParallel(net)
# sync parameters before training:
_safe_print(str_stage, 'syncing parameters....')
for net in model._nets:
<|code_end|>
, predict the next line using imports from the current file:
import sys
import os
import time
import torch
import datasets
import models
import pandas as pd
import torch.multiprocessing as mp
import torch.distributed as dist
from options import options_train
from loggers import loggers
from util.util_print import str_error, str_stage, str_verbose, str_warning
from util import util_loadlib as loadlib
from subprocess import call
and context including class names, function names, and sometimes code from other files:
# Path: options/options_train.py
# def add_general_arguments(parser):
# def overwrite(opt, opt_f_old, unique_params):
# def parse(add_additional_arguments=None):
#
# Path: loggers/loggers.py
# class BaseLogger(object):
# class _LogCumulator(BaseLogger):
# class ProgbarLogger(BaseLogger):
# class CsvLogger(BaseLogger):
# class BatchCsvLogger(BaseLogger):
# class ModelSaveLogger(BaseLogger):
# class TerminateOnNaN(BaseLogger):
# class TensorBoardLogger(BaseLogger):
# class HtmlLogger(BaseLogger):
# class ComposeLogger(BaseLogger):
# def __init__(self):
# def set_mute(self):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
# def _set_unused_metric_mode(self, mode='none'):
# def _allow_unused(self):
# def __init__(self):
# def on_epoch_begin(self, epoch):
# def on_batch_end(self, batch, batch_log):
# def get_epoch_log(self):
# def __init__(self, count_mode='samples', allow_unused_fields='none', interval=10, no_accum=False):
# def on_train_begin(self):
# def on_epoch_begin(self, epoch):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_batch_end(self, batch, batch_log=None):
# def on_train_end(self):
# def __init__(self, filepath, period=1, save_optimizer=False, save_best=False, prev_best=None):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def __init__(self, filepath, use_html_logger=False, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, summary_filepath, allow_unused_fields='none'):
# def on_train_begin(self):
# def flush(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, *args, **kargs):
# def content_to_html(self):
# def summary_to_html(self):
# def __init__(self, loggers):
# def get_tensorboard(self):
# def get_html_logger(self):
# def add_logger(self, logger):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
#
# Path: util/util_print.py
# class bcolors:
# HEADER = '\033[95m'
# OKBLUE = '\033[94m'
# OKGREEN = '\033[92m'
# WARNING = '\033[93m'
# FAIL = '\033[91m'
# ENDC = '\033[0m'
# BOLD = '\033[1m'
# UNDERLINE = '\033[4m'
#
# Path: util/util_loadlib.py
# def set_gpu(gpu, check=True):
# def _check_gpu_setting_in_use(gpu):
# def _check_gpu(gpu):
# def set_manual_seed(seed):
. Output only the next line. | for p in net.parameters(): |
Here is a snippet: <|code_start|> os.system('rm -r ' + tf_logdir)
tensorboard_logger = loggers.TensorBoardLogger(
tf_logdir, opt.html_logger,
allow_unused_fields='all'
)
logger_list.append(
tensorboard_logger
)
logger = loggers.ComposeLogger(logger_list)
if opt.html_logger:
html_summary_filepath = os.path.join(opt.full_logdir, 'summary')
html_logger = loggers.HtmlLogger(html_summary_filepath)
logger_list.append(html_logger)
else:
# other procs do no log.
logger = loggers.ComposeLogger([loggers.TerminateOnNaN()])
# setting up models
_safe_print(str_stage, "Setting up models")
Model = models.get_model(opt.net)
model = Model(opt, logger)
if global_rank == 0 and opt.tensorboard:
model._register_tensorboard(tensorboard_logger)
_safe_print(str_stage, "Setting up data loaders")
if global_rank == 0:
start_time = time.time()
dataset = datasets.get_dataset(opt.dataset)
dataset_train = dataset(opt, mode='train', model=model)
<|code_end|>
. Write the next line using the current file imports:
import sys
import os
import time
import torch
import datasets
import models
import pandas as pd
import torch.multiprocessing as mp
import torch.distributed as dist
from options import options_train
from loggers import loggers
from util.util_print import str_error, str_stage, str_verbose, str_warning
from util import util_loadlib as loadlib
from subprocess import call
and context from other files:
# Path: options/options_train.py
# def add_general_arguments(parser):
# def overwrite(opt, opt_f_old, unique_params):
# def parse(add_additional_arguments=None):
#
# Path: loggers/loggers.py
# class BaseLogger(object):
# class _LogCumulator(BaseLogger):
# class ProgbarLogger(BaseLogger):
# class CsvLogger(BaseLogger):
# class BatchCsvLogger(BaseLogger):
# class ModelSaveLogger(BaseLogger):
# class TerminateOnNaN(BaseLogger):
# class TensorBoardLogger(BaseLogger):
# class HtmlLogger(BaseLogger):
# class ComposeLogger(BaseLogger):
# def __init__(self):
# def set_mute(self):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
# def _set_unused_metric_mode(self, mode='none'):
# def _allow_unused(self):
# def __init__(self):
# def on_epoch_begin(self, epoch):
# def on_batch_end(self, batch, batch_log):
# def get_epoch_log(self):
# def __init__(self, count_mode='samples', allow_unused_fields='none', interval=10, no_accum=False):
# def on_train_begin(self):
# def on_epoch_begin(self, epoch):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_batch_end(self, batch, batch_log=None):
# def on_train_end(self):
# def __init__(self, filepath, period=1, save_optimizer=False, save_best=False, prev_best=None):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def __init__(self, filepath, use_html_logger=False, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, summary_filepath, allow_unused_fields='none'):
# def on_train_begin(self):
# def flush(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, *args, **kargs):
# def content_to_html(self):
# def summary_to_html(self):
# def __init__(self, loggers):
# def get_tensorboard(self):
# def get_html_logger(self):
# def add_logger(self, logger):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
#
# Path: util/util_print.py
# class bcolors:
# HEADER = '\033[95m'
# OKBLUE = '\033[94m'
# OKGREEN = '\033[92m'
# WARNING = '\033[93m'
# FAIL = '\033[91m'
# ENDC = '\033[0m'
# BOLD = '\033[1m'
# UNDERLINE = '\033[4m'
#
# Path: util/util_loadlib.py
# def set_gpu(gpu, check=True):
# def _check_gpu_setting_in_use(gpu):
# def _check_gpu(gpu):
# def set_manual_seed(seed):
, which may include functions, classes, or code. Output only the next line. | dataset_vali = dataset(opt, mode='vali', model=model) |
Predict the next line for this snippet: <|code_start|> if opt.full_logdir is None:
logdir = os.path.join(opt.logdir, exprdir, str(opt.expr_id))
else:
logdir = opt.full_logdir
if opt.resume == 0:
if os.path.isdir(logdir):
if opt.force_overwrite:
print(
str_warning, (
"removing Experiment %d at\n\t%s\n"
) % (opt.expr_id, logdir)
)
os.system('rm -rf ' + logdir)
elif opt.expr_id <= 0:
print(
str_warning, (
"Will remove Experiment %d at\n\t%s\n"
"Do you want to continue? (y/n)"
) % (opt.expr_id, logdir)
)
need_input = True
while need_input:
response = input().lower()
if response in ('y', 'n'):
need_input = False
if response == 'n':
print(str_stage, "User decides to quit")
sys.exit()
os.system('rm -rf ' + logdir)
<|code_end|>
with the help of current file imports:
import sys
import os
import time
import torch
import datasets
import models
import pandas as pd
import torch.multiprocessing as mp
import torch.distributed as dist
from options import options_train
from loggers import loggers
from util.util_print import str_error, str_stage, str_verbose, str_warning
from util import util_loadlib as loadlib
from subprocess import call
and context from other files:
# Path: options/options_train.py
# def add_general_arguments(parser):
# def overwrite(opt, opt_f_old, unique_params):
# def parse(add_additional_arguments=None):
#
# Path: loggers/loggers.py
# class BaseLogger(object):
# class _LogCumulator(BaseLogger):
# class ProgbarLogger(BaseLogger):
# class CsvLogger(BaseLogger):
# class BatchCsvLogger(BaseLogger):
# class ModelSaveLogger(BaseLogger):
# class TerminateOnNaN(BaseLogger):
# class TensorBoardLogger(BaseLogger):
# class HtmlLogger(BaseLogger):
# class ComposeLogger(BaseLogger):
# def __init__(self):
# def set_mute(self):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
# def _set_unused_metric_mode(self, mode='none'):
# def _allow_unused(self):
# def __init__(self):
# def on_epoch_begin(self, epoch):
# def on_batch_end(self, batch, batch_log):
# def get_epoch_log(self):
# def __init__(self, count_mode='samples', allow_unused_fields='none', interval=10, no_accum=False):
# def on_train_begin(self):
# def on_epoch_begin(self, epoch):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_batch_end(self, batch, batch_log=None):
# def on_train_end(self):
# def __init__(self, filepath, period=1, save_optimizer=False, save_best=False, prev_best=None):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def __init__(self, filepath, use_html_logger=False, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, summary_filepath, allow_unused_fields='none'):
# def on_train_begin(self):
# def flush(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, *args, **kargs):
# def content_to_html(self):
# def summary_to_html(self):
# def __init__(self, loggers):
# def get_tensorboard(self):
# def get_html_logger(self):
# def add_logger(self, logger):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
#
# Path: util/util_print.py
# class bcolors:
# HEADER = '\033[95m'
# OKBLUE = '\033[94m'
# OKGREEN = '\033[92m'
# WARNING = '\033[93m'
# FAIL = '\033[91m'
# ENDC = '\033[0m'
# BOLD = '\033[1m'
# UNDERLINE = '\033[4m'
#
# Path: util/util_loadlib.py
# def set_gpu(gpu, check=True):
# def _check_gpu_setting_in_use(gpu):
# def _check_gpu(gpu):
# def set_manual_seed(seed):
, which may contain function names, class names, or code. Output only the next line. | else: |
Given snippet: <|code_start|> print(str_warning, 'training from scratch...')
os.system('mkdir -p ' + logdir)
else:
opt_f_old = os.path.join(logdir, 'opt.pt')
opt = options_train.overwrite(opt, opt_f_old, unique_opt_params)
# Save opt
if os.path.exists(os.path.join(logdir, 'opt.pt')) and opt.pt_no_overwrite:
print(str_warning, 'not overwriting previous opt.pt, this should only be set when doing on the fly eval.')
pass
else:
torch.save(vars(opt), os.path.join(logdir, 'opt.pt'))
with open(os.path.join(logdir, 'opt.txt'), 'w') as fout:
for k, v in vars(opt).items():
fout.write('%20s\t%-20s\n' % (k, v))
opt.full_logdir = logdir
print(str_verbose, "Logging directory set to: %s" % logdir)
# Multiprocess distributed training
if opt.multiprocess_distributed:
print(str_stage, 'using multiprocessing distributed parallel model')
if opt.gpu != 'none':
print(
str_warning, f'ignoring the gpu set up in opt: {opt.gpu}. Will use all gpus in each node.')
ngpus = torch.cuda.device_count()
opt.ngpus = ngpus
opt.world_size = opt.ngpus * opt.world_size
print(f'using {ngpus} gpus')
mp.spawn(main_worker, nprocs=ngpus, args=(ngpus, opt))
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import sys
import os
import time
import torch
import datasets
import models
import pandas as pd
import torch.multiprocessing as mp
import torch.distributed as dist
from options import options_train
from loggers import loggers
from util.util_print import str_error, str_stage, str_verbose, str_warning
from util import util_loadlib as loadlib
from subprocess import call
and context:
# Path: options/options_train.py
# def add_general_arguments(parser):
# def overwrite(opt, opt_f_old, unique_params):
# def parse(add_additional_arguments=None):
#
# Path: loggers/loggers.py
# class BaseLogger(object):
# class _LogCumulator(BaseLogger):
# class ProgbarLogger(BaseLogger):
# class CsvLogger(BaseLogger):
# class BatchCsvLogger(BaseLogger):
# class ModelSaveLogger(BaseLogger):
# class TerminateOnNaN(BaseLogger):
# class TensorBoardLogger(BaseLogger):
# class HtmlLogger(BaseLogger):
# class ComposeLogger(BaseLogger):
# def __init__(self):
# def set_mute(self):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
# def _set_unused_metric_mode(self, mode='none'):
# def _allow_unused(self):
# def __init__(self):
# def on_epoch_begin(self, epoch):
# def on_batch_end(self, batch, batch_log):
# def get_epoch_log(self):
# def __init__(self, count_mode='samples', allow_unused_fields='none', interval=10, no_accum=False):
# def on_train_begin(self):
# def on_epoch_begin(self, epoch):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_batch_end(self, batch, batch_log=None):
# def on_train_end(self):
# def __init__(self, filepath, period=1, save_optimizer=False, save_best=False, prev_best=None):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def __init__(self, filepath, use_html_logger=False, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, summary_filepath, allow_unused_fields='none'):
# def on_train_begin(self):
# def flush(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, *args, **kargs):
# def content_to_html(self):
# def summary_to_html(self):
# def __init__(self, loggers):
# def get_tensorboard(self):
# def get_html_logger(self):
# def add_logger(self, logger):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
#
# Path: util/util_print.py
# class bcolors:
# HEADER = '\033[95m'
# OKBLUE = '\033[94m'
# OKGREEN = '\033[92m'
# WARNING = '\033[93m'
# FAIL = '\033[91m'
# ENDC = '\033[0m'
# BOLD = '\033[1m'
# UNDERLINE = '\033[4m'
#
# Path: util/util_loadlib.py
# def set_gpu(gpu, check=True):
# def _check_gpu_setting_in_use(gpu):
# def _check_gpu(gpu):
# def set_manual_seed(seed):
which might include code, classes, or functions. Output only the next line. | else: |
Given the code snippet: <|code_start|>#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
def main():
# Option Parsing
print(str_stage, "Parsing arguments")
opt, unique_opt_params = options_train.parse()
# Get all parse done, including subparsers
print(opt)
# Setting up log directory
print(str_stage, "Setting up logging directory")
if opt.exprdir_no_prefix:
exprdir = ''
exprdir += ('' + opt.suffix.format(**vars(opt))) if opt.suffix != '' else ''
else:
exprdir = '{}_{}_{}'.format(opt.net, opt.dataset, opt.lr)
<|code_end|>
, generate the next line using the imports in this file:
import sys
import os
import time
import torch
import datasets
import models
import pandas as pd
import torch.multiprocessing as mp
import torch.distributed as dist
from options import options_train
from loggers import loggers
from util.util_print import str_error, str_stage, str_verbose, str_warning
from util import util_loadlib as loadlib
from subprocess import call
and context (functions, classes, or occasionally code) from other files:
# Path: options/options_train.py
# def add_general_arguments(parser):
# def overwrite(opt, opt_f_old, unique_params):
# def parse(add_additional_arguments=None):
#
# Path: loggers/loggers.py
# class BaseLogger(object):
# class _LogCumulator(BaseLogger):
# class ProgbarLogger(BaseLogger):
# class CsvLogger(BaseLogger):
# class BatchCsvLogger(BaseLogger):
# class ModelSaveLogger(BaseLogger):
# class TerminateOnNaN(BaseLogger):
# class TensorBoardLogger(BaseLogger):
# class HtmlLogger(BaseLogger):
# class ComposeLogger(BaseLogger):
# def __init__(self):
# def set_mute(self):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
# def _set_unused_metric_mode(self, mode='none'):
# def _allow_unused(self):
# def __init__(self):
# def on_epoch_begin(self, epoch):
# def on_batch_end(self, batch, batch_log):
# def get_epoch_log(self):
# def __init__(self, count_mode='samples', allow_unused_fields='none', interval=10, no_accum=False):
# def on_train_begin(self):
# def on_epoch_begin(self, epoch):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_batch_end(self, batch, batch_log=None):
# def on_train_end(self):
# def __init__(self, filepath, period=1, save_optimizer=False, save_best=False, prev_best=None):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def __init__(self, filepath, use_html_logger=False, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, summary_filepath, allow_unused_fields='none'):
# def on_train_begin(self):
# def flush(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, *args, **kargs):
# def content_to_html(self):
# def summary_to_html(self):
# def __init__(self, loggers):
# def get_tensorboard(self):
# def get_html_logger(self):
# def add_logger(self, logger):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
#
# Path: util/util_print.py
# class bcolors:
# HEADER = '\033[95m'
# OKBLUE = '\033[94m'
# OKGREEN = '\033[92m'
# WARNING = '\033[93m'
# FAIL = '\033[91m'
# ENDC = '\033[0m'
# BOLD = '\033[1m'
# UNDERLINE = '\033[4m'
#
# Path: util/util_loadlib.py
# def set_gpu(gpu, check=True):
# def _check_gpu_setting_in_use(gpu):
# def _check_gpu(gpu):
# def set_manual_seed(seed):
. Output only the next line. | exprdir += ('_' + opt.suffix.format(**vars(opt))) if opt.suffix != '' else '' |
Here is a snippet: <|code_start|> device = torch.device('cpu')
else:
loadlib.set_gpu(opt.gpu)
device = torch.device('cuda')
global_rank = 0 # as if this is the master node
else:
if opt.multiprocess_distributed:
opt.global_rank = opt.node_rank * opt.ngpus + local_rank
if opt.global_rank == 0:
print(str_stage, "setting up devices...")
loadlib.set_gpu(str(local_rank))
device = torch.device('cuda')
if opt.global_rank == 0:
print(str_stage, "Setting up process groups....")
dist.init_process_group(backend=opt.dist_backend, init_method=opt.init_url,
world_size=opt.world_size, rank=opt.global_rank)
global_rank = opt.global_rank
if opt.manual_seed is not None:
loadlib.set_manual_seed(opt.manual_seed)
def _safe_print(*args, **kargs):
if global_rank == 0:
print(*args, **kargs, flush=True)
# Setting up loggers
_safe_print(str_stage, "Setting up loggers")
if opt.resume != 0 and os.path.isfile(os.path.join(logdir, 'best.pt')):
try:
prev_best_data = torch.load(os.path.join(logdir, 'best.pt'))
prev_best = prev_best_data['loss_eval']
<|code_end|>
. Write the next line using the current file imports:
import sys
import os
import time
import torch
import datasets
import models
import pandas as pd
import torch.multiprocessing as mp
import torch.distributed as dist
from options import options_train
from loggers import loggers
from util.util_print import str_error, str_stage, str_verbose, str_warning
from util import util_loadlib as loadlib
from subprocess import call
and context from other files:
# Path: options/options_train.py
# def add_general_arguments(parser):
# def overwrite(opt, opt_f_old, unique_params):
# def parse(add_additional_arguments=None):
#
# Path: loggers/loggers.py
# class BaseLogger(object):
# class _LogCumulator(BaseLogger):
# class ProgbarLogger(BaseLogger):
# class CsvLogger(BaseLogger):
# class BatchCsvLogger(BaseLogger):
# class ModelSaveLogger(BaseLogger):
# class TerminateOnNaN(BaseLogger):
# class TensorBoardLogger(BaseLogger):
# class HtmlLogger(BaseLogger):
# class ComposeLogger(BaseLogger):
# def __init__(self):
# def set_mute(self):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
# def _set_unused_metric_mode(self, mode='none'):
# def _allow_unused(self):
# def __init__(self):
# def on_epoch_begin(self, epoch):
# def on_batch_end(self, batch, batch_log):
# def get_epoch_log(self):
# def __init__(self, count_mode='samples', allow_unused_fields='none', interval=10, no_accum=False):
# def on_train_begin(self):
# def on_epoch_begin(self, epoch):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_batch_end(self, batch, batch_log=None):
# def on_train_end(self):
# def __init__(self, filepath, period=1, save_optimizer=False, save_best=False, prev_best=None):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def __init__(self, filepath, use_html_logger=False, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, summary_filepath, allow_unused_fields='none'):
# def on_train_begin(self):
# def flush(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, *args, **kargs):
# def content_to_html(self):
# def summary_to_html(self):
# def __init__(self, loggers):
# def get_tensorboard(self):
# def get_html_logger(self):
# def add_logger(self, logger):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
#
# Path: util/util_print.py
# class bcolors:
# HEADER = '\033[95m'
# OKBLUE = '\033[94m'
# OKGREEN = '\033[92m'
# WARNING = '\033[93m'
# FAIL = '\033[91m'
# ENDC = '\033[0m'
# BOLD = '\033[1m'
# UNDERLINE = '\033[4m'
#
# Path: util/util_loadlib.py
# def set_gpu(gpu, check=True):
# def _check_gpu_setting_in_use(gpu):
# def _check_gpu(gpu):
# def set_manual_seed(seed):
, which may include functions, classes, or code. Output only the next line. | del prev_best_data |
Here is a snippet: <|code_start|>Dataset = datasets.get_dataset(opt_train.dataset)
dataset = Dataset(opt_train, mode='vali', model=model)
dataloader = torch.utils.data.DataLoader(
dataset,
batch_size=opt.batch_size,
num_workers=opt.workers,
pin_memory=True,
drop_last=False,
shuffle=False
)
n_batches = len(dataloader)
dataiter = iter(dataloader)
print(str_verbose, "Time spent in data IO initialization: %.2fs" %
(time.time() - start_time))
print(str_verbose, "# test points: " + str(len(dataset)))
print(str_verbose, "# test batches: " + str(n_batches))
if hasattr(model, 'update_opt'):
model.update_opt(opt_train, is_train=False)
model.load_state_dict(net_file)
model.to(device)
model.eval()
print(model)
print("# model parameters: {:,d}".format(model.num_parameters()))
###################################################
print(str_stage, "Testing")
if opt.html_logger:
html_logger.on_train_begin()
<|code_end|>
. Write the next line using the current file imports:
import os
import time
import torch
import datasets
import models
import util.util_loadlib as loadlib
from os.path import join
from shutil import rmtree
from tqdm import tqdm
from options import options_test
from util.util_print import str_error, str_stage, str_verbose
from loggers import loggers
from argparse import Namespace
and context from other files:
# Path: options/options_test.py
# def add_general_arguments(parser):
# def parse(add_additional_arguments=None):
#
# Path: util/util_print.py
# class bcolors:
# HEADER = '\033[95m'
# OKBLUE = '\033[94m'
# OKGREEN = '\033[92m'
# WARNING = '\033[93m'
# FAIL = '\033[91m'
# ENDC = '\033[0m'
# BOLD = '\033[1m'
# UNDERLINE = '\033[4m'
#
# Path: loggers/loggers.py
# class BaseLogger(object):
# class _LogCumulator(BaseLogger):
# class ProgbarLogger(BaseLogger):
# class CsvLogger(BaseLogger):
# class BatchCsvLogger(BaseLogger):
# class ModelSaveLogger(BaseLogger):
# class TerminateOnNaN(BaseLogger):
# class TensorBoardLogger(BaseLogger):
# class HtmlLogger(BaseLogger):
# class ComposeLogger(BaseLogger):
# def __init__(self):
# def set_mute(self):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
# def _set_unused_metric_mode(self, mode='none'):
# def _allow_unused(self):
# def __init__(self):
# def on_epoch_begin(self, epoch):
# def on_batch_end(self, batch, batch_log):
# def get_epoch_log(self):
# def __init__(self, count_mode='samples', allow_unused_fields='none', interval=10, no_accum=False):
# def on_train_begin(self):
# def on_epoch_begin(self, epoch):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_batch_end(self, batch, batch_log=None):
# def on_train_end(self):
# def __init__(self, filepath, period=1, save_optimizer=False, save_best=False, prev_best=None):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def __init__(self, filepath, use_html_logger=False, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, summary_filepath, allow_unused_fields='none'):
# def on_train_begin(self):
# def flush(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, *args, **kargs):
# def content_to_html(self):
# def summary_to_html(self):
# def __init__(self, loggers):
# def get_tensorboard(self):
# def get_html_logger(self):
# def add_logger(self, logger):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
, which may include functions, classes, or code. Output only the next line. | html_logger.training = False |
Predict the next line after this snippet: <|code_start|> html_logger = loggers.HtmlLogger(html_summary_filepath)
logger_list.append(html_logger)
logger = loggers.ComposeLogger(logger_list)
###################################################
print(str_stage, "Setting up models")
Model = models.get_model(opt.net, test=True)
# load opt_original
opt_dict = torch.load(join(opt.checkpoint_path, 'opt.pt'))
opt_train = Namespace(**opt_dict)
opt_train.global_rank = 0
opt_train.output_dir = opt.output_dir
model = Model(opt_train, logger)
if hasattr(opt_train, 'midas'):
opt.midas = opt_train.midas
# checkpoint_path
if opt.epoch < 0:
net_file = join(opt.checkpoint_path, 'best.pt')
else:
net_file = join(opt.checkpoint_path, 'nets', '%04d.pt' % opt.epoch)
###################################################
print(str_stage, "Setting up data loaders")
start_time = time.time()
Dataset = datasets.get_dataset(opt_train.dataset)
dataset = Dataset(opt_train, mode='vali', model=model)
dataloader = torch.utils.data.DataLoader(
<|code_end|>
using the current file's imports:
import os
import time
import torch
import datasets
import models
import util.util_loadlib as loadlib
from os.path import join
from shutil import rmtree
from tqdm import tqdm
from options import options_test
from util.util_print import str_error, str_stage, str_verbose
from loggers import loggers
from argparse import Namespace
and any relevant context from other files:
# Path: options/options_test.py
# def add_general_arguments(parser):
# def parse(add_additional_arguments=None):
#
# Path: util/util_print.py
# class bcolors:
# HEADER = '\033[95m'
# OKBLUE = '\033[94m'
# OKGREEN = '\033[92m'
# WARNING = '\033[93m'
# FAIL = '\033[91m'
# ENDC = '\033[0m'
# BOLD = '\033[1m'
# UNDERLINE = '\033[4m'
#
# Path: loggers/loggers.py
# class BaseLogger(object):
# class _LogCumulator(BaseLogger):
# class ProgbarLogger(BaseLogger):
# class CsvLogger(BaseLogger):
# class BatchCsvLogger(BaseLogger):
# class ModelSaveLogger(BaseLogger):
# class TerminateOnNaN(BaseLogger):
# class TensorBoardLogger(BaseLogger):
# class HtmlLogger(BaseLogger):
# class ComposeLogger(BaseLogger):
# def __init__(self):
# def set_mute(self):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
# def _set_unused_metric_mode(self, mode='none'):
# def _allow_unused(self):
# def __init__(self):
# def on_epoch_begin(self, epoch):
# def on_batch_end(self, batch, batch_log):
# def get_epoch_log(self):
# def __init__(self, count_mode='samples', allow_unused_fields='none', interval=10, no_accum=False):
# def on_train_begin(self):
# def on_epoch_begin(self, epoch):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_batch_end(self, batch, batch_log=None):
# def on_train_end(self):
# def __init__(self, filepath, period=1, save_optimizer=False, save_best=False, prev_best=None):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def __init__(self, filepath, use_html_logger=False, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, summary_filepath, allow_unused_fields='none'):
# def on_train_begin(self):
# def flush(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, *args, **kargs):
# def content_to_html(self):
# def summary_to_html(self):
# def __init__(self, loggers):
# def get_tensorboard(self):
# def get_html_logger(self):
# def add_logger(self, logger):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
. Output only the next line. | dataset, |
Based on the snippet: <|code_start|> device = torch.device('cpu')
else:
loadlib.set_gpu(opt.gpu)
device = torch.device('cuda')
if opt.manual_seed is not None:
loadlib.set_manual_seed(opt.manual_seed)
###################################################
print(str_stage, "Setting up output directory")
output_dir = opt.output_dir
output_dir += (opt.net + '_' + opt.dataset + '_' + opt.suffix.format(**vars(opt))) \
if opt.suffix != '' else (opt.net + '_' + opt.dataset)
opt.output_dir = output_dir
if os.path.isdir(join(output_dir, 'epoch_%04d' % opt.epoch)):
if opt.overwrite:
rmtree(join(output_dir, 'epoch_%04d' % opt.epoch))
else:
raise ValueError(str_error + " %s already exists, but no overwrite flag"
% output_dir)
os.makedirs(output_dir, exist_ok=True)
opt.output_dir = output_dir
###################################################
print(str_stage, "Setting up loggers")
logger_list = [
loggers.TerminateOnNaN(),
]
if opt.html_logger:
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import time
import torch
import datasets
import models
import util.util_loadlib as loadlib
from os.path import join
from shutil import rmtree
from tqdm import tqdm
from options import options_test
from util.util_print import str_error, str_stage, str_verbose
from loggers import loggers
from argparse import Namespace
and context (classes, functions, sometimes code) from other files:
# Path: options/options_test.py
# def add_general_arguments(parser):
# def parse(add_additional_arguments=None):
#
# Path: util/util_print.py
# class bcolors:
# HEADER = '\033[95m'
# OKBLUE = '\033[94m'
# OKGREEN = '\033[92m'
# WARNING = '\033[93m'
# FAIL = '\033[91m'
# ENDC = '\033[0m'
# BOLD = '\033[1m'
# UNDERLINE = '\033[4m'
#
# Path: loggers/loggers.py
# class BaseLogger(object):
# class _LogCumulator(BaseLogger):
# class ProgbarLogger(BaseLogger):
# class CsvLogger(BaseLogger):
# class BatchCsvLogger(BaseLogger):
# class ModelSaveLogger(BaseLogger):
# class TerminateOnNaN(BaseLogger):
# class TensorBoardLogger(BaseLogger):
# class HtmlLogger(BaseLogger):
# class ComposeLogger(BaseLogger):
# def __init__(self):
# def set_mute(self):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
# def _set_unused_metric_mode(self, mode='none'):
# def _allow_unused(self):
# def __init__(self):
# def on_epoch_begin(self, epoch):
# def on_batch_end(self, batch, batch_log):
# def get_epoch_log(self):
# def __init__(self, count_mode='samples', allow_unused_fields='none', interval=10, no_accum=False):
# def on_train_begin(self):
# def on_epoch_begin(self, epoch):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_batch_end(self, batch, batch_log=None):
# def on_train_end(self):
# def __init__(self, filepath, period=1, save_optimizer=False, save_best=False, prev_best=None):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def __init__(self, filepath, use_html_logger=False, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, summary_filepath, allow_unused_fields='none'):
# def on_train_begin(self):
# def flush(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, *args, **kargs):
# def content_to_html(self):
# def summary_to_html(self):
# def __init__(self, loggers):
# def get_tensorboard(self):
# def get_html_logger(self):
# def add_logger(self, logger):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
. Output only the next line. | html_summary_filepath = os.path.join(opt.output_dir, 'summary') |
Using the snippet: <|code_start|># Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
print("Testing Pipeline")
###################################################
print(str_stage, "Parsing arguments")
opt = options_test.parse()
<|code_end|>
, determine the next line of code. You have imports:
import os
import time
import torch
import datasets
import models
import util.util_loadlib as loadlib
from os.path import join
from shutil import rmtree
from tqdm import tqdm
from options import options_test
from util.util_print import str_error, str_stage, str_verbose
from loggers import loggers
from argparse import Namespace
and context (class names, function names, or code) available:
# Path: options/options_test.py
# def add_general_arguments(parser):
# def parse(add_additional_arguments=None):
#
# Path: util/util_print.py
# class bcolors:
# HEADER = '\033[95m'
# OKBLUE = '\033[94m'
# OKGREEN = '\033[92m'
# WARNING = '\033[93m'
# FAIL = '\033[91m'
# ENDC = '\033[0m'
# BOLD = '\033[1m'
# UNDERLINE = '\033[4m'
#
# Path: loggers/loggers.py
# class BaseLogger(object):
# class _LogCumulator(BaseLogger):
# class ProgbarLogger(BaseLogger):
# class CsvLogger(BaseLogger):
# class BatchCsvLogger(BaseLogger):
# class ModelSaveLogger(BaseLogger):
# class TerminateOnNaN(BaseLogger):
# class TensorBoardLogger(BaseLogger):
# class HtmlLogger(BaseLogger):
# class ComposeLogger(BaseLogger):
# def __init__(self):
# def set_mute(self):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
# def _set_unused_metric_mode(self, mode='none'):
# def _allow_unused(self):
# def __init__(self):
# def on_epoch_begin(self, epoch):
# def on_batch_end(self, batch, batch_log):
# def get_epoch_log(self):
# def __init__(self, count_mode='samples', allow_unused_fields='none', interval=10, no_accum=False):
# def on_train_begin(self):
# def on_epoch_begin(self, epoch):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_batch_end(self, batch, batch_log=None):
# def on_train_end(self):
# def __init__(self, filepath, period=1, save_optimizer=False, save_best=False, prev_best=None):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def __init__(self, filepath, use_html_logger=False, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, summary_filepath, allow_unused_fields='none'):
# def on_train_begin(self):
# def flush(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, *args, **kargs):
# def content_to_html(self):
# def summary_to_html(self):
# def __init__(self, loggers):
# def get_tensorboard(self):
# def get_html_logger(self):
# def add_logger(self, logger):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
. Output only the next line. | opt.full_logdir = None |
Given the following code snippet before the placeholder: <|code_start|> pin_memory=True,
drop_last=False,
shuffle=False
)
n_batches = len(dataloader)
dataiter = iter(dataloader)
print(str_verbose, "Time spent in data IO initialization: %.2fs" %
(time.time() - start_time))
print(str_verbose, "# test points: " + str(len(dataset)))
print(str_verbose, "# test batches: " + str(n_batches))
if hasattr(model, 'update_opt'):
model.update_opt(opt_train, is_train=False)
model.load_state_dict(net_file)
model.to(device)
model.eval()
print(model)
print("# model parameters: {:,d}".format(model.num_parameters()))
###################################################
print(str_stage, "Testing")
if opt.html_logger:
html_logger.on_train_begin()
html_logger.training = False
html_logger.on_epoch_begin(0)
model.opt.epoch = opt.epoch
for i in tqdm(range(n_batches)):
batch = next(dataiter)
<|code_end|>
, predict the next line using imports from the current file:
import os
import time
import torch
import datasets
import models
import util.util_loadlib as loadlib
from os.path import join
from shutil import rmtree
from tqdm import tqdm
from options import options_test
from util.util_print import str_error, str_stage, str_verbose
from loggers import loggers
from argparse import Namespace
and context including class names, function names, and sometimes code from other files:
# Path: options/options_test.py
# def add_general_arguments(parser):
# def parse(add_additional_arguments=None):
#
# Path: util/util_print.py
# class bcolors:
# HEADER = '\033[95m'
# OKBLUE = '\033[94m'
# OKGREEN = '\033[92m'
# WARNING = '\033[93m'
# FAIL = '\033[91m'
# ENDC = '\033[0m'
# BOLD = '\033[1m'
# UNDERLINE = '\033[4m'
#
# Path: loggers/loggers.py
# class BaseLogger(object):
# class _LogCumulator(BaseLogger):
# class ProgbarLogger(BaseLogger):
# class CsvLogger(BaseLogger):
# class BatchCsvLogger(BaseLogger):
# class ModelSaveLogger(BaseLogger):
# class TerminateOnNaN(BaseLogger):
# class TensorBoardLogger(BaseLogger):
# class HtmlLogger(BaseLogger):
# class ComposeLogger(BaseLogger):
# def __init__(self):
# def set_mute(self):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
# def _set_unused_metric_mode(self, mode='none'):
# def _allow_unused(self):
# def __init__(self):
# def on_epoch_begin(self, epoch):
# def on_batch_end(self, batch, batch_log):
# def get_epoch_log(self):
# def __init__(self, count_mode='samples', allow_unused_fields='none', interval=10, no_accum=False):
# def on_train_begin(self):
# def on_epoch_begin(self, epoch):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, filename, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_batch_end(self, batch, batch_log=None):
# def on_train_end(self):
# def __init__(self, filepath, period=1, save_optimizer=False, save_best=False, prev_best=None):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def __init__(self):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def __init__(self, filepath, use_html_logger=False, allow_unused_fields='none'):
# def on_train_begin(self):
# def on_epoch_end(self, epoch, epoch_log):
# def on_train_end(self):
# def __init__(self, summary_filepath, allow_unused_fields='none'):
# def on_train_begin(self):
# def flush(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, *args, **kargs):
# def content_to_html(self):
# def summary_to_html(self):
# def __init__(self, loggers):
# def get_tensorboard(self):
# def get_html_logger(self):
# def add_logger(self, logger):
# def on_train_begin(self):
# def on_train_end(self):
# def on_epoch_begin(self, epoch):
# def on_epoch_end(self, epoch, epoch_log):
# def on_batch_begin(self, batch):
# def on_batch_end(self, batch, batch_log):
# def set_params(self, params):
# def set_model(self, model):
# def train(self):
# def eval(self):
. Output only the next line. | model.test_on_batch(i, batch) |
Given the following code snippet before the placeholder: <|code_start|># Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
class SceneFlowFieldNet(nn.Module):
def __init__(self, time_dependent=True, N_freq_xyz=0, N_freq_t=0, output_dim=3, net_width=32, n_layers=3, activation='lrelu', norm='none'):
super().__init__()
N_input_channel_xyz = 3 + 3 * 2 * N_freq_xyz
N_input_channel_t = 1 + 1 * 2 * N_freq_t
N_input_channel = N_input_channel_xyz + N_input_channel_t if time_dependent else N_input_channel_xyz
if N_freq_xyz == 0:
xyz_embed = nn.Identity()
else:
xyz_embed = PeriodicEmbed(max_freq=N_freq_xyz, N_freq=N_freq_xyz)
if N_freq_t == 0:
<|code_end|>
, predict the next line using imports from the current file:
import torch
from torch import nn
from .blocks import PeriodicEmbed, Conv2dBlock
and context including class names, function names, and sometimes code from other files:
# Path: networks/blocks.py
# class PeriodicEmbed(nn.Module):
# def __init__(self, max_freq=5, N_freq=4, linspace=True):
# super().__init__()
# self.embed_functions = [torch.cos, torch.sin]
# if linspace:
# self.freqs = torch.linspace(1, max_freq + 1, steps=N_freq)
# else:
# exps = torch.linspace(0, N_freq - 1, steps=N_freq)
# self.freqs = 2**exps
#
# def forward(self, x):
# output = [x]
# for f in self.embed_functions:
# for freq in self.freqs:
# output.append(f(freq * x))
# return torch.cat(output, 1)
#
# class Conv2dBlock(nn.Module):
# def __init__(self, input_dim, output_dim, kernel_size, stride,
# padding=0, dilation=1, norm='weight', activation='relu', pad_type='zero', use_bias=True, *args, **karg):
# super(Conv2dBlock, self).__init__()
#
# self.conv = nn.Conv2d(input_dim, output_dim, kernel_size, stride,
# padding=0, dilation=dilation, bias=use_bias)
#
# # initialize padding
# if pad_type == 'reflect':
# self.pad = nn.ReflectionPad2d(padding)
# elif pad_type == 'zero':
# self.pad = nn.ZeroPad2d(padding)
# else:
# assert 0, "Unsupported padding type: {}".format(pad_type)
#
# # initialize normalization
# norm_dim = output_dim
# if norm == 'batch':
# self.norm = nn.BatchNorm2d(norm_dim)
# elif norm == 'inst':
# self.norm = nn.InstanceNorm2d(norm_dim, track_running_stats=False)
# elif norm == 'ln':
# self.norm = nn.LayerNorm(norm_dim)
# elif norm == 'none':
# self.norm = nn.Identity()
# elif norm == 'weight':
# self.conv = nn.utils.weight_norm(self.conv)
# self.norm = nn.Identity()
# else:
# assert 0, "Unsupported normalization: {}".format(norm)
#
# # initialize activation
# if activation == 'relu':
# self.activation = nn.ReLU(inplace=True)
# elif activation == 'lrelu':
# self.activation = nn.LeakyReLU(0.2, inplace=True)
# elif activation == 'prelu':
# self.activation = nn.PReLU()
# elif activation == 'selu':
# self.activation = nn.SELU(inplace=True)
# elif activation == 'tanh':
# self.activation = nn.Tanh()
# elif activation == 'none':
# self.activation = nn.Identity()
# else:
# assert 0, "Unsupported activation: {}".format(activation)
#
# def forward(self, x):
# x = self.conv(self.pad(x))
# x = self.norm(x)
# x = self.activation(x)
# return x
. Output only the next line. | t_embed = nn.Identity() |
Based on the snippet: <|code_start|># Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
class SceneFlowFieldNet(nn.Module):
def __init__(self, time_dependent=True, N_freq_xyz=0, N_freq_t=0, output_dim=3, net_width=32, n_layers=3, activation='lrelu', norm='none'):
super().__init__()
N_input_channel_xyz = 3 + 3 * 2 * N_freq_xyz
N_input_channel_t = 1 + 1 * 2 * N_freq_t
N_input_channel = N_input_channel_xyz + N_input_channel_t if time_dependent else N_input_channel_xyz
if N_freq_xyz == 0:
<|code_end|>
, predict the immediate next line with the help of imports:
import torch
from torch import nn
from .blocks import PeriodicEmbed, Conv2dBlock
and context (classes, functions, sometimes code) from other files:
# Path: networks/blocks.py
# class PeriodicEmbed(nn.Module):
# def __init__(self, max_freq=5, N_freq=4, linspace=True):
# super().__init__()
# self.embed_functions = [torch.cos, torch.sin]
# if linspace:
# self.freqs = torch.linspace(1, max_freq + 1, steps=N_freq)
# else:
# exps = torch.linspace(0, N_freq - 1, steps=N_freq)
# self.freqs = 2**exps
#
# def forward(self, x):
# output = [x]
# for f in self.embed_functions:
# for freq in self.freqs:
# output.append(f(freq * x))
# return torch.cat(output, 1)
#
# class Conv2dBlock(nn.Module):
# def __init__(self, input_dim, output_dim, kernel_size, stride,
# padding=0, dilation=1, norm='weight', activation='relu', pad_type='zero', use_bias=True, *args, **karg):
# super(Conv2dBlock, self).__init__()
#
# self.conv = nn.Conv2d(input_dim, output_dim, kernel_size, stride,
# padding=0, dilation=dilation, bias=use_bias)
#
# # initialize padding
# if pad_type == 'reflect':
# self.pad = nn.ReflectionPad2d(padding)
# elif pad_type == 'zero':
# self.pad = nn.ZeroPad2d(padding)
# else:
# assert 0, "Unsupported padding type: {}".format(pad_type)
#
# # initialize normalization
# norm_dim = output_dim
# if norm == 'batch':
# self.norm = nn.BatchNorm2d(norm_dim)
# elif norm == 'inst':
# self.norm = nn.InstanceNorm2d(norm_dim, track_running_stats=False)
# elif norm == 'ln':
# self.norm = nn.LayerNorm(norm_dim)
# elif norm == 'none':
# self.norm = nn.Identity()
# elif norm == 'weight':
# self.conv = nn.utils.weight_norm(self.conv)
# self.norm = nn.Identity()
# else:
# assert 0, "Unsupported normalization: {}".format(norm)
#
# # initialize activation
# if activation == 'relu':
# self.activation = nn.ReLU(inplace=True)
# elif activation == 'lrelu':
# self.activation = nn.LeakyReLU(0.2, inplace=True)
# elif activation == 'prelu':
# self.activation = nn.PReLU()
# elif activation == 'selu':
# self.activation = nn.SELU(inplace=True)
# elif activation == 'tanh':
# self.activation = nn.Tanh()
# elif activation == 'none':
# self.activation = nn.Identity()
# else:
# assert 0, "Unsupported activation: {}".format(activation)
#
# def forward(self, x):
# x = self.conv(self.pad(x))
# x = self.norm(x)
# x = self.activation(x)
# return x
. Output only the next line. | xyz_embed = nn.Identity() |
Given the code snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.SHAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('api:shame'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('application/json', self.resp['Content-Type'])
def test_contents(self):
json_resp = self.resp.json()
shame = json_resp['providers']
with self.subTest():
self.assertEqual(1, len(shame))
self.assertNotIn('fame', json_resp)
self.assertEqual('Xpto', shame[0]['name'])
<|code_end|>
, generate the next line using the imports in this file:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context (functions, classes, or occasionally code) from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | self.assertEqual('http://xp.to', shame[0]['url']) |
Given snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.SHAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
provider = Provider.objects.create(**props)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
which might include code, classes, or functions. Output only the next line. | provider.coverage.set([sc, go]) |
Based on the snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
sp, *_ = State.objects.get_or_create(abbr='GO', name='São Paulo')
props_published = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
props_refused= {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.REFUSED}
provider_published = Provider.objects.create(**props_published)
provider_refused = Provider.objects.create(**props_refused)
provider_published.coverage.set([sc, go])
provider_refused.coverage.set([sp])
self.resp = self.client.get(resolve_url('markdown:fame'))
def test_get(self):
<|code_end|>
, predict the immediate next line with the help of imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context (classes, functions, sometimes code) from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | self.assertEqual(200, self.resp.status_code) |
Predict the next line for this snippet: <|code_start|> sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
sp, *_ = State.objects.get_or_create(abbr='GO', name='São Paulo')
props_published = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
props_refused= {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.REFUSED}
provider_published = Provider.objects.create(**props_published)
provider_refused = Provider.objects.create(**props_refused)
provider_published.coverage.set([sc, go])
provider_refused.coverage.set([sp])
self.resp = self.client.get(resolve_url('markdown:fame'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('text/markdown; charset=UTF-8', self.resp['Content-Type'])
def test_template(self):
self.assertTemplateUsed(self.resp, 'markdown/fame.md')
<|code_end|>
with the help of current file imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
, which may contain function names, class names, or code. Output only the next line. | def test_contents(self): |
Here is a snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
self.resp = self.client.get(resolve_url('new'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('text/html', self.resp['Content-Type'][0:9])
def test_template(self):
<|code_end|>
. Write the next line using the current file imports:
from django.contrib.auth.models import User
from django.core import mail
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.models import Provider, State
and context from other files:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
, which may include functions, classes, or code. Output only the next line. | self.assertTemplateUsed(self.resp, 'core/provider_form.html') |
Predict the next line for this snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
self.resp = self.client.get(resolve_url('new'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('text/html', self.resp['Content-Type'][0:9])
def test_template(self):
self.assertTemplateUsed(self.resp, 'core/provider_form.html')
def test_contents(self):
tags = (('<form', 1),
('<select ', 1),
('type="text"', 2),
('type="url"', 2))
for text, count in tags:
with self.subTest():
self.assertContains(self.resp, text, count)
def test_csrf(self):
self.assertContains(self.resp, 'csrfmiddlewaretoken')
def test_has_form(self):
<|code_end|>
with the help of current file imports:
from django.contrib.auth.models import User
from django.core import mail
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.models import Provider, State
and context from other files:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
, which may contain function names, class names, or code. Output only the next line. | form = self.resp.context['form'] |
Given the code snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
self.resp = self.client.get(resolve_url('new'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('text/html', self.resp['Content-Type'][0:9])
def test_template(self):
self.assertTemplateUsed(self.resp, 'core/provider_form.html')
def test_contents(self):
tags = (('<form', 1),
('<select ', 1),
('type="text"', 2),
('type="url"', 2))
<|code_end|>
, generate the next line using the imports in this file:
from django.contrib.auth.models import User
from django.core import mail
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.models import Provider, State
and context (functions, classes, or occasionally code) from other files:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | for text, count in tags: |
Predict the next line for this snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
sp, *_ = State.objects.get_or_create(abbr='SP', name='São Paulo')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.REFUSED,
'moderation_reason': Provider.REPEATED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('api:provider', 1))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('application/json', self.resp['Content-Type'])
def test_contents(self):
json_resp = self.resp.json()
provider = json_resp['provider']
<|code_end|>
with the help of current file imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
, which may contain function names, class names, or code. Output only the next line. | with self.subTest(): |
Given snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
sp, *_ = State.objects.get_or_create(abbr='SP', name='São Paulo')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.REFUSED,
'moderation_reason': Provider.REPEATED}
provider = Provider.objects.create(**props)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
which might include code, classes, or functions. Output only the next line. | provider.coverage.set([sc, go]) |
Predict the next line for this snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.SHAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('api:shame_by_state', 'go'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('application/json', self.resp['Content-Type'])
def test_contents(self):
json_resp = self.resp.json()
fame = json_resp['providers']
with self.subTest():
self.assertEqual(1, len(fame))
self.assertEqual('Xpto', fame[0]['name'])
<|code_end|>
with the help of current file imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
, which may contain function names, class names, or code. Output only the next line. | self.assertEqual('http://xp.to', fame[0]['url']) |
Using the snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.SHAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('api:shame_by_state', 'go'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
<|code_end|>
, determine the next line of code. You have imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context (class names, function names, or code) available:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | self.assertEqual('application/json', self.resp['Content-Type']) |
Based on the snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.SHAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('markdown:shame'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('text/markdown; charset=UTF-8', self.resp['Content-Type'])
def test_template(self):
self.assertTemplateUsed(self.resp, 'markdown/shame.md')
def test_contents(self):
contents = ['Xpto', 'GO, SC', 'Lorem', 'http://xp.to', 'twitter.com']
for content in contents:
<|code_end|>
, predict the immediate next line with the help of imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context (classes, functions, sometimes code) from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | with self.subTest(): |
Based on the snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.SHAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('markdown:shame'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('text/markdown; charset=UTF-8', self.resp['Content-Type'])
def test_template(self):
<|code_end|>
, predict the immediate next line with the help of imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context (classes, functions, sometimes code) from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | self.assertTemplateUsed(self.resp, 'markdown/shame.md') |
Predict the next line for this snippet: <|code_start|> def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('api:fame'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('application/json', self.resp['Content-Type'])
def test_contents(self):
json_resp = self.resp.json()
fame = json_resp['providers']
with self.subTest():
self.assertEqual(1, len(fame))
self.assertNotIn('hall-of-shame', json_resp)
self.assertEqual('Xpto', fame[0]['name'])
self.assertEqual('http://xp.to', fame[0]['url'])
self.assertEqual('http://twitter.com/xpto', fame[0]['source'])
self.assertEqual(['GO', 'SC'], fame[0]['coverage'])
self.assertEqual('Hall of Fame', fame[0]['category'])
<|code_end|>
with the help of current file imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
, which may contain function names, class names, or code. Output only the next line. | self.assertEqual('Lorem ipsum', fame[0]['other']) |
Here is a snippet: <|code_start|> def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('api:fame'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('application/json', self.resp['Content-Type'])
def test_contents(self):
json_resp = self.resp.json()
fame = json_resp['providers']
with self.subTest():
self.assertEqual(1, len(fame))
self.assertNotIn('hall-of-shame', json_resp)
self.assertEqual('Xpto', fame[0]['name'])
self.assertEqual('http://xp.to', fame[0]['url'])
self.assertEqual('http://twitter.com/xpto', fame[0]['source'])
self.assertEqual(['GO', 'SC'], fame[0]['coverage'])
self.assertEqual('Hall of Fame', fame[0]['category'])
<|code_end|>
. Write the next line using the current file imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
, which may include functions, classes, or code. Output only the next line. | self.assertEqual('Lorem ipsum', fame[0]['other']) |
Here is a snippet: <|code_start|>
class TestPostInvalid(TestCase):
def setUp(self):
User.objects.create_superuser(username='two', password='', email='42@xp.to')
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
self.provider = Provider.objects.create(
name='Xpto',
url='http://xp.to',
source='http://twitter.com/xpto',
category=Provider.SHAME,
other='Lorem ipsum'
)
self.provider.coverage.add(sc)
self.provider.coverage.add(go)
self.resp = self.client.post(resolve_url('api:provider', self.provider.pk), dict())
def test_post(self):
self.assertEqual(422, self.resp.status_code)
def test_has_errors_on_empty_form(self):
json_resp = self.resp.json()
self.assertTrue(json_resp['errors'])
def test_has_errors_on_non_empty_form(self):
invalid_data = {'name': 'Xpto', 'coverage': ['xp', 'to'], 'url': ''}
<|code_end|>
. Write the next line using the current file imports:
from django.contrib.auth.models import User
from django.core import mail
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.models import Provider, State
and context from other files:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
, which may include functions, classes, or code. Output only the next line. | resp = self.client.post(resolve_url('api:provider', self.provider.pk), invalid_data) |
Predict the next line after this snippet: <|code_start|>
class TestPostInvalid(TestCase):
def setUp(self):
User.objects.create_superuser(username='two', password='', email='42@xp.to')
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
self.provider = Provider.objects.create(
name='Xpto',
url='http://xp.to',
source='http://twitter.com/xpto',
category=Provider.SHAME,
other='Lorem ipsum'
)
self.provider.coverage.add(sc)
self.provider.coverage.add(go)
self.resp = self.client.post(resolve_url('api:provider', self.provider.pk), dict())
def test_post(self):
self.assertEqual(422, self.resp.status_code)
def test_has_errors_on_empty_form(self):
json_resp = self.resp.json()
self.assertTrue(json_resp['errors'])
def test_has_errors_on_non_empty_form(self):
<|code_end|>
using the current file's imports:
from django.contrib.auth.models import User
from django.core import mail
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.models import Provider, State
and any relevant context from other files:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | invalid_data = {'name': 'Xpto', 'coverage': ['xp', 'to'], 'url': ''} |
Continue the code snippet: <|code_start|> ordering = ['name']
class Provider(models.Model):
FAME = 'F'
SHAME = 'S'
CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
(SHAME, 'Hall of Shame (utilizará limites/franquia)'))
CATEGORIES_DICT = dict(CATEGORIES)
NEW = 'N'
DISCUSSION = 'D'
PUBLISHED = 'P'
REFUSED = 'R'
EDIT = 'E'
OUTDATED = 'O'
STATUS = ((NEW, 'Aguardando moderação'),
(DISCUSSION, 'Em discussão'),
(PUBLISHED, 'Publicado'),
(REFUSED, 'Recusado'),
(EDIT, 'Edição aguardando moderação'),
(OUTDATED, 'Substituído por versão atualizada'))
BLANK = ''
REPEATED = 'R'
NOT_FOUND = 'N'
IMPRECISE = 'I'
NOT_ACCESSIBLE = 'A'
PRIVATE = 'P'
<|code_end|>
. Use current file imports:
import re
from django.db import models
from django.shortcuts import resolve_url
from InternetSemLimites.core.managers import ProviderManager
and context (classes, functions, or code) from other files:
# Path: InternetSemLimites/core/managers.py
# class ProviderQueryset(models.QuerySet):
# def published(self):
# def fame(self):
# def shame(self):
. Output only the next line. | OTHER = 'O' |
Continue the code snippet: <|code_start|>
class TestProviderForm(TestCase):
def test_form_has_fields(self):
form = ProviderForm()
fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
self.assertSequenceEqual(list(form.fields), fields)
def test_other_is_optional(self):
form = self._valid_form(other='')
<|code_end|>
. Use current file imports:
from django.test import TestCase
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.models import Provider, State
and context (classes, functions, or code) from other files:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | self.assertFalse(form.errors) |
Predict the next line for this snippet: <|code_start|>
class TestProviderForm(TestCase):
def test_form_has_fields(self):
form = ProviderForm()
<|code_end|>
with the help of current file imports:
from django.test import TestCase
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.models import Provider, State
and context from other files:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
, which may contain function names, class names, or code. Output only the next line. | fields = ['category', 'name', 'url', 'source', 'coverage', 'other'] |
Based on the snippet: <|code_start|> def setUp(self):
User.objects.create_superuser(username='two', password='', email='42@xp.to')
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
data = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'coverage': [sc.pk, go.pk],
'category': Provider.SHAME,
'other': 'Lorem ipsum'}
self.resp = self.client.post(resolve_url('api:new'), data)
def test_post(self):
self.assertRedirects(self.resp, resolve_url('api:provider', 1))
def test_send_email(self):
self.assertEqual(1, len(mail.outbox))
def test_save(self):
self.assertTrue(Provider.objects.exists())
class TestPostInvalid(TestCase):
def setUp(self):
self.resp = self.client.post(resolve_url('api:new'), dict())
def test_post(self):
self.assertEqual(200, self.resp.status_code)
<|code_end|>
, predict the immediate next line with the help of imports:
from django.contrib.auth.models import User
from django.core import mail
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.models import Provider, State
and context (classes, functions, sometimes code) from other files:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | def test_dont_save(self): |
Predict the next line after this snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
self.resp = self.client.get(resolve_url('api:new'))
def test_get(self):
self.assertEqual(405, self.resp.status_code)
<|code_end|>
using the current file's imports:
from django.contrib.auth.models import User
from django.core import mail
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.models import Provider, State
and any relevant context from other files:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | class TestPostValid(TestCase): |
Next line prediction: <|code_start|> props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('api:by_state', 'go'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('application/json', self.resp['Content-Type'])
def test_contents(self):
json_resp = self.resp.json()
fame = json_resp['hall-of-fame']
shame = json_resp['hall-of-shame']
with self.subTest():
self.assertEqual(1, len(fame))
self.assertEqual(0, len(shame))
self.assertEqual('Xpto', fame[0]['name'])
self.assertEqual('http://xp.to', fame[0]['url'])
self.assertEqual('http://twitter.com/xpto', fame[0]['source'])
self.assertEqual(['GO', 'SC'], fame[0]['coverage'])
self.assertEqual('Hall of Fame', fame[0]['category'])
self.assertEqual('Lorem ipsum', fame[0]['other'])
<|code_end|>
. Use current file imports:
(from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State)
and context including class names, function names, or small code snippets from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | def test_no_content(self): |
Predict the next line after this snippet: <|code_start|> 'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('api:by_state', 'go'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('application/json', self.resp['Content-Type'])
def test_contents(self):
json_resp = self.resp.json()
fame = json_resp['hall-of-fame']
shame = json_resp['hall-of-shame']
with self.subTest():
self.assertEqual(1, len(fame))
self.assertEqual(0, len(shame))
self.assertEqual('Xpto', fame[0]['name'])
self.assertEqual('http://xp.to', fame[0]['url'])
self.assertEqual('http://twitter.com/xpto', fame[0]['source'])
self.assertEqual(['GO', 'SC'], fame[0]['coverage'])
self.assertEqual('Hall of Fame', fame[0]['category'])
self.assertEqual('Lorem ipsum', fame[0]['other'])
def test_no_content(self):
resp = self.client.get(resolve_url('api:by_state', 'SP'))
json_resp = resp.json()
<|code_end|>
using the current file's imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and any relevant context from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | fame = json_resp['hall-of-fame'] |
Using the snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.REFUSED,
'moderation_reason': Provider.REPEATED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('provider', 1))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_template(self):
self.assertTemplateUsed(self.resp, 'core/provider_detail.html')
def test_html(self):
data = ('Xpto', 'xp.to', 'twitter', 'Hall of Fame', 'Lorem', 'Goiás',
'Status', 'Recusado', 'Provedor repetido')
with self.subTest():
<|code_end|>
, determine the next line of code. You have imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context (class names, function names, or code) available:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | for expected in data: |
Using the snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
<|code_end|>
, determine the next line of code. You have imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context (class names, function names, or code) available:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | 'source': 'http://twitter.com/xpto', |
Continue the code snippet: <|code_start|>
def fame(request):
ctx = {'states': _fame_listed_by_states()}
return _render_md(request, 'fame', ctx)
<|code_end|>
. Use current file imports:
from django.shortcuts import render
from InternetSemLimites.core.models import Provider, State
and context (classes, functions, or code) from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | def shame(request): |
Predict the next line after this snippet: <|code_start|>
class ProviderResource(ModelResource):
class Meta:
model = Provider
class ProviderModelAdmin(ImportExportModelAdmin):
resource_class = ProviderResource
list_display = ('name', 'states', 'status', 'category', 'created_at', 'updated_at')
actions = ['publish', 'unpublish', 'refuse', 'shame', 'fame']
list_filter = ('status', 'moderation_reason', 'category', 'coverage', 'created_at', 'updated_at')
search_fields = ('name',)
def states(self, obj):
states = (state.abbr for state in obj.coverage.all())
return ', '.join(sorted(states))
states.short_description = 'Cobertura'
def publish(self, request, queryset):
count = queryset.update(status=Provider.PUBLISHED)
<|code_end|>
using the current file's imports:
from django.contrib import admin
from import_export.resources import ModelResource
from import_export.admin import ImportExportModelAdmin
from InternetSemLimites.core.models import Provider
and any relevant context from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
. Output only the next line. | messages = (f'{count} provedor publicado.', |
Predict the next line after this snippet: <|code_start|>
def _providers_by_state(abbr):
state = get_object_or_404(State, abbr=abbr.upper())
return state.provider_set
def _to_json(providers_or_fame, shame=None):
if shame:
ctx = {'hall-of-fame': list(providers_or_fame),
'hall-of-shame': list(shame)}
else:
ctx = {'providers': list(providers_or_fame)}
return JsonResponse(ctx)
def _serialize_query(query):
for obj in query:
yield _serialize_object(obj)
def _serialize_object(obj, after_post=False):
all_fields = set(f.__str__().split('.')[-1] for f in Provider._meta.fields)
ignore_fields = set(['id', 'status', 'edited_from'])
fields = tuple(all_fields - ignore_fields)
output = {field: getattr(obj, field) for field in fields}
output['coverage'] = obj.coverage_to_list
output['category'] = obj.category_name
if after_post:
output['moderation_reason'] = obj.get_moderation_reason()
output['status'] = obj.get_status()
<|code_end|>
using the current file's imports:
from copy import deepcopy
from django.conf import settings
from django.contrib.auth.models import User
from django.core import mail
from django.http import (JsonResponse, HttpResponseNotAllowed,
HttpResponseRedirect)
from django.shortcuts import get_object_or_404, resolve_url
from django.template.loader import render_to_string
from django.views.decorators.csrf import csrf_exempt
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.models import Provider, State
and any relevant context from other files:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | return output |
Given snippet: <|code_start|>def home(request):
fame = _serialize_query(Provider.objects.fame())
shame = _serialize_query(Provider.objects.shame())
return _to_json(fame, shame)
def fame(request):
providers = _serialize_query(Provider.objects.fame())
return _to_json(providers)
def shame(request):
providers = _serialize_query(Provider.objects.shame())
return _to_json(providers)
def by_state(request, abbr):
state = get_object_or_404(State, abbr=abbr.upper())
fame = _serialize_query(state.provider_set.fame())
shame = _serialize_query(state.provider_set.shame())
return _to_json(fame, shame)
def fame_by_state(request, abbr):
providers = _serialize_query(_providers_by_state(abbr).fame())
return _to_json(providers)
def shame_by_state(request, abbr):
providers = _serialize_query(_providers_by_state(abbr).shame())
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from copy import deepcopy
from django.conf import settings
from django.contrib.auth.models import User
from django.core import mail
from django.http import (JsonResponse, HttpResponseNotAllowed,
HttpResponseRedirect)
from django.shortcuts import get_object_or_404, resolve_url
from django.template.loader import render_to_string
from django.views.decorators.csrf import csrf_exempt
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.models import Provider, State
and context:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
which might include code, classes, or functions. Output only the next line. | return _to_json(providers) |
Using the snippet: <|code_start|> return HttpResponseRedirect(resolve_url('api:provider', provider.pk))
@csrf_exempt
def provider_edit(request, pk):
provider_original = get_object_or_404(Provider, pk=pk)
provider_edited = deepcopy(provider_original)
provider_edited.id = None
provider_edited.edited_from = provider_original
provider_edited.status = Provider.EDIT
provider_edited_form = ProviderForm(request.POST, instance=provider_edited)
if not provider_edited_form.is_valid():
return JsonResponse({'errors': provider_edited_form.errors}, status=422)
provider_edited_form.save()
_send_mail('+1 InternetSemLimites',
settings.DEFAULT_FROM_EMAIL,
list(_get_admin_emails()),
'core/provider_edit_email.txt',
dict(
provider_original=provider_original,
provider_edited=provider_edited,
))
<|code_end|>
, determine the next line of code. You have imports:
from copy import deepcopy
from django.conf import settings
from django.contrib.auth.models import User
from django.core import mail
from django.http import (JsonResponse, HttpResponseNotAllowed,
HttpResponseRedirect)
from django.shortcuts import get_object_or_404, resolve_url
from django.template.loader import render_to_string
from django.views.decorators.csrf import csrf_exempt
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.models import Provider, State
and context (class names, function names, or code) available:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | return HttpResponseRedirect(resolve_url('api:provider', provider_edited.pk)) |
Predict the next line for this snippet: <|code_start|>
class StateConverter:
regex = '[\w]{2}'
def to_python(self, value):
return value.lower()
def to_url(self, value):
return value
register_converter(StateConverter, 'state')
app_name = 'api'
<|code_end|>
with the help of current file imports:
from django.urls import path, register_converter
from InternetSemLimites.api.views import (
by_state,
fame,
fame_by_state,
home,
provider,
provider_new,
shame,
shame_by_state
)
and context from other files:
# Path: InternetSemLimites/api/views.py
# def by_state(request, abbr):
# state = get_object_or_404(State, abbr=abbr.upper())
# fame = _serialize_query(state.provider_set.fame())
# shame = _serialize_query(state.provider_set.shame())
# return _to_json(fame, shame)
#
# def fame(request):
# providers = _serialize_query(Provider.objects.fame())
# return _to_json(providers)
#
# def fame_by_state(request, abbr):
# providers = _serialize_query(_providers_by_state(abbr).fame())
# return _to_json(providers)
#
# def home(request):
# fame = _serialize_query(Provider.objects.fame())
# shame = _serialize_query(Provider.objects.shame())
# return _to_json(fame, shame)
#
# @csrf_exempt
# def provider(request, pk):
# routes = {
# 'GET': provider_detail,
# 'POST': provider_edit
# }
#
# route = routes.get(request.method)
#
# if route:
# return route(request, pk)
# return HttpResponseNotAllowed([method for method in routes])
#
# @csrf_exempt
# def provider_new(request):
# if request.method != 'POST':
# return HttpResponseNotAllowed(['POST'])
#
# form = ProviderForm(request.POST)
# if not form.is_valid():
# return JsonResponse({'errors': form.errors})
#
# provider = form.save()
# _send_mail('+1 InternetSemLimites',
# settings.DEFAULT_FROM_EMAIL,
# list(_get_admin_emails()),
# 'core/provider_email.txt',
# dict(provider=provider))
#
# return HttpResponseRedirect(resolve_url('api:provider', provider.pk))
#
# def shame(request):
# providers = _serialize_query(Provider.objects.shame())
# return _to_json(providers)
#
# def shame_by_state(request, abbr):
# providers = _serialize_query(_providers_by_state(abbr).shame())
# return _to_json(providers)
, which may contain function names, class names, or code. Output only the next line. | urlpatterns = [ |
Given the code snippet: <|code_start|>
class StateConverter:
regex = '[\w]{2}'
def to_python(self, value):
return value.lower()
def to_url(self, value):
return value
register_converter(StateConverter, 'state')
app_name = 'api'
urlpatterns = [
path('', home, name='home'),
path('fame/', fame, name='fame'),
path('shame/', shame, name='shame'),
path('<state:abbr>/', by_state, name='by_state'),
path('<state:abbr>/fame/', fame_by_state, name='fame_by_state'),
path('<state:abbr>/shame/', shame_by_state, name='shame_by_state'),
path('provider/new/', provider_new, name='new'),
path('provider/<int:pk>/', provider, name='provider'),
<|code_end|>
, generate the next line using the imports in this file:
from django.urls import path, register_converter
from InternetSemLimites.api.views import (
by_state,
fame,
fame_by_state,
home,
provider,
provider_new,
shame,
shame_by_state
)
and context (functions, classes, or occasionally code) from other files:
# Path: InternetSemLimites/api/views.py
# def by_state(request, abbr):
# state = get_object_or_404(State, abbr=abbr.upper())
# fame = _serialize_query(state.provider_set.fame())
# shame = _serialize_query(state.provider_set.shame())
# return _to_json(fame, shame)
#
# def fame(request):
# providers = _serialize_query(Provider.objects.fame())
# return _to_json(providers)
#
# def fame_by_state(request, abbr):
# providers = _serialize_query(_providers_by_state(abbr).fame())
# return _to_json(providers)
#
# def home(request):
# fame = _serialize_query(Provider.objects.fame())
# shame = _serialize_query(Provider.objects.shame())
# return _to_json(fame, shame)
#
# @csrf_exempt
# def provider(request, pk):
# routes = {
# 'GET': provider_detail,
# 'POST': provider_edit
# }
#
# route = routes.get(request.method)
#
# if route:
# return route(request, pk)
# return HttpResponseNotAllowed([method for method in routes])
#
# @csrf_exempt
# def provider_new(request):
# if request.method != 'POST':
# return HttpResponseNotAllowed(['POST'])
#
# form = ProviderForm(request.POST)
# if not form.is_valid():
# return JsonResponse({'errors': form.errors})
#
# provider = form.save()
# _send_mail('+1 InternetSemLimites',
# settings.DEFAULT_FROM_EMAIL,
# list(_get_admin_emails()),
# 'core/provider_email.txt',
# dict(provider=provider))
#
# return HttpResponseRedirect(resolve_url('api:provider', provider.pk))
#
# def shame(request):
# providers = _serialize_query(Provider.objects.shame())
# return _to_json(providers)
#
# def shame_by_state(request, abbr):
# providers = _serialize_query(_providers_by_state(abbr).shame())
# return _to_json(providers)
. Output only the next line. | ] |
Next line prediction: <|code_start|>
class StateConverter:
regex = '[\w]{2}'
def to_python(self, value):
return value.lower()
def to_url(self, value):
return value
<|code_end|>
. Use current file imports:
(from django.urls import path, register_converter
from InternetSemLimites.api.views import (
by_state,
fame,
fame_by_state,
home,
provider,
provider_new,
shame,
shame_by_state
))
and context including class names, function names, or small code snippets from other files:
# Path: InternetSemLimites/api/views.py
# def by_state(request, abbr):
# state = get_object_or_404(State, abbr=abbr.upper())
# fame = _serialize_query(state.provider_set.fame())
# shame = _serialize_query(state.provider_set.shame())
# return _to_json(fame, shame)
#
# def fame(request):
# providers = _serialize_query(Provider.objects.fame())
# return _to_json(providers)
#
# def fame_by_state(request, abbr):
# providers = _serialize_query(_providers_by_state(abbr).fame())
# return _to_json(providers)
#
# def home(request):
# fame = _serialize_query(Provider.objects.fame())
# shame = _serialize_query(Provider.objects.shame())
# return _to_json(fame, shame)
#
# @csrf_exempt
# def provider(request, pk):
# routes = {
# 'GET': provider_detail,
# 'POST': provider_edit
# }
#
# route = routes.get(request.method)
#
# if route:
# return route(request, pk)
# return HttpResponseNotAllowed([method for method in routes])
#
# @csrf_exempt
# def provider_new(request):
# if request.method != 'POST':
# return HttpResponseNotAllowed(['POST'])
#
# form = ProviderForm(request.POST)
# if not form.is_valid():
# return JsonResponse({'errors': form.errors})
#
# provider = form.save()
# _send_mail('+1 InternetSemLimites',
# settings.DEFAULT_FROM_EMAIL,
# list(_get_admin_emails()),
# 'core/provider_email.txt',
# dict(provider=provider))
#
# return HttpResponseRedirect(resolve_url('api:provider', provider.pk))
#
# def shame(request):
# providers = _serialize_query(Provider.objects.shame())
# return _to_json(providers)
#
# def shame_by_state(request, abbr):
# providers = _serialize_query(_providers_by_state(abbr).shame())
# return _to_json(providers)
. Output only the next line. | register_converter(StateConverter, 'state') |
Here is a snippet: <|code_start|>
class StateConverter:
regex = '[\w]{2}'
def to_python(self, value):
return value.lower()
def to_url(self, value):
return value
register_converter(StateConverter, 'state')
app_name = 'api'
urlpatterns = [
path('', home, name='home'),
path('fame/', fame, name='fame'),
path('shame/', shame, name='shame'),
path('<state:abbr>/', by_state, name='by_state'),
path('<state:abbr>/fame/', fame_by_state, name='fame_by_state'),
path('<state:abbr>/shame/', shame_by_state, name='shame_by_state'),
path('provider/new/', provider_new, name='new'),
path('provider/<int:pk>/', provider, name='provider'),
<|code_end|>
. Write the next line using the current file imports:
from django.urls import path, register_converter
from InternetSemLimites.api.views import (
by_state,
fame,
fame_by_state,
home,
provider,
provider_new,
shame,
shame_by_state
)
and context from other files:
# Path: InternetSemLimites/api/views.py
# def by_state(request, abbr):
# state = get_object_or_404(State, abbr=abbr.upper())
# fame = _serialize_query(state.provider_set.fame())
# shame = _serialize_query(state.provider_set.shame())
# return _to_json(fame, shame)
#
# def fame(request):
# providers = _serialize_query(Provider.objects.fame())
# return _to_json(providers)
#
# def fame_by_state(request, abbr):
# providers = _serialize_query(_providers_by_state(abbr).fame())
# return _to_json(providers)
#
# def home(request):
# fame = _serialize_query(Provider.objects.fame())
# shame = _serialize_query(Provider.objects.shame())
# return _to_json(fame, shame)
#
# @csrf_exempt
# def provider(request, pk):
# routes = {
# 'GET': provider_detail,
# 'POST': provider_edit
# }
#
# route = routes.get(request.method)
#
# if route:
# return route(request, pk)
# return HttpResponseNotAllowed([method for method in routes])
#
# @csrf_exempt
# def provider_new(request):
# if request.method != 'POST':
# return HttpResponseNotAllowed(['POST'])
#
# form = ProviderForm(request.POST)
# if not form.is_valid():
# return JsonResponse({'errors': form.errors})
#
# provider = form.save()
# _send_mail('+1 InternetSemLimites',
# settings.DEFAULT_FROM_EMAIL,
# list(_get_admin_emails()),
# 'core/provider_email.txt',
# dict(provider=provider))
#
# return HttpResponseRedirect(resolve_url('api:provider', provider.pk))
#
# def shame(request):
# providers = _serialize_query(Provider.objects.shame())
# return _to_json(providers)
#
# def shame_by_state(request, abbr):
# providers = _serialize_query(_providers_by_state(abbr).shame())
# return _to_json(providers)
, which may include functions, classes, or code. Output only the next line. | ] |
Based on the snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('api:home'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('application/json', self.resp['Content-Type'])
def test_contents(self):
json_resp = self.resp.json()
fame = json_resp['hall-of-fame']
shame = json_resp['hall-of-shame']
with self.subTest():
self.assertEqual(1, len(fame))
self.assertEqual(0, len(shame))
<|code_end|>
, predict the immediate next line with the help of imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context (classes, functions, sometimes code) from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | self.assertEqual('Xpto', fame[0]['name']) |
Continue the code snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('api:home'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('application/json', self.resp['Content-Type'])
def test_contents(self):
json_resp = self.resp.json()
fame = json_resp['hall-of-fame']
shame = json_resp['hall-of-shame']
with self.subTest():
self.assertEqual(1, len(fame))
<|code_end|>
. Use current file imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context (classes, functions, or code) from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | self.assertEqual(0, len(shame)) |
Continue the code snippet: <|code_start|>
provider_new_args = {'model': Provider,
'form_class': ProviderForm,
'email_subject': '+1 InternetSemLimites'}
provider_new = EmailAdminCreateView.as_view(**provider_new_args)
provider_details = DetailView.as_view(model=Provider)
def redirect_to_api(request):
<|code_end|>
. Use current file imports:
from django.http import HttpResponseRedirect
from django.shortcuts import resolve_url
from django.views.generic import DetailView
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.mixins import EmailAdminCreateView
from InternetSemLimites.core.models import Provider
and context (classes, functions, or code) from other files:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/mixins.py
# class EmailAdminCreateView(EmailAdminCreateMixin, CreateView):
#
# def form_valid(self, form):
# response = super().form_valid(form)
# self.send_mail()
# return response
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
. Output only the next line. | return HttpResponseRedirect(resolve_url('api:home')) |
Based on the snippet: <|code_start|>
provider_new_args = {'model': Provider,
'form_class': ProviderForm,
'email_subject': '+1 InternetSemLimites'}
provider_new = EmailAdminCreateView.as_view(**provider_new_args)
provider_details = DetailView.as_view(model=Provider)
def redirect_to_api(request):
<|code_end|>
, predict the immediate next line with the help of imports:
from django.http import HttpResponseRedirect
from django.shortcuts import resolve_url
from django.views.generic import DetailView
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.mixins import EmailAdminCreateView
from InternetSemLimites.core.models import Provider
and context (classes, functions, sometimes code) from other files:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/mixins.py
# class EmailAdminCreateView(EmailAdminCreateMixin, CreateView):
#
# def form_valid(self, form):
# response = super().form_valid(form)
# self.send_mail()
# return response
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
. Output only the next line. | return HttpResponseRedirect(resolve_url('api:home')) |
Next line prediction: <|code_start|>
provider_new_args = {'model': Provider,
'form_class': ProviderForm,
'email_subject': '+1 InternetSemLimites'}
provider_new = EmailAdminCreateView.as_view(**provider_new_args)
provider_details = DetailView.as_view(model=Provider)
def redirect_to_api(request):
<|code_end|>
. Use current file imports:
(from django.http import HttpResponseRedirect
from django.shortcuts import resolve_url
from django.views.generic import DetailView
from InternetSemLimites.core.forms import ProviderForm
from InternetSemLimites.core.mixins import EmailAdminCreateView
from InternetSemLimites.core.models import Provider)
and context including class names, function names, or small code snippets from other files:
# Path: InternetSemLimites/core/forms.py
# class ProviderForm(ModelForm):
#
# class Meta:
# model = Provider
# fields = ['category', 'name', 'url', 'source', 'coverage', 'other']
# widgets = {'coverage': CheckboxSelectMultiple()}
#
# Path: InternetSemLimites/core/mixins.py
# class EmailAdminCreateView(EmailAdminCreateMixin, CreateView):
#
# def form_valid(self, form):
# response = super().form_valid(form)
# self.send_mail()
# return response
#
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
. Output only the next line. | return HttpResponseRedirect(resolve_url('api:home')) |
Given the following code snippet before the placeholder: <|code_start|>
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('api:fame_by_state', 'GO'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('application/json', self.resp['Content-Type'])
def test_contents(self):
json_resp = self.resp.json()
shame = json_resp['providers']
with self.subTest():
self.assertEqual(1, len(shame))
self.assertEqual('Xpto', shame[0]['name'])
self.assertEqual('http://xp.to', shame[0]['url'])
self.assertEqual('http://twitter.com/xpto', shame[0]['source'])
self.assertEqual(['GO', 'SC'], shame[0]['coverage'])
self.assertEqual('Hall of Fame', shame[0]['category'])
<|code_end|>
, predict the next line using imports from the current file:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context including class names, function names, and sometimes code from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | self.assertEqual('Lorem ipsum', shame[0]['other']) |
Using the snippet: <|code_start|>
class TestGet(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum',
'status': Provider.PUBLISHED}
provider = Provider.objects.create(**props)
provider.coverage.set([sc, go])
self.resp = self.client.get(resolve_url('api:fame_by_state', 'GO'))
def test_get(self):
self.assertEqual(200, self.resp.status_code)
def test_type(self):
self.assertEqual('application/json', self.resp['Content-Type'])
def test_contents(self):
json_resp = self.resp.json()
shame = json_resp['providers']
with self.subTest():
<|code_end|>
, determine the next line of code. You have imports:
from django.shortcuts import resolve_url
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context (class names, function names, or code) available:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
. Output only the next line. | self.assertEqual(1, len(shame)) |
Predict the next line for this snippet: <|code_start|>
class TestProviderModel(TestCase):
def setUp(self):
sc, *_ = State.objects.get_or_create(abbr='SC', name='Santa Catarina')
go, *_ = State.objects.get_or_create(abbr='GO', name='Goiás')
props = {'name': 'Xpto',
'url': 'http://xp.to',
'source': 'http://twitter.com/xpto',
'category': Provider.FAME,
'other': 'Lorem ipsum'}
self.provider = Provider.objects.create(**props)
self.provider.coverage.set([sc, go])
def test_str(self):
self.assertEqual('Xpto', str(self.provider))
<|code_end|>
with the help of current file imports:
from django.test import TestCase
from InternetSemLimites.core.models import Provider, State
and context from other files:
# Path: InternetSemLimites/core/models.py
# class Provider(models.Model):
#
# FAME = 'F'
# SHAME = 'S'
# CATEGORIES = ((FAME, 'Hall of Fame (não utilizará limites/fraquia)'),
# (SHAME, 'Hall of Shame (utilizará limites/franquia)'))
# CATEGORIES_DICT = dict(CATEGORIES)
#
# NEW = 'N'
# DISCUSSION = 'D'
# PUBLISHED = 'P'
# REFUSED = 'R'
# EDIT = 'E'
# OUTDATED = 'O'
# STATUS = ((NEW, 'Aguardando moderação'),
# (DISCUSSION, 'Em discussão'),
# (PUBLISHED, 'Publicado'),
# (REFUSED, 'Recusado'),
# (EDIT, 'Edição aguardando moderação'),
# (OUTDATED, 'Substituído por versão atualizada'))
#
# BLANK = ''
# REPEATED = 'R'
# NOT_FOUND = 'N'
# IMPRECISE = 'I'
# NOT_ACCESSIBLE = 'A'
# PRIVATE = 'P'
# OTHER = 'O'
# REASONS = ((BLANK, 'Não se aplica'),
# (REPEATED, 'Provedor repetido'),
# (NOT_FOUND, 'Fonte não encontrada (404)'),
# (IMPRECISE, 'Fonte com informações imprecisas ou erradas'),
# (NOT_ACCESSIBLE, 'Fonte não acessível (ex.: requer login)'),
# (PRIVATE, 'Fonte é comunicação privada (ex.: chat ou suporte)'),
# (OTHER, 'Outros'))
#
# category = models.CharField('Categoria', max_length=1, choices=CATEGORIES)
# name = models.CharField('Nome do provedor', max_length=128)
# url = models.URLField('URL do provedor')
# source = models.URLField('URL da fonte da informação')
# coverage = models.ManyToManyField(State, verbose_name='Cobertura')
# other = models.CharField('Observações', max_length=140, blank=True)
#
# edited_from = models.ForeignKey('self', null=True, blank=True, on_delete=models.CASCADE)
# status = models.CharField('Status', max_length=1, choices=STATUS, default=NEW)
# moderation_reason = models.CharField('Motivo', max_length=1, choices=REASONS, blank=True, default=BLANK)
# moderation_comments = models.TextField('Comentários da moderação', blank=True)
#
# created_at = models.DateTimeField('Criado em', auto_now_add=True)
# updated_at = models.DateTimeField('Editado em', auto_now=True)
#
# objects = ProviderManager()
#
# def __str__(self):
# return self.name
#
# def get_absolute_url(self):
# return resolve_url('provider', self.pk)
#
# def get_moderation_reason(self):
# return dict(self.REASONS).get(self.moderation_reason)
#
# def get_status(self):
# return dict(self.STATUS).get(self.status)
#
# @property
# def coverage_to_list(self):
# return [state.abbr for state in self.coverage.all()]
#
# @property
# def category_name(self):
# category = self.CATEGORIES_DICT.get(self.category)
# return re.sub(r' \([\w\sáã\/]*\)$', '', category)
#
# class Meta:
# verbose_name = 'provedor'
# verbose_name_plural = 'provedores'
# ordering = ['name']
#
# class State(models.Model):
# name = models.CharField('Nome', max_length=128)
# abbr = models.CharField('Sigla', max_length=2)
#
# def __str__(self):
# return f'{self.name} ({self.abbr})'
#
# class Meta:
# ordering = ['name']
, which may contain function names, class names, or code. Output only the next line. | def test_create(self): |
Given snippet: <|code_start|>#
# Copyright (c) 2016 The Ontario Institute for Cancer Research. All rights reserved.
#
# This program and the accompanying materials are made available under the terms of the GNU Public License v3.0.
# You should have received a copy of the GNU General Public License along with
# this program. If not, see <http://www.gnu.org/licenses/>.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
# SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
setup(name='icgcget',
version=__version__,
description='Universal download client for ICGC data residing in various environments',
url="https://github.com/icgc/icgc-get",
packages=find_packages(exclude=['tests']),
install_requires=['PyYaml', 'logging', 'click', 'requests[security]', 'psutil', 'tabulate', 'subprocess32',
'certifi'],
setup_requires=['pytest-runner'],
tests_require=['pytest'],
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from setuptools import setup, find_packages
from icgcget.version import __version__
and context:
# Path: icgcget/version.py
which might include code, classes, or functions. Output only the next line. | entry_points={ |
Next line prediction: <|code_start|> else:
assert filename is None # Unable to download file as expected
def start_server():
thread = stub_thread.stubThread(1, "TestThread")
thread.start()
def stop_server():
for thread in threading.enumerate():
thread.join()
def download_test(file_id, mode, repo, file_names, sizes, data):
runner = CliRunner()
start_server()
args = [mode]
args.extend(file_id)
args.extend(['-r', repo, '--output', data])
if mode == 'download':
args.append('-y')
runner.env = dict(os.environ, ICGCGET_API_URL="http://127.0.0.1:8000/")
rc = runner.invoke(icgcget.cli, args)
if rc.exit_code != 0:
assert rc.output == 0 # An error occurred during the download attempt
if mode == 'download':
for i in range(len(file_names)):
file_info = get_info(data, file_names[i])
result = file_test(file_info, sizes[i])
<|code_end|>
. Use current file imports:
(import os
import tempfile
import threading
import pytest
import icgcget
from click.testing import CliRunner
from tests.fixtures import stub_thread)
and context including class names, function names, or small code snippets from other files:
# Path: tests/fixtures/stub_thread.py
# class stubThread(threading.Thread):
# def __init__(self, threadID, name):
# def run(self):
. Output only the next line. | if not result: |
Given the code snippet: <|code_start|>#
# Copyright (c) 2016 The Ontario Institute for Cancer Research. All rights reserved.
#
# This program and the accompanying materials are made available under the terms of the GNU Public License v3.0.
# You should have received a copy of the GNU General Public License along with
# this program. If not, see <http://www.gnu.org/licenses/>.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
# SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
exitFlag = 0
class stubThread(threading.Thread):
def __init__(self, threadID, name):
threading.Thread.__init__(self)
self.threadID = threadID
self.name = name
self.daemon = True
<|code_end|>
, generate the next line using the imports in this file:
import threading
from tests.fixtures import stub_server
and context (functions, classes, or occasionally code) from other files:
# Path: tests/fixtures/stub_server.py
# class ServerHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
# def do_GET(self):
# def run():
# def parse_id(request):
. Output only the next line. | def run(self): |
Continue the code snippet: <|code_start|>#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright (c) 2016 The Ontario Institute for Cancer Research. All rights reserved.
#
# This program and the accompanying materials are made available under the terms of the GNU Public License v3.0.
# You should have received a copy of the GNU General Public License along with
# this program. If not, see <http://www.gnu.org/licenses/>.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
# SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
# TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
def api_error_catch(self, func, *args):
try:
return func(*args)
except errors.ApiError as ex:
self.logger.error(ex.message)
raise click.Abort
<|code_end|>
. Use current file imports:
import re
import json
import os
import logging
import psutil
import click
import yaml
import signal
from icgcget.clients import errors
from icgcget.clients.utils import normalize_keys, flatten_dict
from icgcget.params import ICGC_REPOS
and context (classes, functions, or code) from other files:
# Path: icgcget/clients/errors.py
# class SubprocessError(Exception):
# class ApiError(Exception):
# def __init__(self, code, message):
# def __init__(self, request_string, message, code=None):
#
# Path: icgcget/clients/utils.py
# def normalize_keys(obj):
# """
# Recursive function that filters keys from python conventions to yaml conventions
# :param obj:
# :return:
# """
# if isinstance(obj, dict):
# return obj
# else:
# return {k.replace('.', '_'): normalize_keys(v) for k, v in obj.items()}
#
# def flatten_dict(dictionary, parent_key='', sep='_'):
# """
# Function that breaks down nested dictionaries into a single level dictionary. Calls itself recursively
# :param dictionary:
# :param parent_key:
# :param sep: separator for new keys that are combinations of the nested path.
# :return:
# """
# items = []
# for key, value in dictionary.items():
# new_key = parent_key + sep + key if parent_key else key
# new_value = None if value == '' else value
# if isinstance(new_value, collections.MutableMapping): # if value is a dict, flatten it.
# items.extend(flatten_dict(new_value, new_key, sep=sep).items())
# else:
# items.append((new_key, new_value))
# return dict(items)
#
# Path: icgcget/params.py
# ICGC_REPOS = ['collaboratory', 'aws-virginia'] #TODO: separate ICGC repos out from REPOS dict, and use the keys
. Output only the next line. | def check_access(self, access, name, docker=False, path='Default', password='Default', secret_key='Default', udt=True): |
Given the code snippet: <|code_start|>
def map(dataset, text, id=None):
logging.info("OpenLSH > map() called.")
start = datetime.datetime.utcnow()
hashes = calculate_max_hashes(dataset.rows, dataset.bands)
if len(dataset.random_seeds) < hashes:
dataset.random_seeds = get_random_bits(hashes)
dataset.put()
sh_type = dataset.shingle_type
modulo = dataset.minhash_modulo
seeds = list(dataset.random_seeds)
minhashes = calc_minhashes(text, sh_type, hashes, seeds, modulo)
buckets = []
buckets_per_band = dataset.buckets_per_band
for band in xrange(dataset.bands):
<|code_end|>
, generate the next line using the imports in this file:
import operator, struct, math, sys, logging, datetime
from lsh.utils.similarity import compute_positive_hash
from lsh.shingles.shingles import _get_list_of_shingles
from repositories.gae.dataset import get_random_bits, calculate_max_hashes
and context (functions, classes, or occasionally code) from other files:
# Path: lsh/utils/similarity.py
# def compute_positive_hash(value):
# return hash(value) % ((sys.maxsize + 1) * 2)
#
# Path: lsh/shingles/shingles.py
# def _get_list_of_shingles(doc, size=DEFAULT_SHINGLE_SIZE):
# """
# Creates a list of shingles (strings)
# :param doc: doc to create shingles from
# :type doc: string
# :param size: size of shingle
# :type size: int
# :return: list of shingles (strings), will return an empty list if doc is None or empty
# """
#
# if doc:
# return [doc[i:i + size] for i in range(len(doc) - size + 1)]
# else:
# return []
#
# Path: repositories/gae/dataset.py
# def get_random_bits(max_hashes):
# return [random.getrandbits(get_max_bits()) for _ in xrange(max_hashes)]
#
# def calculate_max_hashes(rows, bands):
# return rows * bands
. Output only the next line. | minhashes_in_band = [minhashes[band*dataset.rows + row] for row in xrange(dataset.rows)] |
Next line prediction: <|code_start|> hashes = calculate_max_hashes(dataset.rows, dataset.bands)
if len(dataset.random_seeds) < hashes:
dataset.random_seeds = get_random_bits(hashes)
dataset.put()
sh_type = dataset.shingle_type
modulo = dataset.minhash_modulo
seeds = list(dataset.random_seeds)
minhashes = calc_minhashes(text, sh_type, hashes, seeds, modulo)
buckets = []
buckets_per_band = dataset.buckets_per_band
for band in xrange(dataset.bands):
minhashes_in_band = [minhashes[band*dataset.rows + row] for row in xrange(dataset.rows)]
if len(set(minhashes_in_band)) <= 1:
buckets.append( (band * buckets_per_band) + hash(minhashes_in_band[0]) % buckets_per_band )
end = datetime.datetime.utcnow()
if 0 == (start.second % 20):
logging.info('id %s, length %d, time %d', id, len(text), int((end-start).total_seconds()))
for bkt in buckets:
yield (bkt, '/view/%s/%s' % (dataset.filename, id))
def reduce(key, values):
logging.info("OpenLSH > reduce() called.")
<|code_end|>
. Use current file imports:
(import operator, struct, math, sys, logging, datetime
from lsh.utils.similarity import compute_positive_hash
from lsh.shingles.shingles import _get_list_of_shingles
from repositories.gae.dataset import get_random_bits, calculate_max_hashes)
and context including class names, function names, or small code snippets from other files:
# Path: lsh/utils/similarity.py
# def compute_positive_hash(value):
# return hash(value) % ((sys.maxsize + 1) * 2)
#
# Path: lsh/shingles/shingles.py
# def _get_list_of_shingles(doc, size=DEFAULT_SHINGLE_SIZE):
# """
# Creates a list of shingles (strings)
# :param doc: doc to create shingles from
# :type doc: string
# :param size: size of shingle
# :type size: int
# :return: list of shingles (strings), will return an empty list if doc is None or empty
# """
#
# if doc:
# return [doc[i:i + size] for i in range(len(doc) - size + 1)]
# else:
# return []
#
# Path: repositories/gae/dataset.py
# def get_random_bits(max_hashes):
# return [random.getrandbits(get_max_bits()) for _ in xrange(max_hashes)]
#
# def calculate_max_hashes(rows, bands):
# return rows * bands
. Output only the next line. | yield (key, values) |
Predict the next line for this snippet: <|code_start|> buckets.append( (band * buckets_per_band) + hash(minhashes_in_band[0]) % buckets_per_band )
end = datetime.datetime.utcnow()
if 0 == (start.second % 20):
logging.info('id %s, length %d, time %d', id, len(text), int((end-start).total_seconds()))
for bkt in buckets:
yield (bkt, '/view/%s/%s' % (dataset.filename, id))
def reduce(key, values):
logging.info("OpenLSH > reduce() called.")
yield (key, values)
#TODO Create single methods for the lsh code below and one driver function to call
#LSH functions for calculating minhash signatures, creating list of shingles
def calc_minhashes(parsed_text, sh_type, hashes, seeds, modulo):
def minhashes_for_shingles(shingles, sh_type, hashes, seeds, modulo):
def calc_onehash(sh_type, shingle, seed, modulo):
def c4_hash(shingle):
h = struct.unpack('<i',shingle)[0]
return h % ((sys.maxsize + 1) * 2)
if sh_type == 'c4':
return operator.xor(c4_hash(shingle), long(seed)) % modulo
else:
return operator.xor(compute_positive_hash(shingle), long(seed)) % modulo
minhashes = [sys.maxsize for _ in xrange(hashes)]
for shingle in shingles:
<|code_end|>
with the help of current file imports:
import operator, struct, math, sys, logging, datetime
from lsh.utils.similarity import compute_positive_hash
from lsh.shingles.shingles import _get_list_of_shingles
from repositories.gae.dataset import get_random_bits, calculate_max_hashes
and context from other files:
# Path: lsh/utils/similarity.py
# def compute_positive_hash(value):
# return hash(value) % ((sys.maxsize + 1) * 2)
#
# Path: lsh/shingles/shingles.py
# def _get_list_of_shingles(doc, size=DEFAULT_SHINGLE_SIZE):
# """
# Creates a list of shingles (strings)
# :param doc: doc to create shingles from
# :type doc: string
# :param size: size of shingle
# :type size: int
# :return: list of shingles (strings), will return an empty list if doc is None or empty
# """
#
# if doc:
# return [doc[i:i + size] for i in range(len(doc) - size + 1)]
# else:
# return []
#
# Path: repositories/gae/dataset.py
# def get_random_bits(max_hashes):
# return [random.getrandbits(get_max_bits()) for _ in xrange(max_hashes)]
#
# def calculate_max_hashes(rows, bands):
# return rows * bands
, which may contain function names, class names, or code. Output only the next line. | for hno in xrange(hashes): |
Given snippet: <|code_start|>
def map(dataset, text, id=None):
logging.info("OpenLSH > map() called.")
start = datetime.datetime.utcnow()
hashes = calculate_max_hashes(dataset.rows, dataset.bands)
if len(dataset.random_seeds) < hashes:
dataset.random_seeds = get_random_bits(hashes)
dataset.put()
sh_type = dataset.shingle_type
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import operator, struct, math, sys, logging, datetime
from lsh.utils.similarity import compute_positive_hash
from lsh.shingles.shingles import _get_list_of_shingles
from repositories.gae.dataset import get_random_bits, calculate_max_hashes
and context:
# Path: lsh/utils/similarity.py
# def compute_positive_hash(value):
# return hash(value) % ((sys.maxsize + 1) * 2)
#
# Path: lsh/shingles/shingles.py
# def _get_list_of_shingles(doc, size=DEFAULT_SHINGLE_SIZE):
# """
# Creates a list of shingles (strings)
# :param doc: doc to create shingles from
# :type doc: string
# :param size: size of shingle
# :type size: int
# :return: list of shingles (strings), will return an empty list if doc is None or empty
# """
#
# if doc:
# return [doc[i:i + size] for i in range(len(doc) - size + 1)]
# else:
# return []
#
# Path: repositories/gae/dataset.py
# def get_random_bits(max_hashes):
# return [random.getrandbits(get_max_bits()) for _ in xrange(max_hashes)]
#
# def calculate_max_hashes(rows, bands):
# return rows * bands
which might include code, classes, or functions. Output only the next line. | modulo = dataset.minhash_modulo |
Continue the code snippet: <|code_start|>dir_path = os.path.dirname([p for p in sys.path if p][0])
sys.path.insert(0, 'libs')
LOG_FILENAME = dir_path+'/CassDriver.log'
logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)
shingle_cache = Cache(max_size = 1)
<|code_end|>
. Use current file imports:
import sys, os, re, time, math, random, struct, zipfile, operator, csv, hashlib, uuid, pdb
import logging
from collections import defaultdict
from lsh.shingles.shingles import _get_list_of_shingles
from lsh.utils.similarity import compute_positive_hash
from bs4 import BeautifulSoup
from cassandra.cluster import Cluster
from cassandra.query import SimpleStatement, dict_factory
from cassandra import ConsistencyLevel, InvalidRequest
from utils.procache import Cache
from utils.levenshtein import levenshtein
and context (classes, functions, or code) from other files:
# Path: lsh/shingles/shingles.py
# def _get_list_of_shingles(doc, size=DEFAULT_SHINGLE_SIZE):
# """
# Creates a list of shingles (strings)
# :param doc: doc to create shingles from
# :type doc: string
# :param size: size of shingle
# :type size: int
# :return: list of shingles (strings), will return an empty list if doc is None or empty
# """
#
# if doc:
# return [doc[i:i + size] for i in range(len(doc) - size + 1)]
# else:
# return []
#
# Path: lsh/utils/similarity.py
# def compute_positive_hash(value):
# return hash(value) % ((sys.maxsize + 1) * 2)
#
# Path: utils/procache.py
# class Cache():
# """
# In process memory cache. Not thread safe.
# Usage:
#
# cache = Cache(max_size=5)
# cache.set("python", "perfect", timeout=10)
# cache.get("python")
# >>> perfect
# time.sleep(11)
# cache.get("python")
# >>> None
# cache.get("python", "perfect anyway")
# >>> perfect anyway
# cache.clear()
# """
# def __init__(self, max_size=1000, timeout=None):
# self._store = OrderedDict()
# self._max_size = max_size
# self._timeout = timeout
#
# def set(self, key, value, timeout=None):
# self._check_limit()
# if not timeout:
# timeout = self._timeout
# if timeout:
# timeout = time.time() + timeout
# self._store[key] = (value, timeout)
#
# def get(self, key, default=None):
# data = self._store.get(key)
# if not data:
# return default
# value, expire = data
# if expire and time.time() > expire:
# del self._store[key]
# return default
# return value
#
# def _check_limit(self):
# """
# check if current cache size exceeds maximum cache
# size and pop the oldest item in this case
# """
# if len(self._store) >= self._max_size:
# self._store.popitem(last=False)
#
# def clear(self):
# """
# clear all cache
# """
# self._store = OrderedDict()
#
# def keys(self):
# return self._store.keys()
#
# Path: utils/levenshtein.py
# def levenshtein(a,b):
# "Calculates the Levenshtein distance between a and b."
# n, m = len(a), len(b)
# if n > m:
# # Make sure n <= m, to use O(min(n,m)) space
# a,b = b,a
# n,m = m,n
#
# current = range(n+1)
# for i in range(1,m+1):
# previous, current = current, [i]+[0]*n
# for j in range(1,n+1):
# add, delete = previous[j]+1, current[j-1]+1
# change = previous[j-1]
# if a[j-1] != b[i-1]:
# change = change + 1
# current[j] = min(add, delete, change)
#
# return current[n]
. Output only the next line. | max_bits = 32 |
Next line prediction: <|code_start|>dir_path = os.path.dirname([p for p in sys.path if p][0])
sys.path.insert(0, 'libs')
LOG_FILENAME = dir_path+'/CassDriver.log'
logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG)
shingle_cache = Cache(max_size = 1)
max_bits = 32
max_mask = 2**max_bits - 1
text_file_pattern = re.compile('^{"id":"([^"]*):html","text":"(.*)}', flags=re.DOTALL)
<|code_end|>
. Use current file imports:
(import sys, os, re, time, math, random, struct, zipfile, operator, csv, hashlib, uuid, pdb
import logging
from collections import defaultdict
from lsh.shingles.shingles import _get_list_of_shingles
from lsh.utils.similarity import compute_positive_hash
from bs4 import BeautifulSoup
from cassandra.cluster import Cluster
from cassandra.query import SimpleStatement, dict_factory
from cassandra import ConsistencyLevel, InvalidRequest
from utils.procache import Cache
from utils.levenshtein import levenshtein)
and context including class names, function names, or small code snippets from other files:
# Path: lsh/shingles/shingles.py
# def _get_list_of_shingles(doc, size=DEFAULT_SHINGLE_SIZE):
# """
# Creates a list of shingles (strings)
# :param doc: doc to create shingles from
# :type doc: string
# :param size: size of shingle
# :type size: int
# :return: list of shingles (strings), will return an empty list if doc is None or empty
# """
#
# if doc:
# return [doc[i:i + size] for i in range(len(doc) - size + 1)]
# else:
# return []
#
# Path: lsh/utils/similarity.py
# def compute_positive_hash(value):
# return hash(value) % ((sys.maxsize + 1) * 2)
#
# Path: utils/procache.py
# class Cache():
# """
# In process memory cache. Not thread safe.
# Usage:
#
# cache = Cache(max_size=5)
# cache.set("python", "perfect", timeout=10)
# cache.get("python")
# >>> perfect
# time.sleep(11)
# cache.get("python")
# >>> None
# cache.get("python", "perfect anyway")
# >>> perfect anyway
# cache.clear()
# """
# def __init__(self, max_size=1000, timeout=None):
# self._store = OrderedDict()
# self._max_size = max_size
# self._timeout = timeout
#
# def set(self, key, value, timeout=None):
# self._check_limit()
# if not timeout:
# timeout = self._timeout
# if timeout:
# timeout = time.time() + timeout
# self._store[key] = (value, timeout)
#
# def get(self, key, default=None):
# data = self._store.get(key)
# if not data:
# return default
# value, expire = data
# if expire and time.time() > expire:
# del self._store[key]
# return default
# return value
#
# def _check_limit(self):
# """
# check if current cache size exceeds maximum cache
# size and pop the oldest item in this case
# """
# if len(self._store) >= self._max_size:
# self._store.popitem(last=False)
#
# def clear(self):
# """
# clear all cache
# """
# self._store = OrderedDict()
#
# def keys(self):
# return self._store.keys()
#
# Path: utils/levenshtein.py
# def levenshtein(a,b):
# "Calculates the Levenshtein distance between a and b."
# n, m = len(a), len(b)
# if n > m:
# # Make sure n <= m, to use O(min(n,m)) space
# a,b = b,a
# n,m = m,n
#
# current = range(n+1)
# for i in range(1,m+1):
# previous, current = current, [i]+[0]*n
# for j in range(1,n+1):
# add, delete = previous[j]+1, current[j-1]+1
# change = previous[j-1]
# if a[j-1] != b[i-1]:
# change = change + 1
# current[j] = min(add, delete, change)
#
# return current[n]
. Output only the next line. | symbols = re.compile('\W+') |
Continue the code snippet: <|code_start|>dir_path = os.path.dirname([p for p in sys.path if p][0])
sys.path.insert(0, 'libs')
LOG_FILENAME = dir_path+'/CassDriver.log'
<|code_end|>
. Use current file imports:
import sys, os, re, time, math, random, struct, zipfile, operator, csv, hashlib, uuid, pdb
import logging
from collections import defaultdict
from lsh.shingles.shingles import _get_list_of_shingles
from lsh.utils.similarity import compute_positive_hash
from bs4 import BeautifulSoup
from cassandra.cluster import Cluster
from cassandra.query import SimpleStatement, dict_factory
from cassandra import ConsistencyLevel, InvalidRequest
from utils.procache import Cache
from utils.levenshtein import levenshtein
and context (classes, functions, or code) from other files:
# Path: lsh/shingles/shingles.py
# def _get_list_of_shingles(doc, size=DEFAULT_SHINGLE_SIZE):
# """
# Creates a list of shingles (strings)
# :param doc: doc to create shingles from
# :type doc: string
# :param size: size of shingle
# :type size: int
# :return: list of shingles (strings), will return an empty list if doc is None or empty
# """
#
# if doc:
# return [doc[i:i + size] for i in range(len(doc) - size + 1)]
# else:
# return []
#
# Path: lsh/utils/similarity.py
# def compute_positive_hash(value):
# return hash(value) % ((sys.maxsize + 1) * 2)
#
# Path: utils/procache.py
# class Cache():
# """
# In process memory cache. Not thread safe.
# Usage:
#
# cache = Cache(max_size=5)
# cache.set("python", "perfect", timeout=10)
# cache.get("python")
# >>> perfect
# time.sleep(11)
# cache.get("python")
# >>> None
# cache.get("python", "perfect anyway")
# >>> perfect anyway
# cache.clear()
# """
# def __init__(self, max_size=1000, timeout=None):
# self._store = OrderedDict()
# self._max_size = max_size
# self._timeout = timeout
#
# def set(self, key, value, timeout=None):
# self._check_limit()
# if not timeout:
# timeout = self._timeout
# if timeout:
# timeout = time.time() + timeout
# self._store[key] = (value, timeout)
#
# def get(self, key, default=None):
# data = self._store.get(key)
# if not data:
# return default
# value, expire = data
# if expire and time.time() > expire:
# del self._store[key]
# return default
# return value
#
# def _check_limit(self):
# """
# check if current cache size exceeds maximum cache
# size and pop the oldest item in this case
# """
# if len(self._store) >= self._max_size:
# self._store.popitem(last=False)
#
# def clear(self):
# """
# clear all cache
# """
# self._store = OrderedDict()
#
# def keys(self):
# return self._store.keys()
#
# Path: utils/levenshtein.py
# def levenshtein(a,b):
# "Calculates the Levenshtein distance between a and b."
# n, m = len(a), len(b)
# if n > m:
# # Make sure n <= m, to use O(min(n,m)) space
# a,b = b,a
# n,m = m,n
#
# current = range(n+1)
# for i in range(1,m+1):
# previous, current = current, [i]+[0]*n
# for j in range(1,n+1):
# add, delete = previous[j]+1, current[j-1]+1
# change = previous[j-1]
# if a[j-1] != b[i-1]:
# change = change + 1
# current[j] = min(add, delete, change)
#
# return current[n]
. Output only the next line. | logging.basicConfig(filename=LOG_FILENAME, level=logging.DEBUG) |
Based on the snippet: <|code_start|>
url_file_pattern = re.compile('^."id":"([^"]*)","url":"([^"]*)".*')
class ServeHandler(blobstore_handlers.BlobstoreDownloadHandler):
def get(self, resource):
<|code_end|>
, predict the immediate next line with the help of imports:
from google.appengine.ext.webapp import blobstore_handlers
from repositories.gae.blobstore import get_reader
from utils.zip_utils import all_matching_files
import urllib, zipfile, logging, re
and context (classes, functions, sometimes code) from other files:
# Path: repositories/gae/blobstore.py
# def get_reader(key):
# if not isinstance(key, str):
# updated_key = str(urllib.unquote(key))
# else:
# updated_key = key
#
# return blobstore.BlobReader(updated_key)
#
# Path: utils/zip_utils.py
# def all_matching_files(zip_reader, filename, pattern):
# with zip_reader.open(filename) as file_reader:
# (lno, mno) = (0, 0,)
# for line in file_reader:
# found_pattern = pattern.search(line)
# lno += 1
# if found_pattern:
# mno += 1
# yield lno, mno, found_pattern.group(1), found_pattern.group(2)
. Output only the next line. | blob_key = str(urllib.unquote(resource)) |
Using the snippet: <|code_start|>
DEFAULT_SHINGLE_SIZE = 4
class ShingleType(object):
W_SHINGLES = "w-shingles"
K_SHINGLES = "k-shingles"
@classmethod
def is_valid(cls, type):
if type == cls.W_SHINGLES or type == cls.K_SHINGLES:
return True
<|code_end|>
, determine the next line of code. You have imports:
from lsh.utils import strings_utils
and context (class names, function names, or code) available:
# Path: lsh/utils/strings_utils.py
# DEFAULT_TOKENIZER_DELIMITER = ' '
# def remove_all_whitespace(str):
# def tokenize(str, delimiter=DEFAULT_TOKENIZER_DELIMITER):
# def normalize(str):
# def get_stem(word):
. Output only the next line. | return False |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.