Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Based on the snippet: <|code_start|>
class ScaleCase(BaseScaleCase, PgmagickTestCase):
def runner(self, im):
im = Image(im)
im.filterType(self.filter)
im.zoom(Geometry(self.dest_size[0], self.dest_size[1]))
cases = [
rpartial(ScaleCase, size, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for size in [
0.01,
0.125,
0.8,
<|code_end|>
, predict the immediate next line with the help of imports:
from .base import rpartial, BaseScaleCase
from .pgmagick import Image, FilterTypes, Geometry, PgmagickTestCase
and context (classes, functions, sometimes code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | 2.14, |
Using the snippet: <|code_start|>
class ScaleCase(BaseScaleCase, PgmagickTestCase):
def runner(self, im):
im = Image(im)
im.filterType(self.filter)
im.zoom(Geometry(self.dest_size[0], self.dest_size[1]))
cases = [
rpartial(ScaleCase, size, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for size in [
0.01,
<|code_end|>
, determine the next line of code. You have imports:
from .base import rpartial, BaseScaleCase
from .pgmagick import Image, FilterTypes, Geometry, PgmagickTestCase
and context (class names, function names, or code) available:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | 0.125, |
Based on the snippet: <|code_start|>
class ScaleCase(BaseScaleCase, PgmagickTestCase):
def runner(self, im):
im = Image(im)
<|code_end|>
, predict the immediate next line with the help of imports:
from .base import rpartial, BaseScaleCase
from .pgmagick import Image, FilterTypes, Geometry, PgmagickTestCase
and context (classes, functions, sometimes code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | im.filterType(self.filter) |
Given the code snippet: <|code_start|>
class ScaleCase(BaseScaleCase, PgmagickTestCase):
def runner(self, im):
im = Image(im)
im.filterType(self.filter)
im.zoom(Geometry(self.dest_size[0], self.dest_size[1]))
cases = [
rpartial(ScaleCase, size, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for size in [
<|code_end|>
, generate the next line using the imports in this file:
from .base import rpartial, BaseScaleCase
from .pgmagick import Image, FilterTypes, Geometry, PgmagickTestCase
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | 0.01, |
Predict the next line for this snippet: <|code_start|>
class ScaleCase(BaseScaleCase, PgmagickTestCase):
def runner(self, im):
im = Image(im)
im.filterType(self.filter)
im.zoom(Geometry(self.dest_size[0], self.dest_size[1]))
cases = [
rpartial(ScaleCase, size, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for size in [
0.01,
0.125,
0.8,
2.14,
] for flt in [
# FilterTypes.BoxFilter,
FilterTypes.TriangleFilter,
# FilterTypes.HammingFilter,
FilterTypes.CatromFilter,
FilterTypes.LanczosFilter,
<|code_end|>
with the help of current file imports:
from .base import rpartial, BaseScaleCase
from .pgmagick import Image, FilterTypes, Geometry, PgmagickTestCase
and context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
, which may contain function names, class names, or code. Output only the next line. | ] |
Predict the next line for this snippet: <|code_start|>
class BlurCase(Cv2TestCase):
def handle_args(self, radius):
self.radius = radius
def runner(self, im):
window = 1 + int(ceil(self.radius * 2.5)) * 2
cv2.GaussianBlur(im, (window, window), self.radius)
def readable_args(self):
return ["{}px".format(self.radius)]
cases = [
rpartial(BlurCase, radius)
<|code_end|>
with the help of current file imports:
from math import ceil
from .base import rpartial
from .cv2 import cv2, Cv2TestCase
and context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
, which may contain function names, class names, or code. Output only the next line. | for radius in [ |
Given the code snippet: <|code_start|>
class BlurCase(Cv2TestCase):
def handle_args(self, radius):
self.radius = radius
def runner(self, im):
window = 1 + int(ceil(self.radius * 2.5)) * 2
cv2.GaussianBlur(im, (window, window), self.radius)
def readable_args(self):
return ["{}px".format(self.radius)]
cases = [
rpartial(BlurCase, radius)
for radius in [
1,
10,
<|code_end|>
, generate the next line using the imports in this file:
from math import ceil
from .base import rpartial
from .cv2 import cv2, Cv2TestCase
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | 30, |
Continue the code snippet: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
with Image(filename=root('resources', self.filename)):
<|code_end|>
. Use current file imports:
from io import BytesIO
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .wand import WandTestCase, Image
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
. Output only the next line. | pass |
Next line prediction: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
with Image(filename=root('resources', self.filename)):
pass
class SaveCase(BaseSaveCase, WandTestCase):
def create_test_data(self):
im = Image(filename=root('resources', self.filename))
self._free_resources.append(im)
return [im]
def runner(self, im):
im.compression_quality = 85
im.format = self.filetype
im.save(file=BytesIO())
cases = [
rpartial(LoadCase, 'JPEG', 'pineapple.jpeg'),
rpartial(SaveCase, 'JPEG', 'pineapple.jpeg'),
<|code_end|>
. Use current file imports:
(from io import BytesIO
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .wand import WandTestCase, Image)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
. Output only the next line. | ] |
Next line prediction: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
with Image(filename=root('resources', self.filename)):
pass
class SaveCase(BaseSaveCase, WandTestCase):
def create_test_data(self):
im = Image(filename=root('resources', self.filename))
self._free_resources.append(im)
return [im]
def runner(self, im):
im.compression_quality = 85
<|code_end|>
. Use current file imports:
(from io import BytesIO
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .wand import WandTestCase, Image)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
. Output only the next line. | im.format = self.filetype |
Next line prediction: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
with Image(filename=root('resources', self.filename)):
<|code_end|>
. Use current file imports:
(from io import BytesIO
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .wand import WandTestCase, Image)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
. Output only the next line. | pass |
Here is a snippet: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
with Image(filename=root('resources', self.filename)):
pass
class SaveCase(BaseSaveCase, WandTestCase):
def create_test_data(self):
im = Image(filename=root('resources', self.filename))
self._free_resources.append(im)
return [im]
def runner(self, im):
im.compression_quality = 85
im.format = self.filetype
im.save(file=BytesIO())
<|code_end|>
. Write the next line using the current file imports:
from io import BytesIO
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .wand import WandTestCase, Image
and context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
, which may include functions, classes, or code. Output only the next line. | cases = [ |
Next line prediction: <|code_start|>
class RotateRightCase(Cv2TestCase):
def handle_args(self, name, runner):
self.name = name
self.runner = runner
<|code_end|>
. Use current file imports:
(from .base import rpartial
from .cv2 import cv2, Cv2TestCase)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | def readable_args(self): |
Next line prediction: <|code_start|>
class RotateRightCase(Cv2TestCase):
def handle_args(self, name, runner):
self.name = name
self.runner = runner
def readable_args(self):
return [self.name]
<|code_end|>
. Use current file imports:
(from .base import rpartial
from .cv2 import cv2, Cv2TestCase)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | cases = [ |
Given snippet: <|code_start|>
class RotateRightCase(Cv2TestCase):
def handle_args(self, name, runner):
self.name = name
self.runner = runner
def readable_args(self):
return [self.name]
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import rpartial
from .cv2 import cv2, Cv2TestCase
and context:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
which might include code, classes, or functions. Output only the next line. | cases = [ |
Based on the snippet: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
im = Image.new_from_file(root('resources', self.filename))
im.getpoint(0, 0)
class SaveCase(BaseSaveCase):
def create_test_data(self):
im = Image.new_from_file(root('resources', self.filename))
<|code_end|>
, predict the immediate next line with the help of imports:
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .vips import Image
and context (classes, functions, sometimes code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/vips.py
# class VipsTestCase(BaseTestCase):
# def resize(cls, im, *args, **kwargs):
. Output only the next line. | im.getpoint(0, 0) |
Here is a snippet: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
im = Image.new_from_file(root('resources', self.filename))
im.getpoint(0, 0)
class SaveCase(BaseSaveCase):
def create_test_data(self):
im = Image.new_from_file(root('resources', self.filename))
im.getpoint(0, 0)
return [im]
def runner(self, im):
im.write_to_buffer('.'+self.filetype, Q=85)
<|code_end|>
. Write the next line using the current file imports:
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .vips import Image
and context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/vips.py
# class VipsTestCase(BaseTestCase):
# def resize(cls, im, *args, **kwargs):
, which may include functions, classes, or code. Output only the next line. | cases = [ |
Next line prediction: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
im = Image.new_from_file(root('resources', self.filename))
im.getpoint(0, 0)
class SaveCase(BaseSaveCase):
def create_test_data(self):
im = Image.new_from_file(root('resources', self.filename))
im.getpoint(0, 0)
<|code_end|>
. Use current file imports:
(from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .vips import Image)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/vips.py
# class VipsTestCase(BaseTestCase):
# def resize(cls, im, *args, **kwargs):
. Output only the next line. | return [im] |
Continue the code snippet: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
im = Image.new_from_file(root('resources', self.filename))
im.getpoint(0, 0)
class SaveCase(BaseSaveCase):
def create_test_data(self):
im = Image.new_from_file(root('resources', self.filename))
im.getpoint(0, 0)
return [im]
def runner(self, im):
<|code_end|>
. Use current file imports:
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .vips import Image
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/vips.py
# class VipsTestCase(BaseTestCase):
# def resize(cls, im, *args, **kwargs):
. Output only the next line. | im.write_to_buffer('.'+self.filetype, Q=85) |
Next line prediction: <|code_start|>
def __init__(self, *args, **kwargs):
self._free_resources = []
super().__init__(*args, **kwargs)
def create_test_data(self):
im = Image(filename=root('resources', 'color_circle.png'))
if self.mode == 'RGB':
im.type = 'truecolor'
elif self.mode == 'RGBA':
im.type = 'truecolormatte'
elif self.mode == 'L':
im.type = 'grayscale'
elif self.mode in 'LA':
im.type = 'grayscalematte'
else:
raise ValueError('Unknown mode: {}'.format(self.mode))
im.resize(self.size[0], self.size[1], 'catrom')
self._free_resources.append(im)
return [im]
def __del__(self):
for resource in self._free_resources:
resource.destroy()
@staticmethod
@manipulative
def blur(self, radius, sigma):
if not isinstance(radius, numbers.Real):
raise TypeError('radius has to be a numbers.Real, not ' +
<|code_end|>
. Use current file imports:
(import os
import ctypes
import numbers
from wand.image import Image, manipulative
from wand.api import library
from .base import BaseTestCase, root)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# class BaseTestCase:
# def __init__(self, size, mode, *args, **kwargs):
# self.size = size
# self.mode = mode
# self.repeat = kwargs.pop('repeat', 1)
# self.handle_args(*args, **kwargs)
# self.data = self.create_test_data()
#
# def handle_args(self, *args, **kwargs):
# self.args = args
# self.kwargs = kwargs
#
# def create_test_data(self):
# return []
#
# def run(self):
# start = time.time()
# for _ in range(self.repeat):
# self.runner(*self.data)
# return (time.time() - start) / self.repeat
#
# __call__ = run
#
# def readable_args(self):
# return list(map(str, self.args))
#
# def readable_name(self):
# return " ".join(self.readable_args())
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
. Output only the next line. | repr(radius)) |
Given snippet: <|code_start|>
# Make ImageMagick single threaded like other libraries are.
os.environ['MAGICK_THREAD_LIMIT'] = '1'
library.MagickBlurImage.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
library.MagickHaldClutImage.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
class WandTestCase(BaseTestCase):
filter_ids = {
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import ctypes
import numbers
from wand.image import Image, manipulative
from wand.api import library
from .base import BaseTestCase, root
and context:
# Path: testsuite/cases/base.py
# class BaseTestCase:
# def __init__(self, size, mode, *args, **kwargs):
# self.size = size
# self.mode = mode
# self.repeat = kwargs.pop('repeat', 1)
# self.handle_args(*args, **kwargs)
# self.data = self.create_test_data()
#
# def handle_args(self, *args, **kwargs):
# self.args = args
# self.kwargs = kwargs
#
# def create_test_data(self):
# return []
#
# def run(self):
# start = time.time()
# for _ in range(self.repeat):
# self.runner(*self.data)
# return (time.time() - start) / self.repeat
#
# __call__ = run
#
# def readable_args(self):
# return list(map(str, self.args))
#
# def readable_name(self):
# return " ".join(self.readable_args())
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
which might include code, classes, or functions. Output only the next line. | 'lanczos': 'lzs', 'triangle': 'bil', 'catrom': 'bic', 'hamming': 'hmn', |
Using the snippet: <|code_start|>
class BlurCase(PillowTestCase):
def handle_args(self, radius):
self.radius = radius
def runner(self, im):
<|code_end|>
, determine the next line of code. You have imports:
from .base import rpartial
from .pillow import PillowTestCase
and context (class names, function names, or code) available:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# filter_ids = {
# 0: 'ner', 1: 'lzs', 2: 'bil', 3: 'bic',
# 4: 'box', 5: 'hmn', 6: 'mtc',
# }
#
# def create_test_data(self):
# im = Image.open(root('resources', 'color_circle.png'))
# im = im.convert(self.mode)
# im = self.resize(im, self.size, Image.BICUBIC)
# assert im.size == tuple(self.size)
# return [im]
#
# @classmethod
# def resize(cls, self, size, resample=Image.NEAREST):
# """
# This implementation uses convolution resampling on Pillow 2.6 and below.
# """
# self.load()
#
# if self.size == size:
# return self._new(self.im)
#
# if self.mode in ("1", "P"):
# resample = Image.NEAREST
#
# if self.mode == 'RGBA':
# return cls.resize(self.convert('RGBa'),
# size, resample).convert('RGBA')
#
# if self.mode == 'LA':
# return cls.resize(self.convert('La'),
# size, resample).convert('LA')
#
# if resample == Image.NEAREST or not hasattr(self.im, 'stretch'):
# im = self.im.resize(size, resample)
# else:
# im = self.im.stretch(size, resample)
#
# return self._new(im)
#
# @classmethod
# def gaussian_blur(cls, self, radius, n=3):
# if self.mode == 'RGBA':
# return cls.gaussian_blur(self.convert('RGBa'),
# radius, n).convert('RGBA')
#
# if self.mode == 'LA':
# return cls.gaussian_blur(self.convert('La'),
# radius, n).convert('LA')
#
# if not hasattr(self.im, 'box_blur'):
# # Pillow 2.6 used different radius formula
# return self._new(ImageOps.gaussian_blur(self, radius * 2.5))
#
# # https://www.mia.uni-saarland.de/Publications/gwosdek-ssvm11.pdf
# # [7] Box length.
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
# # [11] Box radius.
# l = (L - 1.0) / 2.0
# # Integer part.
# li = math.floor(l)
# # Reduce the fractional part in accordance with tests.
# a = math.e ** (2.5 * (l - li) / (li + 1)) - 1
# a /= math.e ** (2.5 / (li + 1)) - 1
# box_radius = li + a
#
# self.load()
# return self._new(self.im.box_blur(box_radius, n))
#
# @classmethod
# def getchannel(cls, self, channel):
# if hasattr(self, 'getchannel'):
# return self.getchannel(channel)
# else:
# return self.split()[channel]
. Output only the next line. | self.gaussian_blur(im, self.radius) |
Continue the code snippet: <|code_start|>
class BlurCase(PillowTestCase):
def handle_args(self, radius):
self.radius = radius
def runner(self, im):
self.gaussian_blur(im, self.radius)
def readable_args(self):
return ["{}px".format(self.radius)]
<|code_end|>
. Use current file imports:
from .base import rpartial
from .pillow import PillowTestCase
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# filter_ids = {
# 0: 'ner', 1: 'lzs', 2: 'bil', 3: 'bic',
# 4: 'box', 5: 'hmn', 6: 'mtc',
# }
#
# def create_test_data(self):
# im = Image.open(root('resources', 'color_circle.png'))
# im = im.convert(self.mode)
# im = self.resize(im, self.size, Image.BICUBIC)
# assert im.size == tuple(self.size)
# return [im]
#
# @classmethod
# def resize(cls, self, size, resample=Image.NEAREST):
# """
# This implementation uses convolution resampling on Pillow 2.6 and below.
# """
# self.load()
#
# if self.size == size:
# return self._new(self.im)
#
# if self.mode in ("1", "P"):
# resample = Image.NEAREST
#
# if self.mode == 'RGBA':
# return cls.resize(self.convert('RGBa'),
# size, resample).convert('RGBA')
#
# if self.mode == 'LA':
# return cls.resize(self.convert('La'),
# size, resample).convert('LA')
#
# if resample == Image.NEAREST or not hasattr(self.im, 'stretch'):
# im = self.im.resize(size, resample)
# else:
# im = self.im.stretch(size, resample)
#
# return self._new(im)
#
# @classmethod
# def gaussian_blur(cls, self, radius, n=3):
# if self.mode == 'RGBA':
# return cls.gaussian_blur(self.convert('RGBa'),
# radius, n).convert('RGBA')
#
# if self.mode == 'LA':
# return cls.gaussian_blur(self.convert('La'),
# radius, n).convert('LA')
#
# if not hasattr(self.im, 'box_blur'):
# # Pillow 2.6 used different radius formula
# return self._new(ImageOps.gaussian_blur(self, radius * 2.5))
#
# # https://www.mia.uni-saarland.de/Publications/gwosdek-ssvm11.pdf
# # [7] Box length.
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
# # [11] Box radius.
# l = (L - 1.0) / 2.0
# # Integer part.
# li = math.floor(l)
# # Reduce the fractional part in accordance with tests.
# a = math.e ** (2.5 * (l - li) / (li + 1)) - 1
# a /= math.e ** (2.5 / (li + 1)) - 1
# box_radius = li + a
#
# self.load()
# return self._new(self.im.box_blur(box_radius, n))
#
# @classmethod
# def getchannel(cls, self, channel):
# if hasattr(self, 'getchannel'):
# return self.getchannel(channel)
# else:
# return self.split()[channel]
. Output only the next line. | cases = [ |
Given the following code snippet before the placeholder: <|code_start|>
try:
cv2.setNumThreads(1)
except AttributeError:
print('!!! You are using OpenCV which does not allow you to set '
'the number of threads')
class Cv2TestCase(BaseTestCase):
filter_ids = {
cv2.INTER_AREA: 'sup',
cv2.INTER_NEAREST: 'ner',
cv2.INTER_LINEAR: 'bil',
cv2.INTER_CUBIC: 'bic',
cv2.INTER_LANCZOS4: 'lzs4',
}
def create_test_data(self):
im = cv2.imread(root('resources', 'color_circle.png'),
flags=cv2.IMREAD_UNCHANGED)
<|code_end|>
, predict the next line using imports from the current file:
import cv2
from .base import BaseTestCase, root
and context including class names, function names, and sometimes code from other files:
# Path: testsuite/cases/base.py
# class BaseTestCase:
# def __init__(self, size, mode, *args, **kwargs):
# self.size = size
# self.mode = mode
# self.repeat = kwargs.pop('repeat', 1)
# self.handle_args(*args, **kwargs)
# self.data = self.create_test_data()
#
# def handle_args(self, *args, **kwargs):
# self.args = args
# self.kwargs = kwargs
#
# def create_test_data(self):
# return []
#
# def run(self):
# start = time.time()
# for _ in range(self.repeat):
# self.runner(*self.data)
# return (time.time() - start) / self.repeat
#
# __call__ = run
#
# def readable_args(self):
# return list(map(str, self.args))
#
# def readable_name(self):
# return " ".join(self.readable_args())
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
. Output only the next line. | if self.mode == 'RGB': |
Given the code snippet: <|code_start|>
class LutCase(WandTestCase):
def handle_args(self, table_size, hald_image):
self.table_size = table_size
self.hald_image = Image(filename=hald_image)
<|code_end|>
, generate the next line using the imports in this file:
from .base import rpartial, root
from .wand import WandTestCase, Image
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
. Output only the next line. | self._free_resources.append(self.hald_image) |
Next line prediction: <|code_start|>
class LutCase(WandTestCase):
def handle_args(self, table_size, hald_image):
self.table_size = table_size
self.hald_image = Image(filename=hald_image)
self._free_resources.append(self.hald_image)
def runner(self, im):
with im.clone() as im:
<|code_end|>
. Use current file imports:
(from .base import rpartial, root
from .wand import WandTestCase, Image)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
. Output only the next line. | self.hald_lut(im, self.hald_image) |
Predict the next line after this snippet: <|code_start|>
class LutCase(WandTestCase):
def handle_args(self, table_size, hald_image):
self.table_size = table_size
self.hald_image = Image(filename=hald_image)
self._free_resources.append(self.hald_image)
def runner(self, im):
with im.clone() as im:
self.hald_lut(im, self.hald_image)
def readable_args(self):
return ["{}³ table to 3D".format(self.table_size)]
<|code_end|>
using the current file's imports:
from .base import rpartial, root
from .wand import WandTestCase, Image
and any relevant context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
. Output only the next line. | cases = [ |
Predict the next line for this snippet: <|code_start|>
class LutCase(WandTestCase):
def handle_args(self, table_size, hald_image):
self.table_size = table_size
self.hald_image = Image(filename=hald_image)
self._free_resources.append(self.hald_image)
<|code_end|>
with the help of current file imports:
from .base import rpartial, root
from .wand import WandTestCase, Image
and context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
, which may contain function names, class names, or code. Output only the next line. | def runner(self, im): |
Given the code snippet: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
cv2.imread(root('resources', self.filename),
flags=cv2.IMREAD_UNCHANGED)
class SaveCase(BaseSaveCase):
def create_test_data(self):
im = cv2.imread(root('resources', self.filename),
flags=cv2.IMREAD_UNCHANGED)
return [im]
def runner(self, im):
cv2.imencode("." + self.filetype, im,
[int(cv2.IMWRITE_JPEG_QUALITY), 85])
<|code_end|>
, generate the next line using the imports in this file:
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .cv2 import cv2
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | cases = [ |
Continue the code snippet: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
cv2.imread(root('resources', self.filename),
flags=cv2.IMREAD_UNCHANGED)
class SaveCase(BaseSaveCase):
def create_test_data(self):
im = cv2.imread(root('resources', self.filename),
flags=cv2.IMREAD_UNCHANGED)
return [im]
<|code_end|>
. Use current file imports:
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .cv2 import cv2
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | def runner(self, im): |
Using the snippet: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
cv2.imread(root('resources', self.filename),
flags=cv2.IMREAD_UNCHANGED)
class SaveCase(BaseSaveCase):
def create_test_data(self):
im = cv2.imread(root('resources', self.filename),
flags=cv2.IMREAD_UNCHANGED)
return [im]
def runner(self, im):
cv2.imencode("." + self.filetype, im,
[int(cv2.IMWRITE_JPEG_QUALITY), 85])
cases = [
rpartial(LoadCase, 'JPEG', 'pineapple.jpeg'),
rpartial(SaveCase, 'JPEG', 'pineapple.jpeg'),
<|code_end|>
, determine the next line of code. You have imports:
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .cv2 import cv2
and context (class names, function names, or code) available:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | ] |
Given snippet: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
cv2.imread(root('resources', self.filename),
flags=cv2.IMREAD_UNCHANGED)
class SaveCase(BaseSaveCase):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .cv2 import cv2
and context:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
which might include code, classes, or functions. Output only the next line. | def create_test_data(self): |
Using the snippet: <|code_start|>
class CompositionCase(PgmagickTestCase):
def create_test_data(self):
im = Image(root('resources', 'color_circle.png').encode('utf-8'))
im.filterType(FilterTypes.CatromFilter)
im.scale(Geometry("{}x{}!".format(self.size[0], self.size[1])))
return [im, Image(im)]
<|code_end|>
, determine the next line of code. You have imports:
from .base import rpartial, root
from .pgmagick import Image, Geometry, FilterTypes, PgmagickTestCase
and context (class names, function names, or code) available:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | def runner(self, first, second): |
Next line prediction: <|code_start|>
class CompositionCase(PgmagickTestCase):
def create_test_data(self):
im = Image(root('resources', 'color_circle.png').encode('utf-8'))
im.filterType(FilterTypes.CatromFilter)
im.scale(Geometry("{}x{}!".format(self.size[0], self.size[1])))
return [im, Image(im)]
def runner(self, first, second):
res = Image(first)
<|code_end|>
. Use current file imports:
(from .base import rpartial, root
from .pgmagick import Image, Geometry, FilterTypes, PgmagickTestCase)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | res.composite(second, 0, 0) |
Given snippet: <|code_start|>
class CompositionCase(PgmagickTestCase):
def create_test_data(self):
im = Image(root('resources', 'color_circle.png').encode('utf-8'))
im.filterType(FilterTypes.CatromFilter)
im.scale(Geometry("{}x{}!".format(self.size[0], self.size[1])))
return [im, Image(im)]
def runner(self, first, second):
res = Image(first)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import rpartial, root
from .pgmagick import Image, Geometry, FilterTypes, PgmagickTestCase
and context:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
which might include code, classes, or functions. Output only the next line. | res.composite(second, 0, 0) |
Predict the next line after this snippet: <|code_start|>
class CompositionCase(PgmagickTestCase):
def create_test_data(self):
im = Image(root('resources', 'color_circle.png').encode('utf-8'))
im.filterType(FilterTypes.CatromFilter)
im.scale(Geometry("{}x{}!".format(self.size[0], self.size[1])))
return [im, Image(im)]
def runner(self, first, second):
res = Image(first)
res.composite(second, 0, 0)
<|code_end|>
using the current file's imports:
from .base import rpartial, root
from .pgmagick import Image, Geometry, FilterTypes, PgmagickTestCase
and any relevant context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | def readable_args(self): |
Predict the next line for this snippet: <|code_start|>
class CompositionCase(PgmagickTestCase):
def create_test_data(self):
im = Image(root('resources', 'color_circle.png').encode('utf-8'))
im.filterType(FilterTypes.CatromFilter)
im.scale(Geometry("{}x{}!".format(self.size[0], self.size[1])))
return [im, Image(im)]
def runner(self, first, second):
res = Image(first)
<|code_end|>
with the help of current file imports:
from .base import rpartial, root
from .pgmagick import Image, Geometry, FilterTypes, PgmagickTestCase
and context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
, which may contain function names, class names, or code. Output only the next line. | res.composite(second, 0, 0) |
Continue the code snippet: <|code_start|>
class CompositionCase(PgmagickTestCase):
def create_test_data(self):
im = Image(root('resources', 'color_circle.png').encode('utf-8'))
im.filterType(FilterTypes.CatromFilter)
im.scale(Geometry("{}x{}!".format(self.size[0], self.size[1])))
return [im, Image(im)]
def runner(self, first, second):
res = Image(first)
res.composite(second, 0, 0)
def readable_args(self):
return ["Composition"]
<|code_end|>
. Use current file imports:
from .base import rpartial, root
from .pgmagick import Image, Geometry, FilterTypes, PgmagickTestCase
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | cases = [ |
Next line prediction: <|code_start|>
class LutCase(PgmagickTestCase):
def handle_args(self, table_size, hald_image):
self.table_size = table_size
self.hald_image = Image(hald_image.encode('utf-8'))
def runner(self, im):
im = Image(im)
im.haldClut(self.hald_image)
def readable_args(self):
return ["{}³ table to 3D".format(self.table_size)]
cases = [
rpartial(LutCase, 4, root("resources", "hald.2.png")),
rpartial(LutCase, 16, root("resources", "hald.4.png")),
rpartial(LutCase, 36, root("resources", "hald.6.png")),
<|code_end|>
. Use current file imports:
(from .base import rpartial, root
from .pgmagick import Image, FilterTypes, Geometry, PgmagickTestCase)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | ] |
Given the code snippet: <|code_start|>
class LutCase(PgmagickTestCase):
def handle_args(self, table_size, hald_image):
self.table_size = table_size
self.hald_image = Image(hald_image.encode('utf-8'))
<|code_end|>
, generate the next line using the imports in this file:
from .base import rpartial, root
from .pgmagick import Image, FilterTypes, Geometry, PgmagickTestCase
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | def runner(self, im): |
Continue the code snippet: <|code_start|>
class LutCase(PgmagickTestCase):
def handle_args(self, table_size, hald_image):
self.table_size = table_size
self.hald_image = Image(hald_image.encode('utf-8'))
def runner(self, im):
im = Image(im)
<|code_end|>
. Use current file imports:
from .base import rpartial, root
from .pgmagick import Image, FilterTypes, Geometry, PgmagickTestCase
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | im.haldClut(self.hald_image) |
Continue the code snippet: <|code_start|>
class ConvertCase(BaseConvertCase, WandTestCase):
def runner(self, im):
with im.clone() as im:
if self.mode_to == 'L':
im.type = 'grayscale'
elif self.mode_to in 'LA':
<|code_end|>
. Use current file imports:
from .base import rpartial, BaseConvertCase
from .wand import WandTestCase
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseConvertCase:
# def handle_args(self, mode, mode_to):
# self.mode = mode
# self.mode_to = mode_to
#
# def readable_args(self):
# return ["{} to {}".format(self.mode, self.mode_to)]
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# filter_ids = {
# 'lanczos': 'lzs', 'triangle': 'bil', 'catrom': 'bic', 'hamming': 'hmn',
# }
#
# def __init__(self, *args, **kwargs):
# self._free_resources = []
# super().__init__(*args, **kwargs)
#
# def create_test_data(self):
# im = Image(filename=root('resources', 'color_circle.png'))
# if self.mode == 'RGB':
# im.type = 'truecolor'
# elif self.mode == 'RGBA':
# im.type = 'truecolormatte'
# elif self.mode == 'L':
# im.type = 'grayscale'
# elif self.mode in 'LA':
# im.type = 'grayscalematte'
# else:
# raise ValueError('Unknown mode: {}'.format(self.mode))
# im.resize(self.size[0], self.size[1], 'catrom')
# self._free_resources.append(im)
# return [im]
#
# def __del__(self):
# for resource in self._free_resources:
# resource.destroy()
#
# @staticmethod
# @manipulative
# def blur(self, radius, sigma):
# if not isinstance(radius, numbers.Real):
# raise TypeError('radius has to be a numbers.Real, not ' +
# repr(radius))
# elif not isinstance(sigma, numbers.Real):
# raise TypeError('sigma has to be a numbers.Real, not ' +
# repr(sigma))
# r = library.MagickBlurImage(self.wand, radius, sigma)
# if not r:
# self.raise_exception()
#
# @staticmethod
# @manipulative
# def hald_lut(self, hald_image):
# r = library.MagickHaldClutImage(self.wand, hald_image.resource)
# if not r:
# self.raise_exception()
. Output only the next line. | im.type = 'grayscalematte' |
Given snippet: <|code_start|>
class ConvertCase(BaseConvertCase, WandTestCase):
def runner(self, im):
with im.clone() as im:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import rpartial, BaseConvertCase
from .wand import WandTestCase
and context:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseConvertCase:
# def handle_args(self, mode, mode_to):
# self.mode = mode
# self.mode_to = mode_to
#
# def readable_args(self):
# return ["{} to {}".format(self.mode, self.mode_to)]
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# filter_ids = {
# 'lanczos': 'lzs', 'triangle': 'bil', 'catrom': 'bic', 'hamming': 'hmn',
# }
#
# def __init__(self, *args, **kwargs):
# self._free_resources = []
# super().__init__(*args, **kwargs)
#
# def create_test_data(self):
# im = Image(filename=root('resources', 'color_circle.png'))
# if self.mode == 'RGB':
# im.type = 'truecolor'
# elif self.mode == 'RGBA':
# im.type = 'truecolormatte'
# elif self.mode == 'L':
# im.type = 'grayscale'
# elif self.mode in 'LA':
# im.type = 'grayscalematte'
# else:
# raise ValueError('Unknown mode: {}'.format(self.mode))
# im.resize(self.size[0], self.size[1], 'catrom')
# self._free_resources.append(im)
# return [im]
#
# def __del__(self):
# for resource in self._free_resources:
# resource.destroy()
#
# @staticmethod
# @manipulative
# def blur(self, radius, sigma):
# if not isinstance(radius, numbers.Real):
# raise TypeError('radius has to be a numbers.Real, not ' +
# repr(radius))
# elif not isinstance(sigma, numbers.Real):
# raise TypeError('sigma has to be a numbers.Real, not ' +
# repr(sigma))
# r = library.MagickBlurImage(self.wand, radius, sigma)
# if not r:
# self.raise_exception()
#
# @staticmethod
# @manipulative
# def hald_lut(self, hald_image):
# r = library.MagickHaldClutImage(self.wand, hald_image.resource)
# if not r:
# self.raise_exception()
which might include code, classes, or functions. Output only the next line. | if self.mode_to == 'L': |
Next line prediction: <|code_start|>
# Make GraphicsMagick single threaded like other libraries are.
os.environ['OMP_NUM_THREADS'] = '1'
class PgmagickTestCase(BaseTestCase):
filter_ids = {
FilterTypes.LanczosFilter: 'lzs',
FilterTypes.TriangleFilter: 'bil',
FilterTypes.CatromFilter: 'bic',
FilterTypes.HammingFilter: 'hmn',
FilterTypes.BoxFilter: 'box',
}
def create_test_data(self):
im = Image(root('resources', 'color_circle.png').encode('utf-8'))
if self.mode == 'RGB':
im.type(ImageType.TrueColorType)
elif self.mode == 'RGBA':
im.type(ImageType.TrueColorMatteType)
<|code_end|>
. Use current file imports:
(import os
from pgmagick import Image, FilterTypes, ImageType, Geometry, Blob
from .base import BaseTestCase, root)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# class BaseTestCase:
# def __init__(self, size, mode, *args, **kwargs):
# self.size = size
# self.mode = mode
# self.repeat = kwargs.pop('repeat', 1)
# self.handle_args(*args, **kwargs)
# self.data = self.create_test_data()
#
# def handle_args(self, *args, **kwargs):
# self.args = args
# self.kwargs = kwargs
#
# def create_test_data(self):
# return []
#
# def run(self):
# start = time.time()
# for _ in range(self.repeat):
# self.runner(*self.data)
# return (time.time() - start) / self.repeat
#
# __call__ = run
#
# def readable_args(self):
# return list(map(str, self.args))
#
# def readable_name(self):
# return " ".join(self.readable_args())
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
. Output only the next line. | elif self.mode == 'L': |
Given snippet: <|code_start|>
# Make GraphicsMagick single threaded like other libraries are.
os.environ['OMP_NUM_THREADS'] = '1'
class PgmagickTestCase(BaseTestCase):
filter_ids = {
FilterTypes.LanczosFilter: 'lzs',
FilterTypes.TriangleFilter: 'bil',
FilterTypes.CatromFilter: 'bic',
FilterTypes.HammingFilter: 'hmn',
FilterTypes.BoxFilter: 'box',
}
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
from pgmagick import Image, FilterTypes, ImageType, Geometry, Blob
from .base import BaseTestCase, root
and context:
# Path: testsuite/cases/base.py
# class BaseTestCase:
# def __init__(self, size, mode, *args, **kwargs):
# self.size = size
# self.mode = mode
# self.repeat = kwargs.pop('repeat', 1)
# self.handle_args(*args, **kwargs)
# self.data = self.create_test_data()
#
# def handle_args(self, *args, **kwargs):
# self.args = args
# self.kwargs = kwargs
#
# def create_test_data(self):
# return []
#
# def run(self):
# start = time.time()
# for _ in range(self.repeat):
# self.runner(*self.data)
# return (time.time() - start) / self.repeat
#
# __call__ = run
#
# def readable_args(self):
# return list(map(str, self.args))
#
# def readable_name(self):
# return " ".join(self.readable_args())
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
which might include code, classes, or functions. Output only the next line. | def create_test_data(self): |
Continue the code snippet: <|code_start|>
class ScaleCase(BaseScaleCase, PillowTestCase):
def runner(self, im):
self.resize(im, self.dest_size, self.filter)
cases = [
rpartial(ScaleCase, scale, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
<|code_end|>
. Use current file imports:
from .base import rpartial, BaseScaleCase
from .pillow import Image, PillowTestCase
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
. Output only the next line. | ] for scale in [ |
Given snippet: <|code_start|>
class ScaleCase(BaseScaleCase, PillowTestCase):
def runner(self, im):
self.resize(im, self.dest_size, self.filter)
cases = [
rpartial(ScaleCase, scale, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for scale in [
0.01,
0.125,
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import rpartial, BaseScaleCase
from .pillow import Image, PillowTestCase
and context:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
which might include code, classes, or functions. Output only the next line. | 0.8, |
Using the snippet: <|code_start|>
class ScaleCase(BaseScaleCase, PillowTestCase):
def runner(self, im):
self.resize(im, self.dest_size, self.filter)
cases = [
rpartial(ScaleCase, scale, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
<|code_end|>
, determine the next line of code. You have imports:
from .base import rpartial, BaseScaleCase
from .pillow import Image, PillowTestCase
and context (class names, function names, or code) available:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
. Output only the next line. | (True, True), |
Using the snippet: <|code_start|>
class ScaleCase(BaseScaleCase, PillowTestCase):
def runner(self, im):
self.resize(im, self.dest_size, self.filter)
cases = [
rpartial(ScaleCase, scale, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for scale in [
0.01,
0.125,
0.8,
2.14,
<|code_end|>
, determine the next line of code. You have imports:
from .base import rpartial, BaseScaleCase
from .pillow import Image, PillowTestCase
and context (class names, function names, or code) available:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
. Output only the next line. | ] for flt in [ |
Given the code snippet: <|code_start|>
class BlurCase(PgmagickTestCase):
def handle_args(self, radius):
self.radius = radius
def runner(self, im):
im = Image(im)
im.blur(2.5 * self.radius, self.radius)
<|code_end|>
, generate the next line using the imports in this file:
from .base import rpartial
from .pgmagick import Image, PgmagickTestCase
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | def readable_args(self): |
Given the following code snippet before the placeholder: <|code_start|>
class BlurCase(PgmagickTestCase):
def handle_args(self, radius):
self.radius = radius
def runner(self, im):
im = Image(im)
im.blur(2.5 * self.radius, self.radius)
<|code_end|>
, predict the next line using imports from the current file:
from .base import rpartial
from .pgmagick import Image, PgmagickTestCase
and context including class names, function names, and sometimes code from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | def readable_args(self): |
Using the snippet: <|code_start|>
class BlurCase(PgmagickTestCase):
def handle_args(self, radius):
self.radius = radius
def runner(self, im):
im = Image(im)
im.blur(2.5 * self.radius, self.radius)
def readable_args(self):
<|code_end|>
, determine the next line of code. You have imports:
from .base import rpartial
from .pgmagick import Image, PgmagickTestCase
and context (class names, function names, or code) available:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | return ["{}px".format(self.radius)] |
Continue the code snippet: <|code_start|>
Image.LANCZOS = Image.ANTIALIAS
class PillowTestCase(BaseTestCase):
filter_ids = {
0: 'ner', 1: 'lzs', 2: 'bil', 3: 'bic',
4: 'box', 5: 'hmn', 6: 'mtc',
}
def create_test_data(self):
im = Image.open(root('resources', 'color_circle.png'))
im = im.convert(self.mode)
im = self.resize(im, self.size, Image.BICUBIC)
<|code_end|>
. Use current file imports:
import math
from PIL import Image, ImageFilter, ImageOps
from .base import BaseTestCase, root
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# class BaseTestCase:
# def __init__(self, size, mode, *args, **kwargs):
# self.size = size
# self.mode = mode
# self.repeat = kwargs.pop('repeat', 1)
# self.handle_args(*args, **kwargs)
# self.data = self.create_test_data()
#
# def handle_args(self, *args, **kwargs):
# self.args = args
# self.kwargs = kwargs
#
# def create_test_data(self):
# return []
#
# def run(self):
# start = time.time()
# for _ in range(self.repeat):
# self.runner(*self.data)
# return (time.time() - start) / self.repeat
#
# __call__ = run
#
# def readable_args(self):
# return list(map(str, self.args))
#
# def readable_name(self):
# return " ".join(self.readable_args())
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
. Output only the next line. | assert im.size == tuple(self.size) |
Here is a snippet: <|code_start|>
Image.LANCZOS = Image.ANTIALIAS
class PillowTestCase(BaseTestCase):
filter_ids = {
0: 'ner', 1: 'lzs', 2: 'bil', 3: 'bic',
4: 'box', 5: 'hmn', 6: 'mtc',
}
def create_test_data(self):
im = Image.open(root('resources', 'color_circle.png'))
im = im.convert(self.mode)
<|code_end|>
. Write the next line using the current file imports:
import math
from PIL import Image, ImageFilter, ImageOps
from .base import BaseTestCase, root
and context from other files:
# Path: testsuite/cases/base.py
# class BaseTestCase:
# def __init__(self, size, mode, *args, **kwargs):
# self.size = size
# self.mode = mode
# self.repeat = kwargs.pop('repeat', 1)
# self.handle_args(*args, **kwargs)
# self.data = self.create_test_data()
#
# def handle_args(self, *args, **kwargs):
# self.args = args
# self.kwargs = kwargs
#
# def create_test_data(self):
# return []
#
# def run(self):
# start = time.time()
# for _ in range(self.repeat):
# self.runner(*self.data)
# return (time.time() - start) / self.repeat
#
# __call__ = run
#
# def readable_args(self):
# return list(map(str, self.args))
#
# def readable_name(self):
# return " ".join(self.readable_args())
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
, which may include functions, classes, or code. Output only the next line. | im = self.resize(im, self.size, Image.BICUBIC) |
Given snippet: <|code_start|>
class ConvertCase(BaseConvertCase, PillowTestCase):
def runner(self, im):
im.convert(self.mode_to)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import rpartial, BaseConvertCase
from .pillow import PillowTestCase
and context:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseConvertCase:
# def handle_args(self, mode, mode_to):
# self.mode = mode
# self.mode_to = mode_to
#
# def readable_args(self):
# return ["{} to {}".format(self.mode, self.mode_to)]
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# filter_ids = {
# 0: 'ner', 1: 'lzs', 2: 'bil', 3: 'bic',
# 4: 'box', 5: 'hmn', 6: 'mtc',
# }
#
# def create_test_data(self):
# im = Image.open(root('resources', 'color_circle.png'))
# im = im.convert(self.mode)
# im = self.resize(im, self.size, Image.BICUBIC)
# assert im.size == tuple(self.size)
# return [im]
#
# @classmethod
# def resize(cls, self, size, resample=Image.NEAREST):
# """
# This implementation uses convolution resampling on Pillow 2.6 and below.
# """
# self.load()
#
# if self.size == size:
# return self._new(self.im)
#
# if self.mode in ("1", "P"):
# resample = Image.NEAREST
#
# if self.mode == 'RGBA':
# return cls.resize(self.convert('RGBa'),
# size, resample).convert('RGBA')
#
# if self.mode == 'LA':
# return cls.resize(self.convert('La'),
# size, resample).convert('LA')
#
# if resample == Image.NEAREST or not hasattr(self.im, 'stretch'):
# im = self.im.resize(size, resample)
# else:
# im = self.im.stretch(size, resample)
#
# return self._new(im)
#
# @classmethod
# def gaussian_blur(cls, self, radius, n=3):
# if self.mode == 'RGBA':
# return cls.gaussian_blur(self.convert('RGBa'),
# radius, n).convert('RGBA')
#
# if self.mode == 'LA':
# return cls.gaussian_blur(self.convert('La'),
# radius, n).convert('LA')
#
# if not hasattr(self.im, 'box_blur'):
# # Pillow 2.6 used different radius formula
# return self._new(ImageOps.gaussian_blur(self, radius * 2.5))
#
# # https://www.mia.uni-saarland.de/Publications/gwosdek-ssvm11.pdf
# # [7] Box length.
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
# # [11] Box radius.
# l = (L - 1.0) / 2.0
# # Integer part.
# li = math.floor(l)
# # Reduce the fractional part in accordance with tests.
# a = math.e ** (2.5 * (l - li) / (li + 1)) - 1
# a /= math.e ** (2.5 / (li + 1)) - 1
# box_radius = li + a
#
# self.load()
# return self._new(self.im.box_blur(box_radius, n))
#
# @classmethod
# def getchannel(cls, self, channel):
# if hasattr(self, 'getchannel'):
# return self.getchannel(channel)
# else:
# return self.split()[channel]
which might include code, classes, or functions. Output only the next line. | cases = [ |
Given the code snippet: <|code_start|>
class FilterCase(Cv2TestCase):
def handle_args(self, name, kernel):
self.name = name
size = int(len(kernel) ** 0.5)
kernel = numpy.asarray(kernel, numpy.float32).reshape((size, size))
self.kernel = kernel / kernel.sum()
def runner(self, im):
cv2.filter2D(im, -1, self.kernel)
def readable_args(self):
return [self.name]
cases = [
rpartial(FilterCase, "Smooth", [1, 1, 1, 1, 5, 1, 1, 1, 1]),
rpartial(FilterCase, "Sharpen", [-2, -2, -2, -2, 32, -2, -2, -2, -2]),
rpartial(FilterCase, "Smooth More", [
1, 1, 1, 1, 1,
1, 5, 5, 5, 1,
1, 5, 44, 5, 1,
1, 5, 5, 5, 1,
<|code_end|>
, generate the next line using the imports in this file:
import numpy
from .base import rpartial
from .cv2 import Cv2TestCase, cv2
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | 1, 1, 1, 1, 1 |
Continue the code snippet: <|code_start|>
class FilterCase(Cv2TestCase):
def handle_args(self, name, kernel):
self.name = name
size = int(len(kernel) ** 0.5)
<|code_end|>
. Use current file imports:
import numpy
from .base import rpartial
from .cv2 import Cv2TestCase, cv2
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | kernel = numpy.asarray(kernel, numpy.float32).reshape((size, size)) |
Here is a snippet: <|code_start|>
class ScaleCase(BaseScaleCase, Cv2TestCase):
def runner(self, im):
cv2.resize(im, self.dest_size, interpolation=self.filter)
cases = [
rpartial(ScaleCase, scale, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for scale in [
0.01,
0.125,
0.8,
] for flt in [
# cv2.INTER_NEAREST,
cv2.INTER_AREA,
]
] + [
rpartial(ScaleCase, scale, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
<|code_end|>
. Write the next line using the current file imports:
from .base import rpartial, BaseScaleCase
from .cv2 import cv2, Cv2TestCase
and context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
, which may include functions, classes, or code. Output only the next line. | ] for scale in [ |
Given the following code snippet before the placeholder: <|code_start|> cv2.resize(im, self.dest_size, interpolation=self.filter)
cases = [
rpartial(ScaleCase, scale, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for scale in [
0.01,
0.125,
0.8,
] for flt in [
# cv2.INTER_NEAREST,
cv2.INTER_AREA,
]
] + [
rpartial(ScaleCase, scale, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for scale in [
2.14,
] for flt in [
# cv2.INTER_NEAREST,
cv2.INTER_LINEAR,
cv2.INTER_CUBIC,
cv2.INTER_LANCZOS4,
<|code_end|>
, predict the next line using imports from the current file:
from .base import rpartial, BaseScaleCase
from .cv2 import cv2, Cv2TestCase
and context including class names, function names, and sometimes code from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | ] |
Based on the snippet: <|code_start|>
class ScaleCase(BaseScaleCase, Cv2TestCase):
def runner(self, im):
cv2.resize(im, self.dest_size, interpolation=self.filter)
cases = [
rpartial(ScaleCase, scale, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for scale in [
<|code_end|>
, predict the immediate next line with the help of imports:
from .base import rpartial, BaseScaleCase
from .cv2 import cv2, Cv2TestCase
and context (classes, functions, sometimes code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | 0.01, |
Given the code snippet: <|code_start|>
class ScaleCase(BaseScaleCase, Cv2TestCase):
def runner(self, im):
cv2.resize(im, self.dest_size, interpolation=self.filter)
cases = [
rpartial(ScaleCase, scale, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for scale in [
0.01,
0.125,
0.8,
] for flt in [
# cv2.INTER_NEAREST,
cv2.INTER_AREA,
]
] + [
rpartial(ScaleCase, scale, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for scale in [
<|code_end|>
, generate the next line using the imports in this file:
from .base import rpartial, BaseScaleCase
from .cv2 import cv2, Cv2TestCase
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | 2.14, |
Predict the next line after this snippet: <|code_start|>
class CompositionCase(PillowTestCase):
def create_test_data(self):
im = Image.open(root('resources', 'color_circle.png'))
im = self.resize(im, self.size, Image.BICUBIC)
return [im, im.copy()]
def runner(self, first, second):
Image.alpha_composite(first, second)
def readable_args(self):
return ["Composition"]
<|code_end|>
using the current file's imports:
from .base import rpartial, root
from .pillow import Image, PillowTestCase
and any relevant context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
. Output only the next line. | cases = [ |
Predict the next line for this snippet: <|code_start|>
class CompositionCase(PillowTestCase):
def create_test_data(self):
im = Image.open(root('resources', 'color_circle.png'))
im = self.resize(im, self.size, Image.BICUBIC)
return [im, im.copy()]
<|code_end|>
with the help of current file imports:
from .base import rpartial, root
from .pillow import Image, PillowTestCase
and context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
, which may contain function names, class names, or code. Output only the next line. | def runner(self, first, second): |
Predict the next line for this snippet: <|code_start|>
class CompositionCase(PillowTestCase):
def create_test_data(self):
im = Image.open(root('resources', 'color_circle.png'))
im = self.resize(im, self.size, Image.BICUBIC)
<|code_end|>
with the help of current file imports:
from .base import rpartial, root
from .pillow import Image, PillowTestCase
and context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
, which may contain function names, class names, or code. Output only the next line. | return [im, im.copy()] |
Using the snippet: <|code_start|>
class CompositionCase(PillowTestCase):
def create_test_data(self):
im = Image.open(root('resources', 'color_circle.png'))
im = self.resize(im, self.size, Image.BICUBIC)
return [im, im.copy()]
<|code_end|>
, determine the next line of code. You have imports:
from .base import rpartial, root
from .pillow import Image, PillowTestCase
and context (class names, function names, or code) available:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
. Output only the next line. | def runner(self, first, second): |
Continue the code snippet: <|code_start|>
class FullCycleCase(FullCycleBaseCase):
def runner(self):
im = cv2.imread(root('resources', self.filename),
flags=cv2.IMREAD_UNCHANGED)
if self.level > 0:
im = cv2.flip(cv2.transpose(im), 1)
if self.level > 1:
size = (int(im.shape[1] * 0.4 + 0.5),
int(im.shape[0] * 0.4 + 0.5))
im = cv2.resize(im, size, interpolation=cv2.INTER_AREA)
<|code_end|>
. Use current file imports:
from math import ceil
from .base import rpartial, root, FullCycleBaseCase
from .cv2 import cv2
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class FullCycleBaseCase(BaseTestCase):
# def handle_args(self, level, name, filename, filetype):
# self.level = level
# self.name = name
# self.filename = filename
# self.filetype = filetype
#
# def create_test_data(self):
# return ()
#
# def readable_args(self):
# return [self.name]
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | if self.level > 2: |
Given snippet: <|code_start|>
class FullCycleCase(FullCycleBaseCase):
def runner(self):
im = cv2.imread(root('resources', self.filename),
flags=cv2.IMREAD_UNCHANGED)
if self.level > 0:
im = cv2.flip(cv2.transpose(im), 1)
if self.level > 1:
size = (int(im.shape[1] * 0.4 + 0.5),
int(im.shape[0] * 0.4 + 0.5))
im = cv2.resize(im, size, interpolation=cv2.INTER_AREA)
if self.level > 2:
window = 1 + int(ceil(4 * 2.5)) * 2
im = cv2.GaussianBlur(im, (window, window), 4)
cv2.imencode("." + self.filetype, im,
[int(cv2.IMWRITE_JPEG_QUALITY), 85])
# cv2.imwrite('../_out.{}.cv2.png'.format(self.level), im)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from math import ceil
from .base import rpartial, root, FullCycleBaseCase
from .cv2 import cv2
and context:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class FullCycleBaseCase(BaseTestCase):
# def handle_args(self, level, name, filename, filetype):
# self.level = level
# self.name = name
# self.filename = filename
# self.filetype = filetype
#
# def create_test_data(self):
# return ()
#
# def readable_args(self):
# return [self.name]
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
which might include code, classes, or functions. Output only the next line. | cases = [ |
Predict the next line for this snippet: <|code_start|>
class FullCycleCase(FullCycleBaseCase):
def runner(self):
im = cv2.imread(root('resources', self.filename),
flags=cv2.IMREAD_UNCHANGED)
<|code_end|>
with the help of current file imports:
from math import ceil
from .base import rpartial, root, FullCycleBaseCase
from .cv2 import cv2
and context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class FullCycleBaseCase(BaseTestCase):
# def handle_args(self, level, name, filename, filetype):
# self.level = level
# self.name = name
# self.filename = filename
# self.filetype = filetype
#
# def create_test_data(self):
# return ()
#
# def readable_args(self):
# return [self.name]
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
, which may contain function names, class names, or code. Output only the next line. | if self.level > 0: |
Given snippet: <|code_start|>
class FullCycleCase(FullCycleBaseCase):
def runner(self):
im = cv2.imread(root('resources', self.filename),
flags=cv2.IMREAD_UNCHANGED)
if self.level > 0:
im = cv2.flip(cv2.transpose(im), 1)
if self.level > 1:
size = (int(im.shape[1] * 0.4 + 0.5),
int(im.shape[0] * 0.4 + 0.5))
im = cv2.resize(im, size, interpolation=cv2.INTER_AREA)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from math import ceil
from .base import rpartial, root, FullCycleBaseCase
from .cv2 import cv2
and context:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class FullCycleBaseCase(BaseTestCase):
# def handle_args(self, level, name, filename, filetype):
# self.level = level
# self.name = name
# self.filename = filename
# self.filetype = filetype
#
# def create_test_data(self):
# return ()
#
# def readable_args(self):
# return [self.name]
#
# Path: testsuite/cases/cv2.py
# class Cv2TestCase(BaseTestCase):
# def create_test_data(self):
which might include code, classes, or functions. Output only the next line. | if self.level > 2: |
Based on the snippet: <|code_start|>
class RotateRightCase(PgmagickTestCase):
def handle_args(self, name, operation):
self.name = name
self.operation = operation
def runner(self, im):
im = Image(im)
self.operation(im)
<|code_end|>
, predict the immediate next line with the help of imports:
from .base import rpartial
from .pgmagick import Image, PgmagickTestCase
and context (classes, functions, sometimes code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | def readable_args(self): |
Next line prediction: <|code_start|>
class RotateRightCase(PgmagickTestCase):
def handle_args(self, name, operation):
self.name = name
self.operation = operation
def runner(self, im):
im = Image(im)
<|code_end|>
. Use current file imports:
(from .base import rpartial
from .pgmagick import Image, PgmagickTestCase)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | self.operation(im) |
Predict the next line after this snippet: <|code_start|>
class RotateRightCase(PgmagickTestCase):
def handle_args(self, name, operation):
self.name = name
self.operation = operation
def runner(self, im):
im = Image(im)
self.operation(im)
def readable_args(self):
return [self.name]
def transpose(im, op2):
<|code_end|>
using the current file's imports:
from .base import rpartial
from .pgmagick import Image, PgmagickTestCase
and any relevant context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | im.rotate(90.0) |
Predict the next line for this snippet: <|code_start|>
class CompositionCase(WandTestCase):
def create_test_data(self):
im = Image(filename=root('resources', 'color_circle.png'))
im.resize(self.size[0], self.size[1], 'catrom')
copy = im.clone()
self._free_resources.append(im)
self._free_resources.append(copy)
return [im, copy]
def runner(self, first, second):
with first.clone() as res:
res.composite(second, 0, 0)
def readable_args(self):
return ["Composition"]
<|code_end|>
with the help of current file imports:
from .base import rpartial, root
from .wand import Image, WandTestCase
and context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
, which may contain function names, class names, or code. Output only the next line. | cases = [ |
Next line prediction: <|code_start|>
class CompositionCase(WandTestCase):
def create_test_data(self):
im = Image(filename=root('resources', 'color_circle.png'))
im.resize(self.size[0], self.size[1], 'catrom')
copy = im.clone()
self._free_resources.append(im)
self._free_resources.append(copy)
return [im, copy]
def runner(self, first, second):
with first.clone() as res:
<|code_end|>
. Use current file imports:
(from .base import rpartial, root
from .wand import Image, WandTestCase)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
. Output only the next line. | res.composite(second, 0, 0) |
Given snippet: <|code_start|>
class CompositionCase(WandTestCase):
def create_test_data(self):
im = Image(filename=root('resources', 'color_circle.png'))
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import rpartial, root
from .wand import Image, WandTestCase
and context:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
which might include code, classes, or functions. Output only the next line. | im.resize(self.size[0], self.size[1], 'catrom') |
Given the code snippet: <|code_start|>
class CompositionCase(WandTestCase):
def create_test_data(self):
im = Image(filename=root('resources', 'color_circle.png'))
im.resize(self.size[0], self.size[1], 'catrom')
copy = im.clone()
self._free_resources.append(im)
self._free_resources.append(copy)
return [im, copy]
def runner(self, first, second):
with first.clone() as res:
res.composite(second, 0, 0)
<|code_end|>
, generate the next line using the imports in this file:
from .base import rpartial, root
from .wand import Image, WandTestCase
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
. Output only the next line. | def readable_args(self): |
Next line prediction: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
Image(root('resources', self.filename).encode('utf-8'))
class SaveCase(BaseSaveCase):
def create_test_data(self):
im = Image(root('resources', self.filename).encode('utf-8'))
return [im]
def runner(self, im):
im.quality(85)
im.magick(self.filetype.encode('utf-8'))
im.write(Blob())
cases = [
rpartial(LoadCase, 'JPEG', 'pineapple.jpeg'),
rpartial(SaveCase, 'JPEG', 'pineapple.jpeg'),
<|code_end|>
. Use current file imports:
(from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .pgmagick import Image, Blob)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | ] |
Given the code snippet: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
Image(root('resources', self.filename).encode('utf-8'))
class SaveCase(BaseSaveCase):
<|code_end|>
, generate the next line using the imports in this file:
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .pgmagick import Image, Blob
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | def create_test_data(self): |
Given the code snippet: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
Image(root('resources', self.filename).encode('utf-8'))
class SaveCase(BaseSaveCase):
def create_test_data(self):
im = Image(root('resources', self.filename).encode('utf-8'))
return [im]
def runner(self, im):
im.quality(85)
im.magick(self.filetype.encode('utf-8'))
im.write(Blob())
<|code_end|>
, generate the next line using the imports in this file:
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .pgmagick import Image, Blob
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | cases = [ |
Given the code snippet: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
Image(root('resources', self.filename).encode('utf-8'))
class SaveCase(BaseSaveCase):
def create_test_data(self):
im = Image(root('resources', self.filename).encode('utf-8'))
return [im]
def runner(self, im):
im.quality(85)
im.magick(self.filetype.encode('utf-8'))
im.write(Blob())
cases = [
rpartial(LoadCase, 'JPEG', 'pineapple.jpeg'),
rpartial(SaveCase, 'JPEG', 'pineapple.jpeg'),
<|code_end|>
, generate the next line using the imports in this file:
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .pgmagick import Image, Blob
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
. Output only the next line. | ] |
Given snippet: <|code_start|>
class LoadCase(BaseLoadCase):
def runner(self):
Image(root('resources', self.filename).encode('utf-8'))
class SaveCase(BaseSaveCase):
def create_test_data(self):
im = Image(root('resources', self.filename).encode('utf-8'))
return [im]
def runner(self, im):
im.quality(85)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import rpartial, root, BaseLoadCase, BaseSaveCase
from .pgmagick import Image, Blob
and context:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class BaseLoadCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} load".format(self.filetype.capitalize())]
#
# class BaseSaveCase(BaseTestCase):
# def handle_args(self, filetype, filename):
# self.filetype = filetype
# self.filename = filename
#
# def readable_args(self):
# return ["{} save".format(self.filetype.capitalize())]
#
# Path: testsuite/cases/pgmagick.py
# class PgmagickTestCase(BaseTestCase):
# def create_test_data(self):
which might include code, classes, or functions. Output only the next line. | im.magick(self.filetype.encode('utf-8')) |
Continue the code snippet: <|code_start|>
class LutCase(PillowTestCase):
def handle_args(self, channels, table_size):
self.channels = channels
self.table_size = table_size
if channels == 3:
mode, callback = 'RGB', lambda r, g, b: (r, g, b)
elif channels == 4:
mode, callback = 'RGBA', lambda r, g, b: (r, g, b, r)
else:
raise ValueError("Channels should 3 or 4.")
self.lut = ImageFilter.Color3DLUT.generate(
table_size, callback, channels, mode)
def runner(self, im):
im.filter(self.lut)
def readable_args(self):
<|code_end|>
. Use current file imports:
from .base import rpartial
from .pillow import PillowTestCase, Image, ImageFilter
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
. Output only the next line. | return ["{}³ table to {}D".format(self.table_size, self.channels)] |
Next line prediction: <|code_start|>
class LutCase(PillowTestCase):
def handle_args(self, channels, table_size):
self.channels = channels
self.table_size = table_size
if channels == 3:
mode, callback = 'RGB', lambda r, g, b: (r, g, b)
elif channels == 4:
mode, callback = 'RGBA', lambda r, g, b: (r, g, b, r)
else:
<|code_end|>
. Use current file imports:
(from .base import rpartial
from .pillow import PillowTestCase, Image, ImageFilter)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
. Output only the next line. | raise ValueError("Channels should 3 or 4.") |
Given snippet: <|code_start|>
class LutCase(PillowTestCase):
def handle_args(self, channels, table_size):
self.channels = channels
self.table_size = table_size
if channels == 3:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import rpartial
from .pillow import PillowTestCase, Image, ImageFilter
and context:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
which might include code, classes, or functions. Output only the next line. | mode, callback = 'RGB', lambda r, g, b: (r, g, b) |
Given snippet: <|code_start|>
class FilterCase(PillowTestCase):
def handle_args(self, filter):
self.filter = filter
def runner(self, im):
im.filter(self.filter)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import rpartial
from .pillow import ImageFilter, PillowTestCase
and context:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
which might include code, classes, or functions. Output only the next line. | def readable_args(self): |
Using the snippet: <|code_start|>
class FilterCase(PillowTestCase):
def handle_args(self, filter):
self.filter = filter
def runner(self, im):
im.filter(self.filter)
def readable_args(self):
return [self.filter.name]
<|code_end|>
, determine the next line of code. You have imports:
from .base import rpartial
from .pillow import ImageFilter, PillowTestCase
and context (class names, function names, or code) available:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
. Output only the next line. | cases = [ |
Using the snippet: <|code_start|>
class CropCase(BaseCropCase, PillowTestCase):
def runner(self, im):
im = im.crop(self.dest_box)
assert im.size == self.dest_size
cases = [
rpartial(CropCase, (0.9, 0.9)),
rpartial(CropCase, (1.1, 1.1)),
<|code_end|>
, determine the next line of code. You have imports:
from .base import rpartial, BaseCropCase
from .pillow import PillowTestCase
and context (class names, function names, or code) available:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseCropCase:
# def handle_args(self, scale):
# self.scale = scale
# width = int(round(scale[0] * self.size[0]))
# height = int(round(scale[1] * self.size[1]))
# top = int((self.size[0] - width) / 2)
# left = int((self.size[1] - height) / 2)
# self.dest_size = (width, height)
# self.dest_box = (top, left, width + top, height + left)
#
# def readable_args(self):
# return ["x".join(map(str, self.dest_size))]
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# filter_ids = {
# 0: 'ner', 1: 'lzs', 2: 'bil', 3: 'bic',
# 4: 'box', 5: 'hmn', 6: 'mtc',
# }
#
# def create_test_data(self):
# im = Image.open(root('resources', 'color_circle.png'))
# im = im.convert(self.mode)
# im = self.resize(im, self.size, Image.BICUBIC)
# assert im.size == tuple(self.size)
# return [im]
#
# @classmethod
# def resize(cls, self, size, resample=Image.NEAREST):
# """
# This implementation uses convolution resampling on Pillow 2.6 and below.
# """
# self.load()
#
# if self.size == size:
# return self._new(self.im)
#
# if self.mode in ("1", "P"):
# resample = Image.NEAREST
#
# if self.mode == 'RGBA':
# return cls.resize(self.convert('RGBa'),
# size, resample).convert('RGBA')
#
# if self.mode == 'LA':
# return cls.resize(self.convert('La'),
# size, resample).convert('LA')
#
# if resample == Image.NEAREST or not hasattr(self.im, 'stretch'):
# im = self.im.resize(size, resample)
# else:
# im = self.im.stretch(size, resample)
#
# return self._new(im)
#
# @classmethod
# def gaussian_blur(cls, self, radius, n=3):
# if self.mode == 'RGBA':
# return cls.gaussian_blur(self.convert('RGBa'),
# radius, n).convert('RGBA')
#
# if self.mode == 'LA':
# return cls.gaussian_blur(self.convert('La'),
# radius, n).convert('LA')
#
# if not hasattr(self.im, 'box_blur'):
# # Pillow 2.6 used different radius formula
# return self._new(ImageOps.gaussian_blur(self, radius * 2.5))
#
# # https://www.mia.uni-saarland.de/Publications/gwosdek-ssvm11.pdf
# # [7] Box length.
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
# # [11] Box radius.
# l = (L - 1.0) / 2.0
# # Integer part.
# li = math.floor(l)
# # Reduce the fractional part in accordance with tests.
# a = math.e ** (2.5 * (l - li) / (li + 1)) - 1
# a /= math.e ** (2.5 / (li + 1)) - 1
# box_radius = li + a
#
# self.load()
# return self._new(self.im.box_blur(box_radius, n))
#
# @classmethod
# def getchannel(cls, self, channel):
# if hasattr(self, 'getchannel'):
# return self.getchannel(channel)
# else:
# return self.split()[channel]
. Output only the next line. | ] |
Continue the code snippet: <|code_start|>
class ScaleCase(BaseScaleCase, WandTestCase):
def runner(self, im):
with im.clone() as im:
im.resize(self.dest_size[0], self.dest_size[1], self.filter)
cases = [
rpartial(ScaleCase, size, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for size in [
0.01,
0.125,
0.8,
2.14,
] for flt in [
# 'box',
'triangle',
# 'hamming',
'catrom',
<|code_end|>
. Use current file imports:
from .base import rpartial, BaseScaleCase
from .wand import WandTestCase
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# filter_ids = {
# 'lanczos': 'lzs', 'triangle': 'bil', 'catrom': 'bic', 'hamming': 'hmn',
# }
#
# def __init__(self, *args, **kwargs):
# self._free_resources = []
# super().__init__(*args, **kwargs)
#
# def create_test_data(self):
# im = Image(filename=root('resources', 'color_circle.png'))
# if self.mode == 'RGB':
# im.type = 'truecolor'
# elif self.mode == 'RGBA':
# im.type = 'truecolormatte'
# elif self.mode == 'L':
# im.type = 'grayscale'
# elif self.mode in 'LA':
# im.type = 'grayscalematte'
# else:
# raise ValueError('Unknown mode: {}'.format(self.mode))
# im.resize(self.size[0], self.size[1], 'catrom')
# self._free_resources.append(im)
# return [im]
#
# def __del__(self):
# for resource in self._free_resources:
# resource.destroy()
#
# @staticmethod
# @manipulative
# def blur(self, radius, sigma):
# if not isinstance(radius, numbers.Real):
# raise TypeError('radius has to be a numbers.Real, not ' +
# repr(radius))
# elif not isinstance(sigma, numbers.Real):
# raise TypeError('sigma has to be a numbers.Real, not ' +
# repr(sigma))
# r = library.MagickBlurImage(self.wand, radius, sigma)
# if not r:
# self.raise_exception()
#
# @staticmethod
# @manipulative
# def hald_lut(self, hald_image):
# r = library.MagickHaldClutImage(self.wand, hald_image.resource)
# if not r:
# self.raise_exception()
. Output only the next line. | 'lanczos', |
Continue the code snippet: <|code_start|>
class ScaleCase(BaseScaleCase, WandTestCase):
def runner(self, im):
with im.clone() as im:
im.resize(self.dest_size[0], self.dest_size[1], self.filter)
cases = [
rpartial(ScaleCase, size, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for size in [
0.01,
0.125,
0.8,
<|code_end|>
. Use current file imports:
from .base import rpartial, BaseScaleCase
from .wand import WandTestCase
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# filter_ids = {
# 'lanczos': 'lzs', 'triangle': 'bil', 'catrom': 'bic', 'hamming': 'hmn',
# }
#
# def __init__(self, *args, **kwargs):
# self._free_resources = []
# super().__init__(*args, **kwargs)
#
# def create_test_data(self):
# im = Image(filename=root('resources', 'color_circle.png'))
# if self.mode == 'RGB':
# im.type = 'truecolor'
# elif self.mode == 'RGBA':
# im.type = 'truecolormatte'
# elif self.mode == 'L':
# im.type = 'grayscale'
# elif self.mode in 'LA':
# im.type = 'grayscalematte'
# else:
# raise ValueError('Unknown mode: {}'.format(self.mode))
# im.resize(self.size[0], self.size[1], 'catrom')
# self._free_resources.append(im)
# return [im]
#
# def __del__(self):
# for resource in self._free_resources:
# resource.destroy()
#
# @staticmethod
# @manipulative
# def blur(self, radius, sigma):
# if not isinstance(radius, numbers.Real):
# raise TypeError('radius has to be a numbers.Real, not ' +
# repr(radius))
# elif not isinstance(sigma, numbers.Real):
# raise TypeError('sigma has to be a numbers.Real, not ' +
# repr(sigma))
# r = library.MagickBlurImage(self.wand, radius, sigma)
# if not r:
# self.raise_exception()
#
# @staticmethod
# @manipulative
# def hald_lut(self, hald_image):
# r = library.MagickHaldClutImage(self.wand, hald_image.resource)
# if not r:
# self.raise_exception()
. Output only the next line. | 2.14, |
Given snippet: <|code_start|>
class ScaleCase(BaseScaleCase, WandTestCase):
def runner(self, im):
with im.clone() as im:
im.resize(self.dest_size[0], self.dest_size[1], self.filter)
cases = [
rpartial(ScaleCase, size, flt, hpass=hpass, vpass=vpass)
for hpass, vpass in [
# (True, False),
# (False, True),
(True, True),
] for size in [
0.01,
0.125,
0.8,
2.14,
] for flt in [
# 'box',
'triangle',
# 'hamming',
'catrom',
'lanczos',
]
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import rpartial, BaseScaleCase
from .wand import WandTestCase
and context:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# class BaseScaleCase:
# def handle_args(self, scale, filter, hpass=True, vpass=True):
# self.scale = scale
# self.filter = filter
# self.hpass = hpass
# self.vpass = vpass
# self.dest_size = (
# int(round(scale * self.size[0])) if hpass else self.size[0],
# int(round(scale * self.size[1])) if vpass else self.size[1],
# )
#
# def readable_args(self):
# return [
# "x".join(map(str, self.dest_size)),
# self.filter_ids.get(self.filter, self.filter),
# ]
#
# def readable_name(self):
# return 'to ' + super().readable_name()
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# filter_ids = {
# 'lanczos': 'lzs', 'triangle': 'bil', 'catrom': 'bic', 'hamming': 'hmn',
# }
#
# def __init__(self, *args, **kwargs):
# self._free_resources = []
# super().__init__(*args, **kwargs)
#
# def create_test_data(self):
# im = Image(filename=root('resources', 'color_circle.png'))
# if self.mode == 'RGB':
# im.type = 'truecolor'
# elif self.mode == 'RGBA':
# im.type = 'truecolormatte'
# elif self.mode == 'L':
# im.type = 'grayscale'
# elif self.mode in 'LA':
# im.type = 'grayscalematte'
# else:
# raise ValueError('Unknown mode: {}'.format(self.mode))
# im.resize(self.size[0], self.size[1], 'catrom')
# self._free_resources.append(im)
# return [im]
#
# def __del__(self):
# for resource in self._free_resources:
# resource.destroy()
#
# @staticmethod
# @manipulative
# def blur(self, radius, sigma):
# if not isinstance(radius, numbers.Real):
# raise TypeError('radius has to be a numbers.Real, not ' +
# repr(radius))
# elif not isinstance(sigma, numbers.Real):
# raise TypeError('sigma has to be a numbers.Real, not ' +
# repr(sigma))
# r = library.MagickBlurImage(self.wand, radius, sigma)
# if not r:
# self.raise_exception()
#
# @staticmethod
# @manipulative
# def hald_lut(self, hald_image):
# r = library.MagickHaldClutImage(self.wand, hald_image.resource)
# if not r:
# self.raise_exception()
which might include code, classes, or functions. Output only the next line. | ] |
Predict the next line after this snippet: <|code_start|>
class RotateRightCase(PillowTestCase):
def handle_args(self, name, runner):
self.name = name
self.runner = runner
def readable_args(self):
return [self.name]
cases = [
rpartial(RotateRightCase, 'Flop',
lambda im: im.transpose(Image.FLIP_LEFT_RIGHT)),
rpartial(RotateRightCase, 'Flip',
lambda im: im.transpose(Image.FLIP_TOP_BOTTOM)),
rpartial(RotateRightCase, 'Rotate 90',
lambda im: im.transpose(Image.ROTATE_90)),
rpartial(RotateRightCase, 'Rotate 180',
lambda im: im.transpose(Image.ROTATE_180)),
rpartial(RotateRightCase, 'Rotate 270',
lambda im: im.transpose(Image.ROTATE_270)),
rpartial(RotateRightCase, 'Transpose',
(lambda im: im.transpose(Image.TRANSPOSE))
if hasattr(Image, 'TRANSPOSE')
else lambda im: im.transpose(Image.ROTATE_90).transpose(Image.FLIP_TOP_BOTTOM)),
rpartial(RotateRightCase, 'Transverse',
(lambda im: im.transpose(Image.TRANSVERSE))
if hasattr(Image, 'TRANSVERSE')
else lambda im: im.transpose(Image.ROTATE_270).transpose(Image.FLIP_TOP_BOTTOM)),
<|code_end|>
using the current file's imports:
from .base import rpartial
from .pillow import Image, PillowTestCase
and any relevant context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
. Output only the next line. | ] |
Given the code snippet: <|code_start|>
class RotateRightCase(PillowTestCase):
def handle_args(self, name, runner):
self.name = name
self.runner = runner
def readable_args(self):
return [self.name]
cases = [
rpartial(RotateRightCase, 'Flop',
lambda im: im.transpose(Image.FLIP_LEFT_RIGHT)),
rpartial(RotateRightCase, 'Flip',
lambda im: im.transpose(Image.FLIP_TOP_BOTTOM)),
rpartial(RotateRightCase, 'Rotate 90',
lambda im: im.transpose(Image.ROTATE_90)),
rpartial(RotateRightCase, 'Rotate 180',
lambda im: im.transpose(Image.ROTATE_180)),
rpartial(RotateRightCase, 'Rotate 270',
lambda im: im.transpose(Image.ROTATE_270)),
rpartial(RotateRightCase, 'Transpose',
(lambda im: im.transpose(Image.TRANSPOSE))
if hasattr(Image, 'TRANSPOSE')
else lambda im: im.transpose(Image.ROTATE_90).transpose(Image.FLIP_TOP_BOTTOM)),
rpartial(RotateRightCase, 'Transverse',
(lambda im: im.transpose(Image.TRANSVERSE))
if hasattr(Image, 'TRANSVERSE')
else lambda im: im.transpose(Image.ROTATE_270).transpose(Image.FLIP_TOP_BOTTOM)),
<|code_end|>
, generate the next line using the imports in this file:
from .base import rpartial
from .pillow import Image, PillowTestCase
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
. Output only the next line. | ] |
Given the following code snippet before the placeholder: <|code_start|>
class BlurCase(WandTestCase):
def handle_args(self, radius):
self.radius = radius
def runner(self, im):
with im.clone() as im:
self.blur(im, 2.5 * self.radius, self.radius)
def readable_args(self):
return ["{}px".format(self.radius)]
cases = [
rpartial(BlurCase, radius)
for radius in [
1,
10,
30,
]
<|code_end|>
, predict the next line using imports from the current file:
from .base import rpartial
from .wand import WandTestCase
and context including class names, function names, and sometimes code from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# filter_ids = {
# 'lanczos': 'lzs', 'triangle': 'bil', 'catrom': 'bic', 'hamming': 'hmn',
# }
#
# def __init__(self, *args, **kwargs):
# self._free_resources = []
# super().__init__(*args, **kwargs)
#
# def create_test_data(self):
# im = Image(filename=root('resources', 'color_circle.png'))
# if self.mode == 'RGB':
# im.type = 'truecolor'
# elif self.mode == 'RGBA':
# im.type = 'truecolormatte'
# elif self.mode == 'L':
# im.type = 'grayscale'
# elif self.mode in 'LA':
# im.type = 'grayscalematte'
# else:
# raise ValueError('Unknown mode: {}'.format(self.mode))
# im.resize(self.size[0], self.size[1], 'catrom')
# self._free_resources.append(im)
# return [im]
#
# def __del__(self):
# for resource in self._free_resources:
# resource.destroy()
#
# @staticmethod
# @manipulative
# def blur(self, radius, sigma):
# if not isinstance(radius, numbers.Real):
# raise TypeError('radius has to be a numbers.Real, not ' +
# repr(radius))
# elif not isinstance(sigma, numbers.Real):
# raise TypeError('sigma has to be a numbers.Real, not ' +
# repr(sigma))
# r = library.MagickBlurImage(self.wand, radius, sigma)
# if not r:
# self.raise_exception()
#
# @staticmethod
# @manipulative
# def hald_lut(self, hald_image):
# r = library.MagickHaldClutImage(self.wand, hald_image.resource)
# if not r:
# self.raise_exception()
. Output only the next line. | ] |
Next line prediction: <|code_start|>
class BlurCase(WandTestCase):
def handle_args(self, radius):
self.radius = radius
def runner(self, im):
with im.clone() as im:
self.blur(im, 2.5 * self.radius, self.radius)
def readable_args(self):
return ["{}px".format(self.radius)]
cases = [
rpartial(BlurCase, radius)
for radius in [
1,
<|code_end|>
. Use current file imports:
(from .base import rpartial
from .wand import WandTestCase)
and context including class names, function names, or small code snippets from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# filter_ids = {
# 'lanczos': 'lzs', 'triangle': 'bil', 'catrom': 'bic', 'hamming': 'hmn',
# }
#
# def __init__(self, *args, **kwargs):
# self._free_resources = []
# super().__init__(*args, **kwargs)
#
# def create_test_data(self):
# im = Image(filename=root('resources', 'color_circle.png'))
# if self.mode == 'RGB':
# im.type = 'truecolor'
# elif self.mode == 'RGBA':
# im.type = 'truecolormatte'
# elif self.mode == 'L':
# im.type = 'grayscale'
# elif self.mode in 'LA':
# im.type = 'grayscalematte'
# else:
# raise ValueError('Unknown mode: {}'.format(self.mode))
# im.resize(self.size[0], self.size[1], 'catrom')
# self._free_resources.append(im)
# return [im]
#
# def __del__(self):
# for resource in self._free_resources:
# resource.destroy()
#
# @staticmethod
# @manipulative
# def blur(self, radius, sigma):
# if not isinstance(radius, numbers.Real):
# raise TypeError('radius has to be a numbers.Real, not ' +
# repr(radius))
# elif not isinstance(sigma, numbers.Real):
# raise TypeError('sigma has to be a numbers.Real, not ' +
# repr(sigma))
# r = library.MagickBlurImage(self.wand, radius, sigma)
# if not r:
# self.raise_exception()
#
# @staticmethod
# @manipulative
# def hald_lut(self, hald_image):
# r = library.MagickHaldClutImage(self.wand, hald_image.resource)
# if not r:
# self.raise_exception()
. Output only the next line. | 10, |
Continue the code snippet: <|code_start|>
# Make VIPS single threaded like other libraries are.
os.environ['VIPS_CONCURRENCY'] = '1'
pyvips.cache_set_max(0)
class VipsTestCase(BaseTestCase):
@classmethod
<|code_end|>
. Use current file imports:
import os
import pyvips
from pyvips import Image, Interpolate, at_least_libvips
from .base import BaseTestCase
and context (classes, functions, or code) from other files:
# Path: testsuite/cases/base.py
# class BaseTestCase:
# def __init__(self, size, mode, *args, **kwargs):
# self.size = size
# self.mode = mode
# self.repeat = kwargs.pop('repeat', 1)
# self.handle_args(*args, **kwargs)
# self.data = self.create_test_data()
#
# def handle_args(self, *args, **kwargs):
# self.args = args
# self.kwargs = kwargs
#
# def create_test_data(self):
# return []
#
# def run(self):
# start = time.time()
# for _ in range(self.repeat):
# self.runner(*self.data)
# return (time.time() - start) / self.repeat
#
# __call__ = run
#
# def readable_args(self):
# return list(map(str, self.args))
#
# def readable_name(self):
# return " ".join(self.readable_args())
. Output only the next line. | def resize(cls, im, *args, **kwargs): |
Predict the next line for this snippet: <|code_start|>
class RotateRightCase(WandTestCase):
def handle_args(self, name, operation):
self.name = name
self.operation = operation
def runner(self, im):
<|code_end|>
with the help of current file imports:
from .base import rpartial
from .wand import Image, WandTestCase
and context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
, which may contain function names, class names, or code. Output only the next line. | with im.clone() as im: |
Given the code snippet: <|code_start|>
class RotateRightCase(WandTestCase):
def handle_args(self, name, operation):
self.name = name
self.operation = operation
def runner(self, im):
with im.clone() as im:
self.operation(im)
<|code_end|>
, generate the next line using the imports in this file:
from .base import rpartial
from .wand import Image, WandTestCase
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# Path: testsuite/cases/wand.py
# class WandTestCase(BaseTestCase):
# def __init__(self, *args, **kwargs):
# def create_test_data(self):
# def __del__(self):
# def blur(self, radius, sigma):
# def hald_lut(self, hald_image):
. Output only the next line. | def readable_args(self): |
Predict the next line after this snippet: <|code_start|>
class FullCycleCase(FullCycleBaseCase, PillowTestCase):
def runner(self):
im = Image.open(root('resources', self.filename))
if self.level > 0:
im = im.transpose(Image.ROTATE_270)
if self.level > 1:
size = (int(im.size[0] * 0.4 + 0.5),
int(im.size[1] * 0.4 + 0.5))
im = self.resize(im, size, Image.BICUBIC)
if self.level > 2:
im = self.gaussian_blur(im, 4)
im.save(BytesIO(), format=self.filetype, quality=85)
# im.save('../_out.{}.pillow.png'.format(self.level))
<|code_end|>
using the current file's imports:
from io import BytesIO
from .base import rpartial, root, FullCycleBaseCase
from .pillow import Image, PillowTestCase
and any relevant context from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class FullCycleBaseCase(BaseTestCase):
# def handle_args(self, level, name, filename, filetype):
# self.level = level
# self.name = name
# self.filename = filename
# self.filetype = filetype
#
# def create_test_data(self):
# return ()
#
# def readable_args(self):
# return [self.name]
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
. Output only the next line. | cases = [ |
Given the code snippet: <|code_start|>
class FullCycleCase(FullCycleBaseCase, PillowTestCase):
def runner(self):
im = Image.open(root('resources', self.filename))
if self.level > 0:
im = im.transpose(Image.ROTATE_270)
if self.level > 1:
<|code_end|>
, generate the next line using the imports in this file:
from io import BytesIO
from .base import rpartial, root, FullCycleBaseCase
from .pillow import Image, PillowTestCase
and context (functions, classes, or occasionally code) from other files:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class FullCycleBaseCase(BaseTestCase):
# def handle_args(self, level, name, filename, filetype):
# self.level = level
# self.name = name
# self.filename = filename
# self.filetype = filetype
#
# def create_test_data(self):
# return ()
#
# def readable_args(self):
# return [self.name]
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
. Output only the next line. | size = (int(im.size[0] * 0.4 + 0.5), |
Given snippet: <|code_start|>
class FullCycleCase(FullCycleBaseCase, PillowTestCase):
def runner(self):
im = Image.open(root('resources', self.filename))
if self.level > 0:
im = im.transpose(Image.ROTATE_270)
if self.level > 1:
size = (int(im.size[0] * 0.4 + 0.5),
int(im.size[1] * 0.4 + 0.5))
im = self.resize(im, size, Image.BICUBIC)
if self.level > 2:
im = self.gaussian_blur(im, 4)
im.save(BytesIO(), format=self.filetype, quality=85)
# im.save('../_out.{}.pillow.png'.format(self.level))
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from io import BytesIO
from .base import rpartial, root, FullCycleBaseCase
from .pillow import Image, PillowTestCase
and context:
# Path: testsuite/cases/base.py
# def rpartial(func, *args, **keywords):
# """
# right partial — same as functools.partial, but pass function args first
# """
# def newfunc(*fargs, **fkeywords):
# newkeywords = keywords.copy()
# newkeywords.update(fkeywords)
# return func(*(fargs + args), **newkeywords)
# newfunc.func = func
# newfunc.args = args
# newfunc.keywords = keywords
# return newfunc
#
# def root(*chunks):
# return os.path.abspath(os.path.join(
# os.path.dirname(__file__), '..', *chunks))
#
# class FullCycleBaseCase(BaseTestCase):
# def handle_args(self, level, name, filename, filetype):
# self.level = level
# self.name = name
# self.filename = filename
# self.filetype = filetype
#
# def create_test_data(self):
# return ()
#
# def readable_args(self):
# return [self.name]
#
# Path: testsuite/cases/pillow.py
# class PillowTestCase(BaseTestCase):
# def create_test_data(self):
# def resize(cls, self, size, resample=Image.NEAREST):
# def gaussian_blur(cls, self, radius, n=3):
# def getchannel(cls, self, channel):
# L = math.sqrt(12.0 * float(radius) * radius / n + 1.0)
which might include code, classes, or functions. Output only the next line. | cases = [ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.