Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Given snippet: <|code_start|>
@todo: Add stencil components to L{texture_formats}.
@author: Stephan Wenger
@date: 2012-02-29
"""
format_to_length = {
#_gl.GL_COLOR_INDEX: 1,
_gl.GL_STENCIL_INDEX: 1,
_gl.GL_DEPTH_COMPONENT: 1,
_gl.GL_RED: 1,
_gl.GL_GREEN: 1,
_gl.GL_BLUE: 1,
_gl.GL_ALPHA: 1,
_gl.GL_RGB: 3,
_gl.GL_BGR: 3,
_gl.GL_RGBA: 4,
_gl.GL_BGRA: 4,
#_gl.GL_LUMINANCE: 1,
#_gl.GL_LUMINANCE_ALPHA: 2,
}
texture_formats = [ # WARNING: In case of ambiguities, the LAST ONE will win.
((float32, 1), _gl.GL_DEPTH_COMPONENT32F, (_gl.GL_FLOAT, _gl.GL_DEPTH_COMPONENT)),
((int16, 1), _gl.GL_DEPTH_COMPONENT16, (_gl.GL_SHORT, _gl.GL_DEPTH_COMPONENT)),
((int32, 1), _gl.GL_DEPTH_COMPONENT24, (_gl.GL_INT, _gl.GL_DEPTH_COMPONENT)),
((int32, 1), _gl.GL_DEPTH_COMPONENT32, (_gl.GL_INT, _gl.GL_DEPTH_COMPONENT)),
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import glitter.raw as _gl
from glitter.utils.dtypes import uint8, uint16, uint32, int8, int16, int32, float32
from glitter.utils.enum import Enum
and context:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
#
# Path: glitter/utils/enum.py
# class Enum(object):
# def __init__(self, **kwargs):
# self._reverse_dict = {}
# for key, value in list(kwargs.items()):
# self._add(key, value)
#
# def __getitem__(self, value):
# return self._reverse_dict[value]
#
# def __call__(self, obj):
# """Convert C{obj} into an appropriate L{EnumConstant}.
# """
#
# if obj in list(self.__dict__.values()): # A matching EnumConstant is okay.
# return obj
# elif obj in list(self.__dict__.keys()): # A string is converted to an EnumConstant if possible.
# return self.__dict__[obj]
# else: # Anything else is just wrong.
# raise TypeError("%r is not a valid enum constant here" % obj)
#
# def _add(self, key, value):
# setattr(self, key, EnumConstant(self, key, value))
# self._reverse_dict[value] = getattr(self, key)
#
# def __repr__(self):
# return "Enum(%s)" % ", ".join(map(str, list(self._reverse_dict.values())))
which might include code, classes, or functions. Output only the next line. | ((uint8, 1), _gl.GL_R8UI, (_gl.GL_UNSIGNED_BYTE, _gl.GL_RED_INTEGER )), |
Given the code snippet: <|code_start|>
@author: Stephan Wenger
@date: 2012-02-29
"""
format_to_length = {
#_gl.GL_COLOR_INDEX: 1,
_gl.GL_STENCIL_INDEX: 1,
_gl.GL_DEPTH_COMPONENT: 1,
_gl.GL_RED: 1,
_gl.GL_GREEN: 1,
_gl.GL_BLUE: 1,
_gl.GL_ALPHA: 1,
_gl.GL_RGB: 3,
_gl.GL_BGR: 3,
_gl.GL_RGBA: 4,
_gl.GL_BGRA: 4,
#_gl.GL_LUMINANCE: 1,
#_gl.GL_LUMINANCE_ALPHA: 2,
}
texture_formats = [ # WARNING: In case of ambiguities, the LAST ONE will win.
((float32, 1), _gl.GL_DEPTH_COMPONENT32F, (_gl.GL_FLOAT, _gl.GL_DEPTH_COMPONENT)),
((int16, 1), _gl.GL_DEPTH_COMPONENT16, (_gl.GL_SHORT, _gl.GL_DEPTH_COMPONENT)),
((int32, 1), _gl.GL_DEPTH_COMPONENT24, (_gl.GL_INT, _gl.GL_DEPTH_COMPONENT)),
((int32, 1), _gl.GL_DEPTH_COMPONENT32, (_gl.GL_INT, _gl.GL_DEPTH_COMPONENT)),
((uint8, 1), _gl.GL_R8UI, (_gl.GL_UNSIGNED_BYTE, _gl.GL_RED_INTEGER )),
((int8, 1), _gl.GL_R8I, (_gl.GL_BYTE, _gl.GL_RED_INTEGER )),
<|code_end|>
, generate the next line using the imports in this file:
import glitter.raw as _gl
from glitter.utils.dtypes import uint8, uint16, uint32, int8, int16, int32, float32
from glitter.utils.enum import Enum
and context (functions, classes, or occasionally code) from other files:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
#
# Path: glitter/utils/enum.py
# class Enum(object):
# def __init__(self, **kwargs):
# self._reverse_dict = {}
# for key, value in list(kwargs.items()):
# self._add(key, value)
#
# def __getitem__(self, value):
# return self._reverse_dict[value]
#
# def __call__(self, obj):
# """Convert C{obj} into an appropriate L{EnumConstant}.
# """
#
# if obj in list(self.__dict__.values()): # A matching EnumConstant is okay.
# return obj
# elif obj in list(self.__dict__.keys()): # A string is converted to an EnumConstant if possible.
# return self.__dict__[obj]
# else: # Anything else is just wrong.
# raise TypeError("%r is not a valid enum constant here" % obj)
#
# def _add(self, key, value):
# setattr(self, key, EnumConstant(self, key, value))
# self._reverse_dict[value] = getattr(self, key)
#
# def __repr__(self):
# return "Enum(%s)" % ", ".join(map(str, list(self._reverse_dict.values())))
. Output only the next line. | ((uint16, 1), _gl.GL_R16UI, (_gl.GL_UNSIGNED_SHORT, _gl.GL_RED_INTEGER )), |
Using the snippet: <|code_start|>@date: 2012-02-29
"""
format_to_length = {
#_gl.GL_COLOR_INDEX: 1,
_gl.GL_STENCIL_INDEX: 1,
_gl.GL_DEPTH_COMPONENT: 1,
_gl.GL_RED: 1,
_gl.GL_GREEN: 1,
_gl.GL_BLUE: 1,
_gl.GL_ALPHA: 1,
_gl.GL_RGB: 3,
_gl.GL_BGR: 3,
_gl.GL_RGBA: 4,
_gl.GL_BGRA: 4,
#_gl.GL_LUMINANCE: 1,
#_gl.GL_LUMINANCE_ALPHA: 2,
}
texture_formats = [ # WARNING: In case of ambiguities, the LAST ONE will win.
((float32, 1), _gl.GL_DEPTH_COMPONENT32F, (_gl.GL_FLOAT, _gl.GL_DEPTH_COMPONENT)),
((int16, 1), _gl.GL_DEPTH_COMPONENT16, (_gl.GL_SHORT, _gl.GL_DEPTH_COMPONENT)),
((int32, 1), _gl.GL_DEPTH_COMPONENT24, (_gl.GL_INT, _gl.GL_DEPTH_COMPONENT)),
((int32, 1), _gl.GL_DEPTH_COMPONENT32, (_gl.GL_INT, _gl.GL_DEPTH_COMPONENT)),
((uint8, 1), _gl.GL_R8UI, (_gl.GL_UNSIGNED_BYTE, _gl.GL_RED_INTEGER )),
((int8, 1), _gl.GL_R8I, (_gl.GL_BYTE, _gl.GL_RED_INTEGER )),
((uint16, 1), _gl.GL_R16UI, (_gl.GL_UNSIGNED_SHORT, _gl.GL_RED_INTEGER )),
((int16, 1), _gl.GL_R16I, (_gl.GL_SHORT, _gl.GL_RED_INTEGER )),
<|code_end|>
, determine the next line of code. You have imports:
import glitter.raw as _gl
from glitter.utils.dtypes import uint8, uint16, uint32, int8, int16, int32, float32
from glitter.utils.enum import Enum
and context (class names, function names, or code) available:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
#
# Path: glitter/utils/enum.py
# class Enum(object):
# def __init__(self, **kwargs):
# self._reverse_dict = {}
# for key, value in list(kwargs.items()):
# self._add(key, value)
#
# def __getitem__(self, value):
# return self._reverse_dict[value]
#
# def __call__(self, obj):
# """Convert C{obj} into an appropriate L{EnumConstant}.
# """
#
# if obj in list(self.__dict__.values()): # A matching EnumConstant is okay.
# return obj
# elif obj in list(self.__dict__.keys()): # A string is converted to an EnumConstant if possible.
# return self.__dict__[obj]
# else: # Anything else is just wrong.
# raise TypeError("%r is not a valid enum constant here" % obj)
#
# def _add(self, key, value):
# setattr(self, key, EnumConstant(self, key, value))
# self._reverse_dict[value] = getattr(self, key)
#
# def __repr__(self):
# return "Enum(%s)" % ", ".join(map(str, list(self._reverse_dict.values())))
. Output only the next line. | ((uint32, 1), _gl.GL_R32UI, (_gl.GL_UNSIGNED_INT, _gl.GL_RED_INTEGER )), |
Predict the next line for this snippet: <|code_start|>@todo: Add stencil components to L{texture_formats}.
@author: Stephan Wenger
@date: 2012-02-29
"""
format_to_length = {
#_gl.GL_COLOR_INDEX: 1,
_gl.GL_STENCIL_INDEX: 1,
_gl.GL_DEPTH_COMPONENT: 1,
_gl.GL_RED: 1,
_gl.GL_GREEN: 1,
_gl.GL_BLUE: 1,
_gl.GL_ALPHA: 1,
_gl.GL_RGB: 3,
_gl.GL_BGR: 3,
_gl.GL_RGBA: 4,
_gl.GL_BGRA: 4,
#_gl.GL_LUMINANCE: 1,
#_gl.GL_LUMINANCE_ALPHA: 2,
}
texture_formats = [ # WARNING: In case of ambiguities, the LAST ONE will win.
((float32, 1), _gl.GL_DEPTH_COMPONENT32F, (_gl.GL_FLOAT, _gl.GL_DEPTH_COMPONENT)),
((int16, 1), _gl.GL_DEPTH_COMPONENT16, (_gl.GL_SHORT, _gl.GL_DEPTH_COMPONENT)),
((int32, 1), _gl.GL_DEPTH_COMPONENT24, (_gl.GL_INT, _gl.GL_DEPTH_COMPONENT)),
((int32, 1), _gl.GL_DEPTH_COMPONENT32, (_gl.GL_INT, _gl.GL_DEPTH_COMPONENT)),
((uint8, 1), _gl.GL_R8UI, (_gl.GL_UNSIGNED_BYTE, _gl.GL_RED_INTEGER )),
<|code_end|>
with the help of current file imports:
import glitter.raw as _gl
from glitter.utils.dtypes import uint8, uint16, uint32, int8, int16, int32, float32
from glitter.utils.enum import Enum
and context from other files:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
#
# Path: glitter/utils/enum.py
# class Enum(object):
# def __init__(self, **kwargs):
# self._reverse_dict = {}
# for key, value in list(kwargs.items()):
# self._add(key, value)
#
# def __getitem__(self, value):
# return self._reverse_dict[value]
#
# def __call__(self, obj):
# """Convert C{obj} into an appropriate L{EnumConstant}.
# """
#
# if obj in list(self.__dict__.values()): # A matching EnumConstant is okay.
# return obj
# elif obj in list(self.__dict__.keys()): # A string is converted to an EnumConstant if possible.
# return self.__dict__[obj]
# else: # Anything else is just wrong.
# raise TypeError("%r is not a valid enum constant here" % obj)
#
# def _add(self, key, value):
# setattr(self, key, EnumConstant(self, key, value))
# self._reverse_dict[value] = getattr(self, key)
#
# def __repr__(self):
# return "Enum(%s)" % ", ".join(map(str, list(self._reverse_dict.values())))
, which may contain function names, class names, or code. Output only the next line. | ((int8, 1), _gl.GL_R8I, (_gl.GL_BYTE, _gl.GL_RED_INTEGER )), |
Given snippet: <|code_start|>"""Constants and enums.
@todo: Add stencil components to L{texture_formats}.
@author: Stephan Wenger
@date: 2012-02-29
"""
format_to_length = {
#_gl.GL_COLOR_INDEX: 1,
_gl.GL_STENCIL_INDEX: 1,
_gl.GL_DEPTH_COMPONENT: 1,
_gl.GL_RED: 1,
_gl.GL_GREEN: 1,
_gl.GL_BLUE: 1,
_gl.GL_ALPHA: 1,
_gl.GL_RGB: 3,
_gl.GL_BGR: 3,
_gl.GL_RGBA: 4,
_gl.GL_BGRA: 4,
#_gl.GL_LUMINANCE: 1,
#_gl.GL_LUMINANCE_ALPHA: 2,
}
texture_formats = [ # WARNING: In case of ambiguities, the LAST ONE will win.
((float32, 1), _gl.GL_DEPTH_COMPONENT32F, (_gl.GL_FLOAT, _gl.GL_DEPTH_COMPONENT)),
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import glitter.raw as _gl
from glitter.utils.dtypes import uint8, uint16, uint32, int8, int16, int32, float32
from glitter.utils.enum import Enum
and context:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
#
# Path: glitter/utils/enum.py
# class Enum(object):
# def __init__(self, **kwargs):
# self._reverse_dict = {}
# for key, value in list(kwargs.items()):
# self._add(key, value)
#
# def __getitem__(self, value):
# return self._reverse_dict[value]
#
# def __call__(self, obj):
# """Convert C{obj} into an appropriate L{EnumConstant}.
# """
#
# if obj in list(self.__dict__.values()): # A matching EnumConstant is okay.
# return obj
# elif obj in list(self.__dict__.keys()): # A string is converted to an EnumConstant if possible.
# return self.__dict__[obj]
# else: # Anything else is just wrong.
# raise TypeError("%r is not a valid enum constant here" % obj)
#
# def _add(self, key, value):
# setattr(self, key, EnumConstant(self, key, value))
# self._reverse_dict[value] = getattr(self, key)
#
# def __repr__(self):
# return "Enum(%s)" % ", ".join(map(str, list(self._reverse_dict.values())))
which might include code, classes, or functions. Output only the next line. | ((int16, 1), _gl.GL_DEPTH_COMPONENT16, (_gl.GL_SHORT, _gl.GL_DEPTH_COMPONENT)), |
Given the following code snippet before the placeholder: <|code_start|>"""Constants and enums.
@todo: Add stencil components to L{texture_formats}.
@author: Stephan Wenger
@date: 2012-02-29
"""
format_to_length = {
#_gl.GL_COLOR_INDEX: 1,
_gl.GL_STENCIL_INDEX: 1,
_gl.GL_DEPTH_COMPONENT: 1,
_gl.GL_RED: 1,
_gl.GL_GREEN: 1,
_gl.GL_BLUE: 1,
_gl.GL_ALPHA: 1,
_gl.GL_RGB: 3,
_gl.GL_BGR: 3,
_gl.GL_RGBA: 4,
_gl.GL_BGRA: 4,
#_gl.GL_LUMINANCE: 1,
#_gl.GL_LUMINANCE_ALPHA: 2,
}
texture_formats = [ # WARNING: In case of ambiguities, the LAST ONE will win.
((float32, 1), _gl.GL_DEPTH_COMPONENT32F, (_gl.GL_FLOAT, _gl.GL_DEPTH_COMPONENT)),
((int16, 1), _gl.GL_DEPTH_COMPONENT16, (_gl.GL_SHORT, _gl.GL_DEPTH_COMPONENT)),
<|code_end|>
, predict the next line using imports from the current file:
import glitter.raw as _gl
from glitter.utils.dtypes import uint8, uint16, uint32, int8, int16, int32, float32
from glitter.utils.enum import Enum
and context including class names, function names, and sometimes code from other files:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
#
# Path: glitter/utils/enum.py
# class Enum(object):
# def __init__(self, **kwargs):
# self._reverse_dict = {}
# for key, value in list(kwargs.items()):
# self._add(key, value)
#
# def __getitem__(self, value):
# return self._reverse_dict[value]
#
# def __call__(self, obj):
# """Convert C{obj} into an appropriate L{EnumConstant}.
# """
#
# if obj in list(self.__dict__.values()): # A matching EnumConstant is okay.
# return obj
# elif obj in list(self.__dict__.keys()): # A string is converted to an EnumConstant if possible.
# return self.__dict__[obj]
# else: # Anything else is just wrong.
# raise TypeError("%r is not a valid enum constant here" % obj)
#
# def _add(self, key, value):
# setattr(self, key, EnumConstant(self, key, value))
# self._reverse_dict[value] = getattr(self, key)
#
# def __repr__(self):
# return "Enum(%s)" % ", ".join(map(str, list(self._reverse_dict.values())))
. Output only the next line. | ((int32, 1), _gl.GL_DEPTH_COMPONENT24, (_gl.GL_INT, _gl.GL_DEPTH_COMPONENT)), |
Here is a snippet: <|code_start|>"""Constants and enums.
@todo: Add stencil components to L{texture_formats}.
@author: Stephan Wenger
@date: 2012-02-29
"""
format_to_length = {
#_gl.GL_COLOR_INDEX: 1,
_gl.GL_STENCIL_INDEX: 1,
_gl.GL_DEPTH_COMPONENT: 1,
_gl.GL_RED: 1,
_gl.GL_GREEN: 1,
_gl.GL_BLUE: 1,
_gl.GL_ALPHA: 1,
_gl.GL_RGB: 3,
_gl.GL_BGR: 3,
_gl.GL_RGBA: 4,
_gl.GL_BGRA: 4,
#_gl.GL_LUMINANCE: 1,
#_gl.GL_LUMINANCE_ALPHA: 2,
}
texture_formats = [ # WARNING: In case of ambiguities, the LAST ONE will win.
<|code_end|>
. Write the next line using the current file imports:
import glitter.raw as _gl
from glitter.utils.dtypes import uint8, uint16, uint32, int8, int16, int32, float32
from glitter.utils.enum import Enum
and context from other files:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
#
# Path: glitter/utils/enum.py
# class Enum(object):
# def __init__(self, **kwargs):
# self._reverse_dict = {}
# for key, value in list(kwargs.items()):
# self._add(key, value)
#
# def __getitem__(self, value):
# return self._reverse_dict[value]
#
# def __call__(self, obj):
# """Convert C{obj} into an appropriate L{EnumConstant}.
# """
#
# if obj in list(self.__dict__.values()): # A matching EnumConstant is okay.
# return obj
# elif obj in list(self.__dict__.keys()): # A string is converted to an EnumConstant if possible.
# return self.__dict__[obj]
# else: # Anything else is just wrong.
# raise TypeError("%r is not a valid enum constant here" % obj)
#
# def _add(self, key, value):
# setattr(self, key, EnumConstant(self, key, value))
# self._reverse_dict[value] = getattr(self, key)
#
# def __repr__(self):
# return "Enum(%s)" % ", ".join(map(str, list(self._reverse_dict.values())))
, which may include functions, classes, or code. Output only the next line. | ((float32, 1), _gl.GL_DEPTH_COMPONENT32F, (_gl.GL_FLOAT, _gl.GL_DEPTH_COMPONENT)), |
Based on the snippet: <|code_start|> ((int32, 2), _gl.GL_RG32I, (_gl.GL_INT, _gl.GL_RG_INTEGER )),
((float32, 2), _gl.GL_RG32F, (_gl.GL_FLOAT, _gl.GL_RG )),
((uint8, 3), _gl.GL_RGB8UI, (_gl.GL_UNSIGNED_BYTE, _gl.GL_RGB_INTEGER )),
((int8, 3), _gl.GL_RGB8I, (_gl.GL_BYTE, _gl.GL_RGB_INTEGER )),
((uint16, 3), _gl.GL_RGB16UI, (_gl.GL_UNSIGNED_SHORT, _gl.GL_RGB_INTEGER )),
((int16, 3), _gl.GL_RGB16I, (_gl.GL_SHORT, _gl.GL_RGB_INTEGER )),
((uint32, 3), _gl.GL_RGB32UI, (_gl.GL_UNSIGNED_INT, _gl.GL_RGB_INTEGER )),
((int32, 3), _gl.GL_RGB32I, (_gl.GL_INT, _gl.GL_RGB_INTEGER )),
((float32, 3), _gl.GL_RGB32F, (_gl.GL_FLOAT, _gl.GL_RGB )),
((uint8, 4), _gl.GL_RGBA8UI, (_gl.GL_UNSIGNED_BYTE, _gl.GL_RGBA_INTEGER)),
((int8, 4), _gl.GL_RGBA8I, (_gl.GL_BYTE, _gl.GL_RGBA_INTEGER)),
((uint16, 4), _gl.GL_RGBA16UI, (_gl.GL_UNSIGNED_SHORT, _gl.GL_RGBA_INTEGER)),
((int16, 4), _gl.GL_RGBA16I, (_gl.GL_SHORT, _gl.GL_RGBA_INTEGER)),
((uint32, 4), _gl.GL_RGBA32UI, (_gl.GL_UNSIGNED_INT, _gl.GL_RGBA_INTEGER)),
((int32, 4), _gl.GL_RGBA32I, (_gl.GL_INT, _gl.GL_RGBA_INTEGER)),
((float32, 4), _gl.GL_RGBA32F, (_gl.GL_FLOAT, _gl.GL_RGBA )),
]
"""Mapping between C{numpy} types and OpenGL types.
First column: C{numpy} datatype, number of color channels
Second column: OpenGL internal format
Third column: OpenGL type, OpenGL format
"""
dtype_to_gl_iformat = dict((x[0], x[1] ) for x in texture_formats)
gl_iformat_to_dtype = dict((x[1], x[0] ) for x in texture_formats)
dtype_to_gl_format = dict((x[0], x[2][1]) for x in texture_formats)
gl_format_to_dtype = dict((x[2][1], x[0] ) for x in texture_formats)
gl_iformat_to_gl_type = dict((x[1], x[2][0]) for x in texture_formats)
<|code_end|>
, predict the immediate next line with the help of imports:
import glitter.raw as _gl
from glitter.utils.dtypes import uint8, uint16, uint32, int8, int16, int32, float32
from glitter.utils.enum import Enum
and context (classes, functions, sometimes code) from other files:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
#
# Path: glitter/utils/enum.py
# class Enum(object):
# def __init__(self, **kwargs):
# self._reverse_dict = {}
# for key, value in list(kwargs.items()):
# self._add(key, value)
#
# def __getitem__(self, value):
# return self._reverse_dict[value]
#
# def __call__(self, obj):
# """Convert C{obj} into an appropriate L{EnumConstant}.
# """
#
# if obj in list(self.__dict__.values()): # A matching EnumConstant is okay.
# return obj
# elif obj in list(self.__dict__.keys()): # A string is converted to an EnumConstant if possible.
# return self.__dict__[obj]
# else: # Anything else is just wrong.
# raise TypeError("%r is not a valid enum constant here" % obj)
#
# def _add(self, key, value):
# setattr(self, key, EnumConstant(self, key, value))
# self._reverse_dict[value] = getattr(self, key)
#
# def __repr__(self):
# return "Enum(%s)" % ", ".join(map(str, list(self._reverse_dict.values())))
. Output only the next line. | texture_compare_funcs = Enum( |
Given snippet: <|code_start|> self._setter = setter
self._set_args = set_args
self._dtype = dtype if dtype else int32
self._shape = None if shape is None else tuple(shape) if hasattr(shape, "__iter__") and not isinstance(shape, str) else (shape,)
self._enum = enum
self._name = name
def __get__(self, obj, cls):
_value = _np.empty(self._shape, dtype=self._dtype.as_numpy())
args = list(self._get_args) + [_gl.cast(_value.ctypes, self._getter.argtypes[-1])]
with obj:
self._getter(*args)
value = _value.item() if _value.shape is () else _value
if self._enum is not None:
if hasattr(value, "__iter__") and not isinstance(value, str):
value = [self._enum[x] for x in value]
else:
value = self._enum[value]
return value
def __set__(self, obj, value):
if self._setter is None:
raise AttributeError("can't set attribute")
if self._enum is not None:
if hasattr(value, "__iter__") and not isinstance(value, str):
_value = [self._enum(x)._value for x in value]
else:
_value = self._enum(value)._value
else:
_value = value
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from inspect import getmembers as _getmembers
from glitter.utils.dtypes import coerce_array, int32
from glitter.utils.objects import with_obj
import types as _types
import numpy as _np
import glitter.raw as _gl
import collections
and context:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
#
# Path: glitter/utils/objects.py
# def with_obj(obj, f):
# """Create a wrapper that executes C{f} in a C{with obj:} block."""
# @_wraps(f)
# def wrapper(*args, **kwargs):
# with obj:
# return f(*args, **kwargs)
# return wrapper
which might include code, classes, or functions. Output only the next line. | _value = coerce_array(_value, dtype=self._dtype) |
Continue the code snippet: <|code_start|>"""Base classes for descriptors and descriptor owners.
@bug: L{Proxy} is currently unaware of its context.
@author: Stephan Wenger
@date: 2012-02-29
"""
class Proxy(object):
def __init__(self, getter=None, get_args=(), setter=None, set_args=(), dtype=None, shape=(), enum=None, name=None):
self._getter = getter
self._get_args = get_args
self._setter = setter
self._set_args = set_args
<|code_end|>
. Use current file imports:
from inspect import getmembers as _getmembers
from glitter.utils.dtypes import coerce_array, int32
from glitter.utils.objects import with_obj
import types as _types
import numpy as _np
import glitter.raw as _gl
import collections
and context (classes, functions, or code) from other files:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
#
# Path: glitter/utils/objects.py
# def with_obj(obj, f):
# """Create a wrapper that executes C{f} in a C{with obj:} block."""
# @_wraps(f)
# def wrapper(*args, **kwargs):
# with obj:
# return f(*args, **kwargs)
# return wrapper
. Output only the next line. | self._dtype = dtype if dtype else int32 |
Given the following code snippet before the placeholder: <|code_start|> return getattr(self._obj, self._name)
def __set__(self, obj, value):
setattr(self._obj, self._name, value)
def __delete__(self, obj):
delattr(self._obj, self._name)
class ItemProxy(object):
def __init__(self, obj, idx):
self._obj = obj
self._idx = idx
def __get__(self, obj, cls):
return self._obj[self._idx]
def __set__(self, obj, value):
self._obj[self._idx] = value
def __delete__(self, obj):
del self._obj[self._idx]
def add_proxies(parent, obj):
"""Add proxies for methods and properties of C{obj} to C{parent}."""
# add functions and methods
for key, value in _getmembers(obj):
if key.startswith("_"):
continue
if isinstance(value, (_types.FunctionType, _types.MethodType)):
<|code_end|>
, predict the next line using imports from the current file:
from inspect import getmembers as _getmembers
from glitter.utils.dtypes import coerce_array, int32
from glitter.utils.objects import with_obj
import types as _types
import numpy as _np
import glitter.raw as _gl
import collections
and context including class names, function names, and sometimes code from other files:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
#
# Path: glitter/utils/objects.py
# def with_obj(obj, f):
# """Create a wrapper that executes C{f} in a C{with obj:} block."""
# @_wraps(f)
# def wrapper(*args, **kwargs):
# with obj:
# return f(*args, **kwargs)
# return wrapper
. Output only the next line. | setattr(parent, key, with_obj(parent, value)) |
Given the following code snippet before the placeholder: <|code_start|>"""Datatypes for use with L{ShaderProgram}s.
@author: Stephan Wenger
@date: 2012-02-29
"""
class ShaderDatatype(object):
_gltype_db = {}
_db = {}
def __init__(self, name, _gltype, dtype=int32, shape=1, texture=False, atomic=True):
self._name = name
self._gltype = _gltype
self._dtype = dtype
self._shape = (shape,) if not hasattr(shape, "__iter__") and not isinstance(shape, str) else tuple(shape)
self._texture = texture
self._atomic = atomic
<|code_end|>
, predict the next line using imports from the current file:
import numpy as _np
import glitter.raw as _gl
from glitter.utils.dtypes import Datatype, bool8, int32, uint32, float32, float64
and context including class names, function names, and sometimes code from other files:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
. Output only the next line. | Datatype._gltype_db[self._gltype] = self |
Given the following code snippet before the placeholder: <|code_start|>"""Datatypes for use with L{ShaderProgram}s.
@author: Stephan Wenger
@date: 2012-02-29
"""
class ShaderDatatype(object):
_gltype_db = {}
_db = {}
def __init__(self, name, _gltype, dtype=int32, shape=1, texture=False, atomic=True):
self._name = name
self._gltype = _gltype
self._dtype = dtype
self._shape = (shape,) if not hasattr(shape, "__iter__") and not isinstance(shape, str) else tuple(shape)
self._texture = texture
self._atomic = atomic
Datatype._gltype_db[self._gltype] = self
Datatype._db[self._dtype, self._shape, self._texture, self._atomic] = self
@classmethod
def _from_gl(cls, _gltype):
return Datatype._gltype_db[_gltype]
def get_value(self, program, location):
data = _np.empty(self._shape, int32.as_numpy() if self._dtype.is_boolean() else self._dtype.as_numpy(), order="F")
<|code_end|>
, predict the next line using imports from the current file:
import numpy as _np
import glitter.raw as _gl
from glitter.utils.dtypes import Datatype, bool8, int32, uint32, float32, float64
and context including class names, function names, and sometimes code from other files:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
. Output only the next line. | if self._dtype == int32 or self._dtype == bool8: |
Given snippet: <|code_start|>"""Datatypes for use with L{ShaderProgram}s.
@author: Stephan Wenger
@date: 2012-02-29
"""
class ShaderDatatype(object):
_gltype_db = {}
_db = {}
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import numpy as _np
import glitter.raw as _gl
from glitter.utils.dtypes import Datatype, bool8, int32, uint32, float32, float64
and context:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
which might include code, classes, or functions. Output only the next line. | def __init__(self, name, _gltype, dtype=int32, shape=1, texture=False, atomic=True): |
Predict the next line after this snippet: <|code_start|>
@author: Stephan Wenger
@date: 2012-02-29
"""
class ShaderDatatype(object):
_gltype_db = {}
_db = {}
def __init__(self, name, _gltype, dtype=int32, shape=1, texture=False, atomic=True):
self._name = name
self._gltype = _gltype
self._dtype = dtype
self._shape = (shape,) if not hasattr(shape, "__iter__") and not isinstance(shape, str) else tuple(shape)
self._texture = texture
self._atomic = atomic
Datatype._gltype_db[self._gltype] = self
Datatype._db[self._dtype, self._shape, self._texture, self._atomic] = self
@classmethod
def _from_gl(cls, _gltype):
return Datatype._gltype_db[_gltype]
def get_value(self, program, location):
data = _np.empty(self._shape, int32.as_numpy() if self._dtype.is_boolean() else self._dtype.as_numpy(), order="F")
if self._dtype == int32 or self._dtype == bool8:
_gl.glGetUniformiv(program._id, location, _gl.cast(data.ctypes, _gl.glGetUniformiv.argtypes[-1]))
<|code_end|>
using the current file's imports:
import numpy as _np
import glitter.raw as _gl
from glitter.utils.dtypes import Datatype, bool8, int32, uint32, float32, float64
and any relevant context from other files:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
. Output only the next line. | elif self._dtype == uint32: |
Predict the next line after this snippet: <|code_start|>@date: 2012-02-29
"""
class ShaderDatatype(object):
_gltype_db = {}
_db = {}
def __init__(self, name, _gltype, dtype=int32, shape=1, texture=False, atomic=True):
self._name = name
self._gltype = _gltype
self._dtype = dtype
self._shape = (shape,) if not hasattr(shape, "__iter__") and not isinstance(shape, str) else tuple(shape)
self._texture = texture
self._atomic = atomic
Datatype._gltype_db[self._gltype] = self
Datatype._db[self._dtype, self._shape, self._texture, self._atomic] = self
@classmethod
def _from_gl(cls, _gltype):
return Datatype._gltype_db[_gltype]
def get_value(self, program, location):
data = _np.empty(self._shape, int32.as_numpy() if self._dtype.is_boolean() else self._dtype.as_numpy(), order="F")
if self._dtype == int32 or self._dtype == bool8:
_gl.glGetUniformiv(program._id, location, _gl.cast(data.ctypes, _gl.glGetUniformiv.argtypes[-1]))
elif self._dtype == uint32:
_gl.glGetUniformuiv(program._id, location, _gl.cast(data.ctypes, _gl.glGetUniformuiv.argtypes[-1]))
<|code_end|>
using the current file's imports:
import numpy as _np
import glitter.raw as _gl
from glitter.utils.dtypes import Datatype, bool8, int32, uint32, float32, float64
and any relevant context from other files:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
. Output only the next line. | elif self._dtype == float32: |
Continue the code snippet: <|code_start|>
class ShaderDatatype(object):
_gltype_db = {}
_db = {}
def __init__(self, name, _gltype, dtype=int32, shape=1, texture=False, atomic=True):
self._name = name
self._gltype = _gltype
self._dtype = dtype
self._shape = (shape,) if not hasattr(shape, "__iter__") and not isinstance(shape, str) else tuple(shape)
self._texture = texture
self._atomic = atomic
Datatype._gltype_db[self._gltype] = self
Datatype._db[self._dtype, self._shape, self._texture, self._atomic] = self
@classmethod
def _from_gl(cls, _gltype):
return Datatype._gltype_db[_gltype]
def get_value(self, program, location):
data = _np.empty(self._shape, int32.as_numpy() if self._dtype.is_boolean() else self._dtype.as_numpy(), order="F")
if self._dtype == int32 or self._dtype == bool8:
_gl.glGetUniformiv(program._id, location, _gl.cast(data.ctypes, _gl.glGetUniformiv.argtypes[-1]))
elif self._dtype == uint32:
_gl.glGetUniformuiv(program._id, location, _gl.cast(data.ctypes, _gl.glGetUniformuiv.argtypes[-1]))
elif self._dtype == float32:
_gl.glGetUniformfv(program._id, location, _gl.cast(data.ctypes, _gl.glGetUniformfv.argtypes[-1]))
<|code_end|>
. Use current file imports:
import numpy as _np
import glitter.raw as _gl
from glitter.utils.dtypes import Datatype, bool8, int32, uint32, float32, float64
and context (classes, functions, or code) from other files:
# Path: glitter/utils/dtypes.py
# class Datatype(object):
# def __init__(self, integer, signed, nptype, _gltype=None, charcode=None):
# def from_numpy(cls, nptype):
# def _from_gl(cls, _gltype):
# def as_numpy(self):
# def _as_gl(self):
# def as_signed(self):
# def as_unsigned(self):
# def as_nbytes(self, nbytes):
# def is_signed(self):
# def is_unsigned(self):
# def is_integer(self):
# def is_float(self):
# def is_boolean(self):
# def charcode(self):
# def nbytes(self):
# def __str__(self):
# def __repr__(self):
# def coerced(self, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
# def coerce_array(data, dtype=None, force_integer=False, force_unsigned=False, force_float=False, force_gl=True):
. Output only the next line. | elif self._dtype == float64: |
Given snippet: <|code_start|> fovy = 45.0 * np.pi / 180.0
aspect = self.width / float(self.height)
znear = 0.001
zfar = 1000.0
focal = 1.0 / np.tan(fovy / 2.0)
persp_mat = np.zeros((4, 4))
persp_mat[0, 0] = focal / aspect
persp_mat[1, 1] = focal
persp_mat[2, 2] = (zfar + znear) / (znear - zfar)
persp_mat[2, 3] = 2 * zfar * znear / (znear - zfar)
persp_mat[3, 2] = -1
rot_mat = np.identity(4)
rot_mat[0, :3] = s
rot_mat[1, :3] = u
rot_mat[2, :3] = -f
t_mat = np.identity(4)
t_mat[:3, 3] = -self.position
return np.dot(np.dot(persp_mat, rot_mat), t_mat)
def set_window_size(self, w, h):
self.width = w
self.height = h
def mouse(self, button, state, x, y):
self.old_x = x;
self.old_y = y;
if button == 0 and state == 0:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import numpy as np
from quaternion import Quaternion
from glitter.contexts.glut import get_shift_state
from math import atan2
and context:
# Path: glitter/contexts/glut.py
# def get_shift_state():
# """Only available in keyboard, special, and mouse callbacks."""
# return bool(_gl.glutGetModifiers() & _gl.GLUT_ACTIVE_SHIFT)
which might include code, classes, or functions. Output only the next line. | if get_shift_state(): |
Continue the code snippet: <|code_start|>'''
Created on Jan 4, 2017
@author: lubo
'''
def test_multiplier(model_fixture):
<|code_end|>
. Use current file imports:
import numpy as np
import pytest
from scgv.views.sample import SamplesViewer
and context (classes, functions, or code) from other files:
# Path: scgv/views/sample.py
# class SamplesViewer(ViewerBase):
#
# def __init__(self, model):
# super(SamplesViewer, self).__init__(model)
#
# def calc_chrom_lines(self):
# return self.model.calc_chrom_lines()
#
# def calc_ploidy(self, sample_name):
# return self.model.data\
# .seg_df[sample_name]\
# .iloc[:self.model.chrom_x_index]\
# .mean()
#
# def upto_chrom_x(self, data):
# assert len(data) == len(self.model.data.seg_df)
# return data[0:self.model.chrom_x_index]
#
# def calc_error(self, sample_name):
# if self.model.data.ratio_df is None:
# return np.NaN
# df_r = self.upto_chrom_x(self.model.data.ratio_df[sample_name].values)
# df_s = self.upto_chrom_x(self.model.data.seg_df[sample_name].values)
# return np.sqrt(np.sum(((df_r - df_s) / df_s)**2))
#
# def calc_shredded(self, sample_name):
# upto_x_data = \
# self.model.data \
# .seg_df[sample_name].values[0:self.model.chrom_x_index]
# shredded = np.sum(upto_x_data < 0.4) / float(self.model.chrom_x_index)
# return shredded
#
# def draw_samples(self, fig, sample_list):
# self.chrom_lines = self.calc_chrom_lines()
#
# ax_common = None
# for num, sample_name in enumerate(sample_list):
# if num == 0:
# ax = fig.add_subplot(len(sample_list), 1, num + 1)
# ax_common = ax
# else:
# ax = fig.add_subplot(
# len(sample_list), 1, num + 1,
# sharex=ax_common,
# sharey=ax_common)
#
# for chrom_line in self.chrom_lines:
# ax.axvline(x=chrom_line, color="#000000", linewidth=1)
# for hl in [1, 2, 3, 4, 5, 6]:
# ax.axhline(y=hl, color="#000000", linewidth=1, linestyle="--")
#
# if self.model.data.ratio_df is not None:
# ax.plot(
# self.model.data.ratio_df['abspos'],
# self.model.data.ratio_df[sample_name],
# color="#bbbbbb", alpha=0.8)
# ax.plot(
# self.model.data.seg_df['abspos'],
# self.model.data.seg_df[sample_name],
# color='b', alpha=0.8)
# ax.set_yscale('log')
#
# ax.set_xlim((0, self.model.data.seg_df['abspos'].values[-1]))
# ax.set_ylim((0.05, 20))
#
# ploidy = self.calc_ploidy(sample_name)
# error = self.calc_error(sample_name)
# shredded = self.calc_shredded(sample_name)
#
# ax.set_title(
# "{} Ploidy={:.2f} Error={:.2f} Shredded={:.2f}".format(
# sample_name, ploidy, error, shredded))
#
# ax.set_xticks([])
# ax.set_xticklabels([])
#
# chrom_labels_pos = self.calc_chrom_labels_pos(self.chrom_lines)
# ax.set_xticks(chrom_labels_pos)
# ax.set_xticklabels(self.CHROM_LABELS, rotation='vertical')
# fig.tight_layout()
. Output only the next line. | sample = SamplesViewer(model_fixture) |
Using the snippet: <|code_start|>'''
Created on Dec 21, 2016
@author: lubo
'''
# import pytest
def test_data_model_make_01(example_data):
<|code_end|>
, determine the next line of code. You have imports:
import numpy as np
from scgv.models.model import DataModel # , gate_compare
from scgv.models.featuremat_model import FeaturematModel
and context (class names, function names, or code) available:
# Path: scgv/models/model.py
# class DataModel(BaseModel):
#
# def __init__(self, filename):
# self.data = DataLoader(filename)
# self.data.load()
# self.data.filter_cells()
# self.data.order_cells()
#
# super(DataModel, self).__init__(self.data)
#
# Path: scgv/models/featuremat_model.py
# class FeaturematModel(ModelDelegate):
#
# def __init__(self, model):
# super(FeaturematModel, self).__init__(model)
# assert self.model.data.features_df is not None
# assert self.model.data.featuremat_df is not None
# self.heatmap = self.model.make_featuremat(ordering=self.ordering) + 2.0
. Output only the next line. | model = DataModel(example_data) |
Using the snippet: <|code_start|>'''
Created on Dec 21, 2016
@author: lubo
'''
# import pytest
def test_data_model_make_01(example_data):
model = DataModel(example_data)
assert model is not None
model.make()
sectors_legend = model.make_sectors_legend()
print(sectors_legend)
def test_make_featuremat(example_data):
model = DataModel(example_data)
assert model is not None
model.make()
<|code_end|>
, determine the next line of code. You have imports:
import numpy as np
from scgv.models.model import DataModel # , gate_compare
from scgv.models.featuremat_model import FeaturematModel
and context (class names, function names, or code) available:
# Path: scgv/models/model.py
# class DataModel(BaseModel):
#
# def __init__(self, filename):
# self.data = DataLoader(filename)
# self.data.load()
# self.data.filter_cells()
# self.data.order_cells()
#
# super(DataModel, self).__init__(self.data)
#
# Path: scgv/models/featuremat_model.py
# class FeaturematModel(ModelDelegate):
#
# def __init__(self, model):
# super(FeaturematModel, self).__init__(model)
# assert self.model.data.features_df is not None
# assert self.model.data.featuremat_df is not None
# self.heatmap = self.model.make_featuremat(ordering=self.ordering) + 2.0
. Output only the next line. | featuremat_model = FeaturematModel(model) |
Given the following code snippet before the placeholder: <|code_start|>'''
Created on Dec 2, 2016
@author: lubo
'''
@pytest.fixture
def example_data():
return 'exampledata/example.archive.zip'
@pytest.fixture
def example_dir():
return 'exampledata/example.directory'
@pytest.fixture
def model_fixture(example_data):
<|code_end|>
, predict the next line using imports from the current file:
import pytest
from scgv.models.model import DataModel
and context including class names, function names, and sometimes code from other files:
# Path: scgv/models/model.py
# class DataModel(BaseModel):
#
# def __init__(self, filename):
# self.data = DataLoader(filename)
# self.data.load()
# self.data.filter_cells()
# self.data.order_cells()
#
# super(DataModel, self).__init__(self.data)
. Output only the next line. | model = DataModel(example_data) |
Based on the snippet: <|code_start|> QApplication.setOverrideCursor(Qt.ArrowCursor)
print("UCSC Genome Broser position not found....")
return
QApplication.setOverrideCursor(Qt.ArrowCursor)
chrom_end, pos_end = self.browse_position
chrom_start, pos_start = self.browse_position_start
chrom_start = self.ucsc_chrom(chrom_start)
chrom_end = self.ucsc_chrom(chrom_end)
self.browse_position_region = False
self.browse_position = None
self.browse_position_start = None
if chrom_start != chrom_end:
print("region in different chromosomes")
return
chrom = chrom_start
start = min(pos_start, pos_end)
end = max(pos_start, pos_end)
position = 'chr{}:{}-{}'.format(chrom, start, end)
url = "http://genome.ucsc.edu/cgi-bin/hgTracks?db={}&position={}"\
.format(genome, position)
print('opening url: ', url)
webbrowser.open(url, new=False, autoraise=True)
def draw_canvas(self):
<|code_end|>
, predict the immediate next line with the help of imports:
import webbrowser
import numpy as np
from PyQt5.QtWidgets import QWidget, QVBoxLayout, QApplication
from PyQt5.QtWidgets import QAction, QMenu
from PyQt5.QtCore import Qt
from matplotlib.backends.backend_qt5agg import FigureCanvas, \
NavigationToolbar2QT as NavigationToolbar
from matplotlib.figure import Figure
from scgv.qtviews.base import BaseDialog
from scgv.views.sample import SamplesViewer
and context (classes, functions, sometimes code) from other files:
# Path: scgv/qtviews/base.py
# class BaseDialog(QDialog):
#
# def __init__(self, *args, **kwargs):
# super(BaseDialog, self).__init__(*args, **kwargs)
# # self.setWindowFlags(
# # self.windowFlags() |
# # Qt.CustomizeWindowHint |
# # Qt.WindowMaximizeButtonHint |
# # Qt.WindowType_Mask)
# self.signals = CloseSignals()
# print(self.sizeHint())
# # self.resize(self.sizeHint())
#
# def closeEvent(self, event):
# print("closing window...")
# self.signals.closing.emit()
#
# Path: scgv/views/sample.py
# class SamplesViewer(ViewerBase):
#
# def __init__(self, model):
# super(SamplesViewer, self).__init__(model)
#
# def calc_chrom_lines(self):
# return self.model.calc_chrom_lines()
#
# def calc_ploidy(self, sample_name):
# return self.model.data\
# .seg_df[sample_name]\
# .iloc[:self.model.chrom_x_index]\
# .mean()
#
# def upto_chrom_x(self, data):
# assert len(data) == len(self.model.data.seg_df)
# return data[0:self.model.chrom_x_index]
#
# def calc_error(self, sample_name):
# if self.model.data.ratio_df is None:
# return np.NaN
# df_r = self.upto_chrom_x(self.model.data.ratio_df[sample_name].values)
# df_s = self.upto_chrom_x(self.model.data.seg_df[sample_name].values)
# return np.sqrt(np.sum(((df_r - df_s) / df_s)**2))
#
# def calc_shredded(self, sample_name):
# upto_x_data = \
# self.model.data \
# .seg_df[sample_name].values[0:self.model.chrom_x_index]
# shredded = np.sum(upto_x_data < 0.4) / float(self.model.chrom_x_index)
# return shredded
#
# def draw_samples(self, fig, sample_list):
# self.chrom_lines = self.calc_chrom_lines()
#
# ax_common = None
# for num, sample_name in enumerate(sample_list):
# if num == 0:
# ax = fig.add_subplot(len(sample_list), 1, num + 1)
# ax_common = ax
# else:
# ax = fig.add_subplot(
# len(sample_list), 1, num + 1,
# sharex=ax_common,
# sharey=ax_common)
#
# for chrom_line in self.chrom_lines:
# ax.axvline(x=chrom_line, color="#000000", linewidth=1)
# for hl in [1, 2, 3, 4, 5, 6]:
# ax.axhline(y=hl, color="#000000", linewidth=1, linestyle="--")
#
# if self.model.data.ratio_df is not None:
# ax.plot(
# self.model.data.ratio_df['abspos'],
# self.model.data.ratio_df[sample_name],
# color="#bbbbbb", alpha=0.8)
# ax.plot(
# self.model.data.seg_df['abspos'],
# self.model.data.seg_df[sample_name],
# color='b', alpha=0.8)
# ax.set_yscale('log')
#
# ax.set_xlim((0, self.model.data.seg_df['abspos'].values[-1]))
# ax.set_ylim((0.05, 20))
#
# ploidy = self.calc_ploidy(sample_name)
# error = self.calc_error(sample_name)
# shredded = self.calc_shredded(sample_name)
#
# ax.set_title(
# "{} Ploidy={:.2f} Error={:.2f} Shredded={:.2f}".format(
# sample_name, ploidy, error, shredded))
#
# ax.set_xticks([])
# ax.set_xticklabels([])
#
# chrom_labels_pos = self.calc_chrom_labels_pos(self.chrom_lines)
# ax.set_xticks(chrom_labels_pos)
# ax.set_xticklabels(self.CHROM_LABELS, rotation='vertical')
# fig.tight_layout()
. Output only the next line. | samples_viewer = SamplesViewer(self.model) |
Based on the snippet: <|code_start|>'''
Created on Jan 18, 2017
@author: lubo
'''
def test_data_model_make_01(example_data):
model = DataModel(example_data)
assert model is not None
model.make()
<|code_end|>
, predict the immediate next line with the help of imports:
import numpy as np
from scgv.models.sector_model import SectorsDataModel, SingleSectorDataModel
from scgv.models.model import DataModel
and context (classes, functions, sometimes code) from other files:
# Path: scgv/models/sector_model.py
# class SectorsDataModel(BaseModel):
#
# def __init__(self, model):
# super(SectorsDataModel, self).__init__(model.data)
# self.model = model
# assert self.model.sector is not None
# self.tracks = self.model.tracks
# self.selected_tracks = self.model.selected_tracks
#
# def make_ordering(self):
# index = np.array(self.model.Z['leaves'])
# order = np.arange(len(index))
#
# sector = self.model.sector
# self.sector_mapping = self.model.sector_mapping
#
# res = np.lexsort(
# (
# order,
# sector,
# ))
#
# return index[res]
#
# class SingleSectorDataModel(BaseModel):
#
# def __init__(self, model, sector_id):
# super(SingleSectorDataModel, self).__init__(model.data)
# if isinstance(model, DataModel):
# self.model = model
# else:
# self.model = model.model
# assert self.model.sector is not None
# assert self.model.sector_mapping is not None
#
# self.sector_mapping = self.model.sector_mapping
# self.sector_id = None
#
# if sector_id in self.sector_mapping:
# self.sector_id = sector_id
# else:
# for key, value in self.sector_mapping.items():
# if sector_id == value:
# self.sector_id = key
#
# assert self.sector_id in self.sector_mapping
#
# self.bins, self.samples = self.model.seg_data.shape
# self.lmat = None
# self.selected_tracks = self.model.selected_tracks
# self.tracks = self.model.tracks
#
# def make_ordering(self):
# index = np.array(self.model.Z['leaves'])
# order = np.arange(len(index))
#
# sector = self.model.sector
#
# res = np.lexsort(
# (
# order,
# sector,
# ))
#
# return index[res]
#
# def make_subtree(self):
#
# return get_subtree(
# self.model.lmat[:],
# self.model._original_column_labels(),
# self.column_labels
# )
#
# def make(self):
# self.ordering = self.make_ordering()
# self.sector, self.sector_mapping = \
# self.make_sector(ordering=self.ordering)
#
# sector_val = self.sector_mapping[self.sector_id]
# sector_index = self.sector == sector_val
#
# self.column_labels = self.make_column_labels(ordering=self.ordering)
# self.column_labels = self.column_labels[sector_index]
#
# self.lmat = self.make_subtree()
# self.Z = self.make_dendrogram(self.lmat)
#
# self.samples = len(self.column_labels)
# self.interval_length = self.make_interval_length(self.Z)
# self.label_midpoints = self.make_label_midpoints()
#
# self.bins = self.model.bins
#
# self.clone, self.subclone = self.make_clone(
# ordering=self.ordering)
# if self.clone is not None:
# self.clone = self.clone[sector_index]
# self.subclone = self.subclone[sector_index]
#
# self.heatmap = self.make_heatmap(
# ordering=self.ordering)
# self.heatmap = self.heatmap[:, sector_index]
#
# if self.sector is not None:
# self.sector = self.sector[sector_index]
#
# self.multiplier = self.model.make_multiplier(
# ordering=self.ordering)
# if self.multiplier is not None:
# self.multiplier = self.multiplier[sector_index]
#
# self.error = self.model.make_error(
# ordering=self.ordering)
# if self.error is not None:
# self.error = self.error[sector_index]
#
# self.update_selected_tracks(sector_index)
#
# Path: scgv/models/model.py
# class DataModel(BaseModel):
#
# def __init__(self, filename):
# self.data = DataLoader(filename)
# self.data.load()
# self.data.filter_cells()
# self.data.order_cells()
#
# super(DataModel, self).__init__(self.data)
. Output only the next line. | sector_model = SectorsDataModel(model) |
Continue the code snippet: <|code_start|> print(model.column_labels[m - 1])
assert sector_model.sector[0] == 1
assert sector_model.column_labels[0] == model.column_labels[m]
def test_sector_order_experiments():
elements = np.array([0, 1, 2, 3])
leaves = np.array([3, 1, 2, 0])
sectors = np.array([1, 1, 2, 2])
res = np.lexsort(
(
leaves,
sectors
)
)
print(elements[res])
print(elements[leaves])
assert np.all(elements[res] == np.array([1, 0, 3, 2]))
def test_single_sector_subtree_experiments(example_data):
model = DataModel(example_data)
assert model is not None
model.make()
print(model.sector_mapping)
<|code_end|>
. Use current file imports:
import numpy as np
from scgv.models.sector_model import SectorsDataModel, SingleSectorDataModel
from scgv.models.model import DataModel
and context (classes, functions, or code) from other files:
# Path: scgv/models/sector_model.py
# class SectorsDataModel(BaseModel):
#
# def __init__(self, model):
# super(SectorsDataModel, self).__init__(model.data)
# self.model = model
# assert self.model.sector is not None
# self.tracks = self.model.tracks
# self.selected_tracks = self.model.selected_tracks
#
# def make_ordering(self):
# index = np.array(self.model.Z['leaves'])
# order = np.arange(len(index))
#
# sector = self.model.sector
# self.sector_mapping = self.model.sector_mapping
#
# res = np.lexsort(
# (
# order,
# sector,
# ))
#
# return index[res]
#
# class SingleSectorDataModel(BaseModel):
#
# def __init__(self, model, sector_id):
# super(SingleSectorDataModel, self).__init__(model.data)
# if isinstance(model, DataModel):
# self.model = model
# else:
# self.model = model.model
# assert self.model.sector is not None
# assert self.model.sector_mapping is not None
#
# self.sector_mapping = self.model.sector_mapping
# self.sector_id = None
#
# if sector_id in self.sector_mapping:
# self.sector_id = sector_id
# else:
# for key, value in self.sector_mapping.items():
# if sector_id == value:
# self.sector_id = key
#
# assert self.sector_id in self.sector_mapping
#
# self.bins, self.samples = self.model.seg_data.shape
# self.lmat = None
# self.selected_tracks = self.model.selected_tracks
# self.tracks = self.model.tracks
#
# def make_ordering(self):
# index = np.array(self.model.Z['leaves'])
# order = np.arange(len(index))
#
# sector = self.model.sector
#
# res = np.lexsort(
# (
# order,
# sector,
# ))
#
# return index[res]
#
# def make_subtree(self):
#
# return get_subtree(
# self.model.lmat[:],
# self.model._original_column_labels(),
# self.column_labels
# )
#
# def make(self):
# self.ordering = self.make_ordering()
# self.sector, self.sector_mapping = \
# self.make_sector(ordering=self.ordering)
#
# sector_val = self.sector_mapping[self.sector_id]
# sector_index = self.sector == sector_val
#
# self.column_labels = self.make_column_labels(ordering=self.ordering)
# self.column_labels = self.column_labels[sector_index]
#
# self.lmat = self.make_subtree()
# self.Z = self.make_dendrogram(self.lmat)
#
# self.samples = len(self.column_labels)
# self.interval_length = self.make_interval_length(self.Z)
# self.label_midpoints = self.make_label_midpoints()
#
# self.bins = self.model.bins
#
# self.clone, self.subclone = self.make_clone(
# ordering=self.ordering)
# if self.clone is not None:
# self.clone = self.clone[sector_index]
# self.subclone = self.subclone[sector_index]
#
# self.heatmap = self.make_heatmap(
# ordering=self.ordering)
# self.heatmap = self.heatmap[:, sector_index]
#
# if self.sector is not None:
# self.sector = self.sector[sector_index]
#
# self.multiplier = self.model.make_multiplier(
# ordering=self.ordering)
# if self.multiplier is not None:
# self.multiplier = self.multiplier[sector_index]
#
# self.error = self.model.make_error(
# ordering=self.ordering)
# if self.error is not None:
# self.error = self.error[sector_index]
#
# self.update_selected_tracks(sector_index)
#
# Path: scgv/models/model.py
# class DataModel(BaseModel):
#
# def __init__(self, filename):
# self.data = DataLoader(filename)
# self.data.load()
# self.data.filter_cells()
# self.data.order_cells()
#
# super(DataModel, self).__init__(self.data)
. Output only the next line. | single_sector_model = SingleSectorDataModel(model, 1) |
Next line prediction: <|code_start|>'''
Created on Jan 18, 2017
@author: lubo
'''
def test_data_model_make_01(example_data):
<|code_end|>
. Use current file imports:
(import numpy as np
from scgv.models.sector_model import SectorsDataModel, SingleSectorDataModel
from scgv.models.model import DataModel)
and context including class names, function names, or small code snippets from other files:
# Path: scgv/models/sector_model.py
# class SectorsDataModel(BaseModel):
#
# def __init__(self, model):
# super(SectorsDataModel, self).__init__(model.data)
# self.model = model
# assert self.model.sector is not None
# self.tracks = self.model.tracks
# self.selected_tracks = self.model.selected_tracks
#
# def make_ordering(self):
# index = np.array(self.model.Z['leaves'])
# order = np.arange(len(index))
#
# sector = self.model.sector
# self.sector_mapping = self.model.sector_mapping
#
# res = np.lexsort(
# (
# order,
# sector,
# ))
#
# return index[res]
#
# class SingleSectorDataModel(BaseModel):
#
# def __init__(self, model, sector_id):
# super(SingleSectorDataModel, self).__init__(model.data)
# if isinstance(model, DataModel):
# self.model = model
# else:
# self.model = model.model
# assert self.model.sector is not None
# assert self.model.sector_mapping is not None
#
# self.sector_mapping = self.model.sector_mapping
# self.sector_id = None
#
# if sector_id in self.sector_mapping:
# self.sector_id = sector_id
# else:
# for key, value in self.sector_mapping.items():
# if sector_id == value:
# self.sector_id = key
#
# assert self.sector_id in self.sector_mapping
#
# self.bins, self.samples = self.model.seg_data.shape
# self.lmat = None
# self.selected_tracks = self.model.selected_tracks
# self.tracks = self.model.tracks
#
# def make_ordering(self):
# index = np.array(self.model.Z['leaves'])
# order = np.arange(len(index))
#
# sector = self.model.sector
#
# res = np.lexsort(
# (
# order,
# sector,
# ))
#
# return index[res]
#
# def make_subtree(self):
#
# return get_subtree(
# self.model.lmat[:],
# self.model._original_column_labels(),
# self.column_labels
# )
#
# def make(self):
# self.ordering = self.make_ordering()
# self.sector, self.sector_mapping = \
# self.make_sector(ordering=self.ordering)
#
# sector_val = self.sector_mapping[self.sector_id]
# sector_index = self.sector == sector_val
#
# self.column_labels = self.make_column_labels(ordering=self.ordering)
# self.column_labels = self.column_labels[sector_index]
#
# self.lmat = self.make_subtree()
# self.Z = self.make_dendrogram(self.lmat)
#
# self.samples = len(self.column_labels)
# self.interval_length = self.make_interval_length(self.Z)
# self.label_midpoints = self.make_label_midpoints()
#
# self.bins = self.model.bins
#
# self.clone, self.subclone = self.make_clone(
# ordering=self.ordering)
# if self.clone is not None:
# self.clone = self.clone[sector_index]
# self.subclone = self.subclone[sector_index]
#
# self.heatmap = self.make_heatmap(
# ordering=self.ordering)
# self.heatmap = self.heatmap[:, sector_index]
#
# if self.sector is not None:
# self.sector = self.sector[sector_index]
#
# self.multiplier = self.model.make_multiplier(
# ordering=self.ordering)
# if self.multiplier is not None:
# self.multiplier = self.multiplier[sector_index]
#
# self.error = self.model.make_error(
# ordering=self.ordering)
# if self.error is not None:
# self.error = self.error[sector_index]
#
# self.update_selected_tracks(sector_index)
#
# Path: scgv/models/model.py
# class DataModel(BaseModel):
#
# def __init__(self, filename):
# self.data = DataLoader(filename)
# self.data.load()
# self.data.filter_cells()
# self.data.order_cells()
#
# super(DataModel, self).__init__(self.data)
. Output only the next line. | model = DataModel(example_data) |
Continue the code snippet: <|code_start|>
'''
Change filepath = your data file from ncbi
Change column_num = Column number of data file
'''
filepath = r""
column_num = 0
if not DATABASE_URI.startswith('mysql+pymysql://'):
DATABASE_URI = 'mysql+pymysql://'+DATABASE_URI.split('://')[1]
<|code_end|>
. Use current file imports:
from plugins.dbupload.uploaddb import upload
from plugins.dbupload.dbprofile import *
from config import DATABASE_URI
and context (classes, functions, or code) from other files:
# Path: plugins/dbupload/uploaddb.py
# def upload(DATABASE_URI, path, commit, column_num, cache_size=100000, echo=False, log=False):
# engine = create_engine(DATABASE_URI)
# DBSession = sessionmaker(bind=engine)
# session = DBSession()
#
# # Open file
# if echo:
# line_num = count_lines(path)
# if log:
# try:
# logf = open('log.dat', 'w+')
# except IOError as e:
# print(e, 'can\'t log!')
# log = False
# else:
# logf.write('Log date:' + time.asctime(time.localtime(time.time())) + ' Start.\nFile:' + path + '\n')
#
# try:
# f = open(path, 'r')
# except IOError as e:
# print(e)
# if log:
# logf.write(time.asctime(time.localtime(time.time())) + ':' + e)
# logf.close()
# return -1
# except FileNotFoundError as e:
# print(e)
# if log:
# logf.write(time.asctime(time.localtime(time.time())) + ':' + e)
# logf.close()
# return -2
#
# # Initialize
# num = 0
# flag = False
# while 1:
# res = []
# # cache_size is import for a high speed upload
# for i in range(1, cache_size + 1):
# num += 1
# try:
# line = f.readline()
# except UnicodeDecodeError as e:
# print("In " + path + " row ", num + i, '.', end='')
# print(e)
# if log:
# logf.write(time.asctime(time.localtime(time.time())) + ':' + "In " + path + " row " +
# str(num + i) + '.' + str(e) + '\n')
# continue
# else:
# if not line:
# flag = True
# break
#
# # Filter and append
# if line.startswith('#'):
# continue
# if line == '':
# continue
# temp = line.split('\t')
#
# if len(temp) != column_num:
# print("In " + path + " row ", num, ", data missed or duplicated.")
# if log:
# logf.write(time.asctime(time.localtime(time.time())) + ':' + "In " + path + " row " + str(num)
# + ", data missed or duplicated." + '\n')
# else:
# res.append(temp)
#
# # Commit data
# try:
# commit(engine.execute, res, num)
#
# if echo:
# print_bar(num, line_num)
#
# except ValueError as e:
# print(e)
# if log:
# logf.write(time.asctime(time.localtime(time.time())) + ':' + str(e) + '\n')
# logf.close()
# return -3
# except IntegrityError as e:
# print(e.orig.args)
# if log:
# logf.write(time.asctime(time.localtime(time.time())) + ':' + str(e) + '\n')
# logf.close()
# return -4
# except InvalidRequestError as e:
# print(e)
# if log:
# logf.write(time.asctime(time.localtime(time.time())) + ':' + str(e) + '\n')
# logf.close()
# return -5
#
# if flag:
# break
#
# if log:
# logf.close()
. Output only the next line. | upload(DATABASE_URI, filepath, gene_commit, column_num, cache_size=100000, echo=True, log=True) |
Given the code snippet: <|code_start|>'''
'''
class TestFunctions(unittest.TestCase):
# replace the function:multiply that we import
# if not decorated,the function imported is used
@mock.patch('test_sample.function_as_sample.multiply')
def test_add_and_multiply(self,mock_multiply):
x = 3
y = 5
mock_multiply.return_value = 15
<|code_end|>
, generate the next line using the imports in this file:
from test_sample.function_as_sample import multiply,add_and_multiply
import unittest
import mock
and context (functions, classes, or occasionally code) from other files:
# Path: test_sample/function_as_sample.py
# def multiply(x, y):
#
# return x * y+3
#
# def add_and_multiply(x, y):
#
# addition = x + y
# multiple = multiply(x, y)
#
# return (addition, multiple)
. Output only the next line. | addition, multiple = add_and_multiply(x, y) |
Based on the snippet: <|code_start|>
class PanoDocument(TableBase, PluginDocument):
__tablename__ = 'pano'
def __init__(self, owner, title='Untitled', text=''):
super().__init__()
self.owner = owner
self.title = title
self.text = text
self.description = 'not support description'
text = Column(Text())
created = Column(Integer())
public = Column(Boolean())
comments = Column(Text())
praises = Column(Text())
<|code_end|>
, predict the immediate next line with the help of imports:
from time import time
from plugin import Plugin, PluginDocument
from database import TableBase, Column, Text, Integer, Boolean
from database import engine, session
from .dbupload.dbprofile import Gene
and context (classes, functions, sometimes code) from other files:
# Path: plugin.py
# class Plugin:
# class PluginManager:
# class Documents:
# def __init__(self):
# def user(self):
# def process(self, request):
# def unload(self):
# def __init__(self):
# def load_plugin(self, name, reload=False):
# def get_plugins(self):
# def send_request(self, plugin, request):
# def __init__(self, plugin: Plugin):
# def set_document_type(self, name: str):
# def set_document_table(self, table):
# def get(self, pid):
# def list(self, owner):
# def create(self, pdoc: PluginDocument):
# def update(pdoc: PluginDocument):
# def delete(self, pdoc: PluginDocument):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: plugins/dbupload/dbprofile.py
# class Gene(TableBase):
# __tablename__ = 'allgeneinfo_all'
# tax_id = Column(String(10))
# gene_id = Column(String(10), primary_key=True)
# Symbol = Column(String(64))
# LocusTag = Column(Text)
# Synonyms = Column(Text)
# dbXrefs = Column(Text)
# chromosome = Column(Text)
# map_location = Column(Text)
# description = Column(Text)
# type_of_gene = Column(Text)
# Symbol_from_nomenclature_authority = Column(Text)
# Full_name_from_nomenclature_authority = Column(Text)
# Nomenclature_status = Column(Text)
# Other_designations = Column(Text)
# Modification_date = Column(Date)
. Output only the next line. | class Pano(Plugin): |
Given the following code snippet before the placeholder: <|code_start|>
class PanoDocument(TableBase, PluginDocument):
__tablename__ = 'pano'
def __init__(self, owner, title='Untitled', text=''):
super().__init__()
self.owner = owner
self.title = title
self.text = text
self.description = 'not support description'
<|code_end|>
, predict the next line using imports from the current file:
from time import time
from plugin import Plugin, PluginDocument
from database import TableBase, Column, Text, Integer, Boolean
from database import engine, session
from .dbupload.dbprofile import Gene
and context including class names, function names, and sometimes code from other files:
# Path: plugin.py
# class Plugin:
# class PluginManager:
# class Documents:
# def __init__(self):
# def user(self):
# def process(self, request):
# def unload(self):
# def __init__(self):
# def load_plugin(self, name, reload=False):
# def get_plugins(self):
# def send_request(self, plugin, request):
# def __init__(self, plugin: Plugin):
# def set_document_type(self, name: str):
# def set_document_table(self, table):
# def get(self, pid):
# def list(self, owner):
# def create(self, pdoc: PluginDocument):
# def update(pdoc: PluginDocument):
# def delete(self, pdoc: PluginDocument):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: plugins/dbupload/dbprofile.py
# class Gene(TableBase):
# __tablename__ = 'allgeneinfo_all'
# tax_id = Column(String(10))
# gene_id = Column(String(10), primary_key=True)
# Symbol = Column(String(64))
# LocusTag = Column(Text)
# Synonyms = Column(Text)
# dbXrefs = Column(Text)
# chromosome = Column(Text)
# map_location = Column(Text)
# description = Column(Text)
# type_of_gene = Column(Text)
# Symbol_from_nomenclature_authority = Column(Text)
# Full_name_from_nomenclature_authority = Column(Text)
# Nomenclature_status = Column(Text)
# Other_designations = Column(Text)
# Modification_date = Column(Date)
. Output only the next line. | text = Column(Text()) |
Here is a snippet: <|code_start|>
class PanoDocument(TableBase, PluginDocument):
__tablename__ = 'pano'
def __init__(self, owner, title='Untitled', text=''):
super().__init__()
self.owner = owner
self.title = title
self.text = text
self.description = 'not support description'
<|code_end|>
. Write the next line using the current file imports:
from time import time
from plugin import Plugin, PluginDocument
from database import TableBase, Column, Text, Integer, Boolean
from database import engine, session
from .dbupload.dbprofile import Gene
and context from other files:
# Path: plugin.py
# class Plugin:
# class PluginManager:
# class Documents:
# def __init__(self):
# def user(self):
# def process(self, request):
# def unload(self):
# def __init__(self):
# def load_plugin(self, name, reload=False):
# def get_plugins(self):
# def send_request(self, plugin, request):
# def __init__(self, plugin: Plugin):
# def set_document_type(self, name: str):
# def set_document_table(self, table):
# def get(self, pid):
# def list(self, owner):
# def create(self, pdoc: PluginDocument):
# def update(pdoc: PluginDocument):
# def delete(self, pdoc: PluginDocument):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: plugins/dbupload/dbprofile.py
# class Gene(TableBase):
# __tablename__ = 'allgeneinfo_all'
# tax_id = Column(String(10))
# gene_id = Column(String(10), primary_key=True)
# Symbol = Column(String(64))
# LocusTag = Column(Text)
# Synonyms = Column(Text)
# dbXrefs = Column(Text)
# chromosome = Column(Text)
# map_location = Column(Text)
# description = Column(Text)
# type_of_gene = Column(Text)
# Symbol_from_nomenclature_authority = Column(Text)
# Full_name_from_nomenclature_authority = Column(Text)
# Nomenclature_status = Column(Text)
# Other_designations = Column(Text)
# Modification_date = Column(Date)
, which may include functions, classes, or code. Output only the next line. | text = Column(Text()) |
Here is a snippet: <|code_start|>
class PanoDocument(TableBase, PluginDocument):
__tablename__ = 'pano'
def __init__(self, owner, title='Untitled', text=''):
super().__init__()
self.owner = owner
self.title = title
self.text = text
self.description = 'not support description'
text = Column(Text())
<|code_end|>
. Write the next line using the current file imports:
from time import time
from plugin import Plugin, PluginDocument
from database import TableBase, Column, Text, Integer, Boolean
from database import engine, session
from .dbupload.dbprofile import Gene
and context from other files:
# Path: plugin.py
# class Plugin:
# class PluginManager:
# class Documents:
# def __init__(self):
# def user(self):
# def process(self, request):
# def unload(self):
# def __init__(self):
# def load_plugin(self, name, reload=False):
# def get_plugins(self):
# def send_request(self, plugin, request):
# def __init__(self, plugin: Plugin):
# def set_document_type(self, name: str):
# def set_document_table(self, table):
# def get(self, pid):
# def list(self, owner):
# def create(self, pdoc: PluginDocument):
# def update(pdoc: PluginDocument):
# def delete(self, pdoc: PluginDocument):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: plugins/dbupload/dbprofile.py
# class Gene(TableBase):
# __tablename__ = 'allgeneinfo_all'
# tax_id = Column(String(10))
# gene_id = Column(String(10), primary_key=True)
# Symbol = Column(String(64))
# LocusTag = Column(Text)
# Synonyms = Column(Text)
# dbXrefs = Column(Text)
# chromosome = Column(Text)
# map_location = Column(Text)
# description = Column(Text)
# type_of_gene = Column(Text)
# Symbol_from_nomenclature_authority = Column(Text)
# Full_name_from_nomenclature_authority = Column(Text)
# Nomenclature_status = Column(Text)
# Other_designations = Column(Text)
# Modification_date = Column(Date)
, which may include functions, classes, or code. Output only the next line. | created = Column(Integer()) |
Given the code snippet: <|code_start|>
class PanoDocument(TableBase, PluginDocument):
__tablename__ = 'pano'
def __init__(self, owner, title='Untitled', text=''):
super().__init__()
self.owner = owner
self.title = title
self.text = text
self.description = 'not support description'
text = Column(Text())
created = Column(Integer())
<|code_end|>
, generate the next line using the imports in this file:
from time import time
from plugin import Plugin, PluginDocument
from database import TableBase, Column, Text, Integer, Boolean
from database import engine, session
from .dbupload.dbprofile import Gene
and context (functions, classes, or occasionally code) from other files:
# Path: plugin.py
# class Plugin:
# class PluginManager:
# class Documents:
# def __init__(self):
# def user(self):
# def process(self, request):
# def unload(self):
# def __init__(self):
# def load_plugin(self, name, reload=False):
# def get_plugins(self):
# def send_request(self, plugin, request):
# def __init__(self, plugin: Plugin):
# def set_document_type(self, name: str):
# def set_document_table(self, table):
# def get(self, pid):
# def list(self, owner):
# def create(self, pdoc: PluginDocument):
# def update(pdoc: PluginDocument):
# def delete(self, pdoc: PluginDocument):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: plugins/dbupload/dbprofile.py
# class Gene(TableBase):
# __tablename__ = 'allgeneinfo_all'
# tax_id = Column(String(10))
# gene_id = Column(String(10), primary_key=True)
# Symbol = Column(String(64))
# LocusTag = Column(Text)
# Synonyms = Column(Text)
# dbXrefs = Column(Text)
# chromosome = Column(Text)
# map_location = Column(Text)
# description = Column(Text)
# type_of_gene = Column(Text)
# Symbol_from_nomenclature_authority = Column(Text)
# Full_name_from_nomenclature_authority = Column(Text)
# Nomenclature_status = Column(Text)
# Other_designations = Column(Text)
# Modification_date = Column(Date)
. Output only the next line. | public = Column(Boolean()) |
Using the snippet: <|code_start|>
class PanoDocument(TableBase, PluginDocument):
__tablename__ = 'pano'
def __init__(self, owner, title='Untitled', text=''):
super().__init__()
self.owner = owner
self.title = title
self.text = text
self.description = 'not support description'
text = Column(Text())
created = Column(Integer())
public = Column(Boolean())
comments = Column(Text())
praises = Column(Text())
class Pano(Plugin):
def __init__(self):
super().__init__()
self.documents.set_document_type('pano')
self.documents.set_document_table(PanoDocument)
self.name = 'biobrick_manager'
try:
<|code_end|>
, determine the next line of code. You have imports:
from time import time
from plugin import Plugin, PluginDocument
from database import TableBase, Column, Text, Integer, Boolean
from database import engine, session
from .dbupload.dbprofile import Gene
and context (class names, function names, or code) available:
# Path: plugin.py
# class Plugin:
# class PluginManager:
# class Documents:
# def __init__(self):
# def user(self):
# def process(self, request):
# def unload(self):
# def __init__(self):
# def load_plugin(self, name, reload=False):
# def get_plugins(self):
# def send_request(self, plugin, request):
# def __init__(self, plugin: Plugin):
# def set_document_type(self, name: str):
# def set_document_table(self, table):
# def get(self, pid):
# def list(self, owner):
# def create(self, pdoc: PluginDocument):
# def update(pdoc: PluginDocument):
# def delete(self, pdoc: PluginDocument):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: plugins/dbupload/dbprofile.py
# class Gene(TableBase):
# __tablename__ = 'allgeneinfo_all'
# tax_id = Column(String(10))
# gene_id = Column(String(10), primary_key=True)
# Symbol = Column(String(64))
# LocusTag = Column(Text)
# Synonyms = Column(Text)
# dbXrefs = Column(Text)
# chromosome = Column(Text)
# map_location = Column(Text)
# description = Column(Text)
# type_of_gene = Column(Text)
# Symbol_from_nomenclature_authority = Column(Text)
# Full_name_from_nomenclature_authority = Column(Text)
# Nomenclature_status = Column(Text)
# Other_designations = Column(Text)
# Modification_date = Column(Date)
. Output only the next line. | PanoDocument.__table__.create(engine) |
Given snippet: <|code_start|>
def list(self, **kwargs):
docs = self.documents.list(self.user.id)
return dict(ids=list(map(lambda x:x.id, docs)))
def load(self, id, **kwargs):
id = int(id)
doc = self.documents.get(id)
if not (doc and (doc.owner == self.user.id or doc.public)):
raise ValueError('Document %d does not exists.' % id)
return dict(data=doc.text, title=doc.title, owner=doc.owner, ctime=doc.created, mtime=doc.last_modified,
public=doc.public, comments=eval(doc.comments), praises=len(eval(doc.praises)), img=doc.description)
def delete(self, id, **kwargs):
id = int(id)
doc = self.documents.get(id)
if not (doc and doc.owner == self.user.id):
raise ValueError('Document %d does not exists.' % id)
self.documents.delete(doc)
return {}
def get_event_data(self, **kwargs):
events = []
'''
for i in session.query(PanoDocument).filter(PanoDocument.created > time()-7*24*3600).all():
if(i.public):
events.append(dict(project_id=i.id, user_id=i.owner, time=i.created, img_src=i.description, state='Create',
project_name=i.title, last_update_time=i.last_modified, praise=self.user.id in eval(i.praises),
comment=eval(i.comments)))
'''
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from time import time
from plugin import Plugin, PluginDocument
from database import TableBase, Column, Text, Integer, Boolean
from database import engine, session
from .dbupload.dbprofile import Gene
and context:
# Path: plugin.py
# class Plugin:
# class PluginManager:
# class Documents:
# def __init__(self):
# def user(self):
# def process(self, request):
# def unload(self):
# def __init__(self):
# def load_plugin(self, name, reload=False):
# def get_plugins(self):
# def send_request(self, plugin, request):
# def __init__(self, plugin: Plugin):
# def set_document_type(self, name: str):
# def set_document_table(self, table):
# def get(self, pid):
# def list(self, owner):
# def create(self, pdoc: PluginDocument):
# def update(pdoc: PluginDocument):
# def delete(self, pdoc: PluginDocument):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: plugins/dbupload/dbprofile.py
# class Gene(TableBase):
# __tablename__ = 'allgeneinfo_all'
# tax_id = Column(String(10))
# gene_id = Column(String(10), primary_key=True)
# Symbol = Column(String(64))
# LocusTag = Column(Text)
# Synonyms = Column(Text)
# dbXrefs = Column(Text)
# chromosome = Column(Text)
# map_location = Column(Text)
# description = Column(Text)
# type_of_gene = Column(Text)
# Symbol_from_nomenclature_authority = Column(Text)
# Full_name_from_nomenclature_authority = Column(Text)
# Nomenclature_status = Column(Text)
# Other_designations = Column(Text)
# Modification_date = Column(Date)
which might include code, classes, or functions. Output only the next line. | for i in session.query(PanoDocument).filter(PanoDocument.last_modified > time()-7*24*3600).all(): |
Continue the code snippet: <|code_start|> doc.comments = repr(comments)
self.documents.update(doc)
return {}
def submit_praise(self, modify, event_id, **kwargs):
modify = modify=='true' if type(modify) is str else bool(modify)
id = int(event_id)
doc = self.documents.get(id)
if not (doc and (doc.owner == self.user.id or doc.public)):
raise ValueError('Document %d does not exists.' % id)
praises = eval(doc.praises)
praises.discard(self.user.id)
if modify:
praises.add(self.user.id)
doc.praises = repr(praises)
self.documents.update(doc)
return {}
def get_project_data(self, **kwargs):
events = []
for i in self.documents.list(self.user.id):
events.append(dict(project_id=i.id, user_id=i.owner, time=i.created, img_src=i.description, public=i.public,
project_name=i.title, last_update_time=i.last_modified, praise=self.user.id in eval(i.praises),
comment=eval(i.comments)))
return dict(project=events)
def match_node(self, s, **kwargs):
suggest = {'nodes':[]}
<|code_end|>
. Use current file imports:
from time import time
from plugin import Plugin, PluginDocument
from database import TableBase, Column, Text, Integer, Boolean
from database import engine, session
from .dbupload.dbprofile import Gene
and context (classes, functions, or code) from other files:
# Path: plugin.py
# class Plugin:
# class PluginManager:
# class Documents:
# def __init__(self):
# def user(self):
# def process(self, request):
# def unload(self):
# def __init__(self):
# def load_plugin(self, name, reload=False):
# def get_plugins(self):
# def send_request(self, plugin, request):
# def __init__(self, plugin: Plugin):
# def set_document_type(self, name: str):
# def set_document_table(self, table):
# def get(self, pid):
# def list(self, owner):
# def create(self, pdoc: PluginDocument):
# def update(pdoc: PluginDocument):
# def delete(self, pdoc: PluginDocument):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: plugins/dbupload/dbprofile.py
# class Gene(TableBase):
# __tablename__ = 'allgeneinfo_all'
# tax_id = Column(String(10))
# gene_id = Column(String(10), primary_key=True)
# Symbol = Column(String(64))
# LocusTag = Column(Text)
# Synonyms = Column(Text)
# dbXrefs = Column(Text)
# chromosome = Column(Text)
# map_location = Column(Text)
# description = Column(Text)
# type_of_gene = Column(Text)
# Symbol_from_nomenclature_authority = Column(Text)
# Full_name_from_nomenclature_authority = Column(Text)
# Nomenclature_status = Column(Text)
# Other_designations = Column(Text)
# Modification_date = Column(Date)
. Output only the next line. | for res in session.query(Gene).filter(Gene.gene_id == s): |
Predict the next line for this snippet: <|code_start|>
class user_model(Plugin):
def __init__(self):
super().__init__()
print('user_model plugin loaded')
self.name = 'user_model'
def process(self, request):
if request['action'] == 'validate_login':
print('Login: ', request['email'], request['password'])
email = request['email']
password = request['password']
user = User.get_user_by_email(email)
if not user:
return {'success': False, 'error': 'Email not found'}
elif not user.check_password(password):
return {'success': False, 'error': 'Email or password incorrect'}
else:
login_user(user, remember='remember' in request)
return {'success': True}
elif request['action'] == 'create_user':
print('Create: ', request['email'], request['password'], request['username'])
email = request['email']
password = request['password']
username = request['username']
if User.get_user_by_email(email):
return {'success': False, 'error': 'Email already exists'}
user = User(email, password, username)
<|code_end|>
with the help of current file imports:
from plugin import Plugin
from database import TableBase, Column, Text
from database import engine, session
from flask_login import current_user, login_required, login_user, logout_user
from models import User
from plugins.pano import __plugin__ as pano
and context from other files:
# Path: plugin.py
# class Plugin:
# def __init__(self):
# self.documents = Documents(self)
# try: self.name
# except: self.name = self.__class__.__name__.lower()
# try: self.description
# except: self.description = 'This plugin has no description.'
# if self.__class__ is Plugin:
# raise NotImplementedError
#
# @property
# def user(self):
# return app.current_user
#
# def process(self, request):
# pass
#
# def unload(self):
# pass
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: models/user.py
# class User(TableBase, UserMixin):
# """A user."""
#
# __tablename__ = 'user'
# id = Column(Integer, primary_key=True)
# email = Column(String(63), unique=True)
# passwordhash = Column(String(127), nullable=False)
# salt = Column(String(127), nullable=False)
# username = Column(String(127))
# if os.getenv('FLASK_TESTING'):
# avatar = Column(String(16777215))
# else:
# avatar = Column(MEDIUMTEXT())
# description = Column(Text())
# education = Column(Text())
# major = Column(Text())
#
# def __init__(self, email, password, username):
# self.email = email
# self.set_password(password)
# self.username = username
#
# def set_password(self, password):
# """hash and save the password"""
# self.salt = random_string(10)
# s = hashlib.sha256()
# s.update(password.encode('utf-8'))
# s.update(self.salt.encode('utf-8'))
# self.passwordhash = s.hexdigest()
#
# def check_password(self, password):
# """hash and check the password"""
# s = hashlib.sha256()
# s.update(password.encode('utf-8'))
# s.update(self.salt.encode('utf-8'))
# return self.passwordhash == s.hexdigest()
#
# @classmethod
# def get_user_by_email(cls, email):
# return session.query(cls).filter_by(email=email).first()
#
# @classmethod
# def get_user_by_id(cls, id):
# return session.query(cls).get(id)
#
# Path: plugins/pano.py
# class PanoDocument(TableBase, PluginDocument):
# class Pano(Plugin):
# def __init__(self, owner, title='Untitled', text=''):
# def __init__(self):
# def process(self, request):
# def new(self, title, data, public, img, **kwargs):
# def save(self, id, title, data, img, **kwargs):
# def list(self, **kwargs):
# def load(self, id, **kwargs):
# def delete(self, id, **kwargs):
# def get_event_data(self, **kwargs):
# def submit_comment(self, comment, event_id, **kwargs):
# def submit_praise(self, modify, event_id, **kwargs):
# def get_project_data(self, **kwargs):
# def match_node(self, s, **kwargs):
, which may contain function names, class names, or code. Output only the next line. | session.add(user) |
Given the following code snippet before the placeholder: <|code_start|>
class user_model(Plugin):
def __init__(self):
super().__init__()
print('user_model plugin loaded')
self.name = 'user_model'
def process(self, request):
if request['action'] == 'validate_login':
print('Login: ', request['email'], request['password'])
email = request['email']
password = request['password']
<|code_end|>
, predict the next line using imports from the current file:
from plugin import Plugin
from database import TableBase, Column, Text
from database import engine, session
from flask_login import current_user, login_required, login_user, logout_user
from models import User
from plugins.pano import __plugin__ as pano
and context including class names, function names, and sometimes code from other files:
# Path: plugin.py
# class Plugin:
# def __init__(self):
# self.documents = Documents(self)
# try: self.name
# except: self.name = self.__class__.__name__.lower()
# try: self.description
# except: self.description = 'This plugin has no description.'
# if self.__class__ is Plugin:
# raise NotImplementedError
#
# @property
# def user(self):
# return app.current_user
#
# def process(self, request):
# pass
#
# def unload(self):
# pass
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: models/user.py
# class User(TableBase, UserMixin):
# """A user."""
#
# __tablename__ = 'user'
# id = Column(Integer, primary_key=True)
# email = Column(String(63), unique=True)
# passwordhash = Column(String(127), nullable=False)
# salt = Column(String(127), nullable=False)
# username = Column(String(127))
# if os.getenv('FLASK_TESTING'):
# avatar = Column(String(16777215))
# else:
# avatar = Column(MEDIUMTEXT())
# description = Column(Text())
# education = Column(Text())
# major = Column(Text())
#
# def __init__(self, email, password, username):
# self.email = email
# self.set_password(password)
# self.username = username
#
# def set_password(self, password):
# """hash and save the password"""
# self.salt = random_string(10)
# s = hashlib.sha256()
# s.update(password.encode('utf-8'))
# s.update(self.salt.encode('utf-8'))
# self.passwordhash = s.hexdigest()
#
# def check_password(self, password):
# """hash and check the password"""
# s = hashlib.sha256()
# s.update(password.encode('utf-8'))
# s.update(self.salt.encode('utf-8'))
# return self.passwordhash == s.hexdigest()
#
# @classmethod
# def get_user_by_email(cls, email):
# return session.query(cls).filter_by(email=email).first()
#
# @classmethod
# def get_user_by_id(cls, id):
# return session.query(cls).get(id)
#
# Path: plugins/pano.py
# class PanoDocument(TableBase, PluginDocument):
# class Pano(Plugin):
# def __init__(self, owner, title='Untitled', text=''):
# def __init__(self):
# def process(self, request):
# def new(self, title, data, public, img, **kwargs):
# def save(self, id, title, data, img, **kwargs):
# def list(self, **kwargs):
# def load(self, id, **kwargs):
# def delete(self, id, **kwargs):
# def get_event_data(self, **kwargs):
# def submit_comment(self, comment, event_id, **kwargs):
# def submit_praise(self, modify, event_id, **kwargs):
# def get_project_data(self, **kwargs):
# def match_node(self, s, **kwargs):
. Output only the next line. | user = User.get_user_by_email(email) |
Given the code snippet: <|code_start|>"""This is an example plugin for BioHub. It manages all text files, and print some debug messages."""
class TextFileDocument(TableBase, PluginDocument):
__tablename__ = 'textfile'
def __init__(self, owner, title='Untitled', text=''):
super().__init__()
self.owner = owner
self.title = title
self.text = text
self.description = 'not support description'
text = Column(Text())
<|code_end|>
, generate the next line using the imports in this file:
from plugin import Plugin, PluginDocument
from database import TableBase, Column, Text
from database import engine
and context (functions, classes, or occasionally code) from other files:
# Path: plugin.py
# class Plugin:
# class PluginManager:
# class Documents:
# def __init__(self):
# def user(self):
# def process(self, request):
# def unload(self):
# def __init__(self):
# def load_plugin(self, name, reload=False):
# def get_plugins(self):
# def send_request(self, plugin, request):
# def __init__(self, plugin: Plugin):
# def set_document_type(self, name: str):
# def set_document_table(self, table):
# def get(self, pid):
# def list(self, owner):
# def create(self, pdoc: PluginDocument):
# def update(pdoc: PluginDocument):
# def delete(self, pdoc: PluginDocument):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | class TextFile(Plugin): |
Predict the next line after this snippet: <|code_start|>"""This is an example plugin for BioHub. It manages all text files, and print some debug messages."""
class TextFileDocument(TableBase, PluginDocument):
__tablename__ = 'textfile'
def __init__(self, owner, title='Untitled', text=''):
super().__init__()
self.owner = owner
self.title = title
self.text = text
self.description = 'not support description'
<|code_end|>
using the current file's imports:
from plugin import Plugin, PluginDocument
from database import TableBase, Column, Text
from database import engine
and any relevant context from other files:
# Path: plugin.py
# class Plugin:
# class PluginManager:
# class Documents:
# def __init__(self):
# def user(self):
# def process(self, request):
# def unload(self):
# def __init__(self):
# def load_plugin(self, name, reload=False):
# def get_plugins(self):
# def send_request(self, plugin, request):
# def __init__(self, plugin: Plugin):
# def set_document_type(self, name: str):
# def set_document_table(self, table):
# def get(self, pid):
# def list(self, owner):
# def create(self, pdoc: PluginDocument):
# def update(pdoc: PluginDocument):
# def delete(self, pdoc: PluginDocument):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | text = Column(Text()) |
Using the snippet: <|code_start|>"""This is an example plugin for BioHub. It manages all text files, and print some debug messages."""
class TextFileDocument(TableBase, PluginDocument):
__tablename__ = 'textfile'
def __init__(self, owner, title='Untitled', text=''):
super().__init__()
self.owner = owner
self.title = title
self.text = text
self.description = 'not support description'
<|code_end|>
, determine the next line of code. You have imports:
from plugin import Plugin, PluginDocument
from database import TableBase, Column, Text
from database import engine
and context (class names, function names, or code) available:
# Path: plugin.py
# class Plugin:
# class PluginManager:
# class Documents:
# def __init__(self):
# def user(self):
# def process(self, request):
# def unload(self):
# def __init__(self):
# def load_plugin(self, name, reload=False):
# def get_plugins(self):
# def send_request(self, plugin, request):
# def __init__(self, plugin: Plugin):
# def set_document_type(self, name: str):
# def set_document_table(self, table):
# def get(self, pid):
# def list(self, owner):
# def create(self, pdoc: PluginDocument):
# def update(pdoc: PluginDocument):
# def delete(self, pdoc: PluginDocument):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | text = Column(Text()) |
Based on the snippet: <|code_start|>"""This is an example plugin for BioHub. It manages all text files, and print some debug messages."""
class TextFileDocument(TableBase, PluginDocument):
__tablename__ = 'textfile'
def __init__(self, owner, title='Untitled', text=''):
super().__init__()
self.owner = owner
self.title = title
self.text = text
self.description = 'not support description'
text = Column(Text())
class TextFile(Plugin):
def __init__(self):
super().__init__()
print('example plugin loaded')
self.documents.set_document_type('text')
self.documents.set_document_table(TextFileDocument)
self.name = 'example_plugin'
try:
<|code_end|>
, predict the immediate next line with the help of imports:
from plugin import Plugin, PluginDocument
from database import TableBase, Column, Text
from database import engine
and context (classes, functions, sometimes code) from other files:
# Path: plugin.py
# class Plugin:
# class PluginManager:
# class Documents:
# def __init__(self):
# def user(self):
# def process(self, request):
# def unload(self):
# def __init__(self):
# def load_plugin(self, name, reload=False):
# def get_plugins(self):
# def send_request(self, plugin, request):
# def __init__(self, plugin: Plugin):
# def set_document_type(self, name: str):
# def set_document_table(self, table):
# def get(self, pid):
# def list(self, owner):
# def create(self, pdoc: PluginDocument):
# def update(pdoc: PluginDocument):
# def delete(self, pdoc: PluginDocument):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | TextFileDocument.__table__.create(engine) |
Given the code snippet: <|code_start|>
SPFA_time = datetime.now()
time_point["SPFA"] = SPFA_time - convert_time
path_list = []
for j in Astar(s, t, k):
# not founded
if j == -1:
break
# overtime
if j == 0:
break
path = []
for node in j:
result = {"id": search_pool[node]}
object_node = data['node'][result["id"]]
result["NAME"] = object_node["NAME"]
result["TYPE"] = object_node["TYPE"]
path.append(result)
del result
# path.append(db.node.find_one({"_id": search_dict[node]})["NAME"])
path_list.append(path)
Astar_time = datetime.now()
time_point["Astar"] = Astar_time - SPFA_time
return {'paths': path_list}
<|code_end|>
, generate the next line using the imports in this file:
from queue import PriorityQueue, Queue
from datetime import *
from plugin import Plugin
import json
and context (functions, classes, or occasionally code) from other files:
# Path: plugin.py
# class Plugin:
# def __init__(self):
# self.documents = Documents(self)
# try: self.name
# except: self.name = self.__class__.__name__.lower()
# try: self.description
# except: self.description = 'This plugin has no description.'
# if self.__class__ is Plugin:
# raise NotImplementedError
#
# @property
# def user(self):
# return app.current_user
#
# def process(self, request):
# pass
#
# def unload(self):
# pass
. Output only the next line. | class Path_Finder_New(Plugin): |
Predict the next line for this snippet: <|code_start|>
home = Blueprint('home', __name__)
@home.route('/')
def index():
if current_user.is_authenticated:
return redirect(url_for('static', filename='projects.html'))
return redirect(url_for('static', filename='login.html'))
@home.route('/validateLogin', methods=['POST'])
def login():
username = request.values['username']
password = request.values['password']
return username
@home.route('/login/<int:id>')
def login_test(id):
<|code_end|>
with the help of current file imports:
from flask import Blueprint, redirect, url_for, request
from flask_login import current_user, login_required, login_user, logout_user
from models import User
from database import session
and context from other files:
# Path: models/user.py
# class User(TableBase, UserMixin):
# """A user."""
#
# __tablename__ = 'user'
# id = Column(Integer, primary_key=True)
# email = Column(String(63), unique=True)
# passwordhash = Column(String(127), nullable=False)
# salt = Column(String(127), nullable=False)
# username = Column(String(127))
# if os.getenv('FLASK_TESTING'):
# avatar = Column(String(16777215))
# else:
# avatar = Column(MEDIUMTEXT())
# description = Column(Text())
# education = Column(Text())
# major = Column(Text())
#
# def __init__(self, email, password, username):
# self.email = email
# self.set_password(password)
# self.username = username
#
# def set_password(self, password):
# """hash and save the password"""
# self.salt = random_string(10)
# s = hashlib.sha256()
# s.update(password.encode('utf-8'))
# s.update(self.salt.encode('utf-8'))
# self.passwordhash = s.hexdigest()
#
# def check_password(self, password):
# """hash and check the password"""
# s = hashlib.sha256()
# s.update(password.encode('utf-8'))
# s.update(self.salt.encode('utf-8'))
# return self.passwordhash == s.hexdigest()
#
# @classmethod
# def get_user_by_email(cls, email):
# return session.query(cls).filter_by(email=email).first()
#
# @classmethod
# def get_user_by_id(cls, id):
# return session.query(cls).get(id)
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
, which may contain function names, class names, or code. Output only the next line. | login_user(session.query(User).get(id)) |
Continue the code snippet: <|code_start|>
home = Blueprint('home', __name__)
@home.route('/')
def index():
if current_user.is_authenticated:
return redirect(url_for('static', filename='projects.html'))
return redirect(url_for('static', filename='login.html'))
@home.route('/validateLogin', methods=['POST'])
def login():
username = request.values['username']
password = request.values['password']
return username
@home.route('/login/<int:id>')
def login_test(id):
<|code_end|>
. Use current file imports:
from flask import Blueprint, redirect, url_for, request
from flask_login import current_user, login_required, login_user, logout_user
from models import User
from database import session
and context (classes, functions, or code) from other files:
# Path: models/user.py
# class User(TableBase, UserMixin):
# """A user."""
#
# __tablename__ = 'user'
# id = Column(Integer, primary_key=True)
# email = Column(String(63), unique=True)
# passwordhash = Column(String(127), nullable=False)
# salt = Column(String(127), nullable=False)
# username = Column(String(127))
# if os.getenv('FLASK_TESTING'):
# avatar = Column(String(16777215))
# else:
# avatar = Column(MEDIUMTEXT())
# description = Column(Text())
# education = Column(Text())
# major = Column(Text())
#
# def __init__(self, email, password, username):
# self.email = email
# self.set_password(password)
# self.username = username
#
# def set_password(self, password):
# """hash and save the password"""
# self.salt = random_string(10)
# s = hashlib.sha256()
# s.update(password.encode('utf-8'))
# s.update(self.salt.encode('utf-8'))
# self.passwordhash = s.hexdigest()
#
# def check_password(self, password):
# """hash and check the password"""
# s = hashlib.sha256()
# s.update(password.encode('utf-8'))
# s.update(self.salt.encode('utf-8'))
# return self.passwordhash == s.hexdigest()
#
# @classmethod
# def get_user_by_email(cls, email):
# return session.query(cls).filter_by(email=email).first()
#
# @classmethod
# def get_user_by_id(cls, id):
# return session.query(cls).get(id)
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | login_user(session.query(User).get(id)) |
Predict the next line for this snippet: <|code_start|>
class PluginDocument(object):
"""Abstract class for all plugins to make their own document type."""
def __init__(self):
super().__init__()
if self.__class__ is PluginDocument:
raise NotImplementedError
<|code_end|>
with the help of current file imports:
from sqlalchemy.ext.declarative import declared_attr
from database import Column, Integer, String, ForeignKey, Text
and context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
, which may contain function names, class names, or code. Output only the next line. | id = Column(Integer(), primary_key=True) |
Based on the snippet: <|code_start|>
class PluginDocument(object):
"""Abstract class for all plugins to make their own document type."""
def __init__(self):
super().__init__()
if self.__class__ is PluginDocument:
raise NotImplementedError
<|code_end|>
, predict the immediate next line with the help of imports:
from sqlalchemy.ext.declarative import declared_attr
from database import Column, Integer, String, ForeignKey, Text
and context (classes, functions, sometimes code) from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | id = Column(Integer(), primary_key=True) |
Given snippet: <|code_start|>
class PluginDocument(object):
"""Abstract class for all plugins to make their own document type."""
def __init__(self):
super().__init__()
if self.__class__ is PluginDocument:
raise NotImplementedError
id = Column(Integer(), primary_key=True)
@declared_attr
def owner(cls):
return Column(Integer(), ForeignKey('user.id'))
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from sqlalchemy.ext.declarative import declared_attr
from database import Column, Integer, String, ForeignKey, Text
and context:
# Path: database.py
# def get_session():
# def teardown_session(exception):
which might include code, classes, or functions. Output only the next line. | title = Column(String(256)) |
Next line prediction: <|code_start|>
class PluginDocument(object):
"""Abstract class for all plugins to make their own document type."""
def __init__(self):
super().__init__()
if self.__class__ is PluginDocument:
raise NotImplementedError
id = Column(Integer(), primary_key=True)
@declared_attr
def owner(cls):
<|code_end|>
. Use current file imports:
(from sqlalchemy.ext.declarative import declared_attr
from database import Column, Integer, String, ForeignKey, Text)
and context including class names, function names, or small code snippets from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | return Column(Integer(), ForeignKey('user.id')) |
Using the snippet: <|code_start|>
class PluginDocument(object):
"""Abstract class for all plugins to make their own document type."""
def __init__(self):
super().__init__()
if self.__class__ is PluginDocument:
raise NotImplementedError
id = Column(Integer(), primary_key=True)
@declared_attr
def owner(cls):
return Column(Integer(), ForeignKey('user.id'))
title = Column(String(256))
last_modified = Column(Integer())
<|code_end|>
, determine the next line of code. You have imports:
from sqlalchemy.ext.declarative import declared_attr
from database import Column, Integer, String, ForeignKey, Text
and context (class names, function names, or code) available:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | description = Column(Text()) |
Next line prediction: <|code_start|> works = Column(VARCHAR(10))
favorite = Column(INTEGER(4))
specified_u_list = Column(LONGTEXT)
deep_u_list = Column(LONGTEXT)
deep_count = Column(INTEGER(11))
ps_string = Column(LONGTEXT)
scars = Column(VARCHAR(20))
default_scars = Column(VARCHAR(20))
owner_id = Column(INTEGER(11))
group_u_list = Column(LONGTEXT)
has_barcode = Column(TINYINT(1))
notes = Column(LONGTEXT)
sources = Column(TEXT)
nickname = Column(VARCHAR(10))
categories = Column(VARCHAR(500))
sequence = Column(LONGTEXT)
sequence_sha1 = Column(BINARY(20))
sequence_update = Column(INTEGER(11))
seq_edit_cache = Column(LONGTEXT)
review_result = Column(DOUBLE(12, 0))
review_count = Column(INTEGER(4))
review_total = Column(INTEGER(4))
flag = Column(INTEGER(4))
sequence_length = Column(INTEGER(11))
temp_1 = Column(INTEGER(11))
temp_2 = Column(INTEGER(11))
temp_3 = Column(INTEGER(11))
temp4 = Column(INTEGER(11))
rating = Column(INTEGER(11))
<|code_end|>
. Use current file imports:
(from database import TableBase, Column, ForeignKey, \
Integer, INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE)
and context including class names, function names, or small code snippets from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | owner = Column(Integer, ForeignKey('user.user_id')) |
Here is a snippet: <|code_start|> works = Column(VARCHAR(10))
favorite = Column(INTEGER(4))
specified_u_list = Column(LONGTEXT)
deep_u_list = Column(LONGTEXT)
deep_count = Column(INTEGER(11))
ps_string = Column(LONGTEXT)
scars = Column(VARCHAR(20))
default_scars = Column(VARCHAR(20))
owner_id = Column(INTEGER(11))
group_u_list = Column(LONGTEXT)
has_barcode = Column(TINYINT(1))
notes = Column(LONGTEXT)
sources = Column(TEXT)
nickname = Column(VARCHAR(10))
categories = Column(VARCHAR(500))
sequence = Column(LONGTEXT)
sequence_sha1 = Column(BINARY(20))
sequence_update = Column(INTEGER(11))
seq_edit_cache = Column(LONGTEXT)
review_result = Column(DOUBLE(12, 0))
review_count = Column(INTEGER(4))
review_total = Column(INTEGER(4))
flag = Column(INTEGER(4))
sequence_length = Column(INTEGER(11))
temp_1 = Column(INTEGER(11))
temp_2 = Column(INTEGER(11))
temp_3 = Column(INTEGER(11))
temp4 = Column(INTEGER(11))
rating = Column(INTEGER(11))
<|code_end|>
. Write the next line using the current file imports:
from database import TableBase, Column, ForeignKey, \
Integer, INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
and context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
, which may include functions, classes, or code. Output only the next line. | owner = Column(Integer, ForeignKey('user.user_id')) |
Given the code snippet: <|code_start|>
class BiobrickUser(TableBase):
__tablename__ = 'parts_by_user'
part_id = Column(INTEGER(11), primary_key=True)
<|code_end|>
, generate the next line using the imports in this file:
from database import TableBase, Column, ForeignKey, \
Integer, INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
and context (functions, classes, or occasionally code) from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | ok = Column(TINYINT(1)) |
Given the following code snippet before the placeholder: <|code_start|>
class BiobrickUser(TableBase):
__tablename__ = 'parts_by_user'
part_id = Column(INTEGER(11), primary_key=True)
ok = Column(TINYINT(1))
<|code_end|>
, predict the next line using imports from the current file:
from database import TableBase, Column, ForeignKey, \
Integer, INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
and context including class names, function names, and sometimes code from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | part_name = Column(VARCHAR(255)) |
Here is a snippet: <|code_start|>
class BiobrickUser(TableBase):
__tablename__ = 'parts_by_user'
part_id = Column(INTEGER(11), primary_key=True)
ok = Column(TINYINT(1))
part_name = Column(VARCHAR(255))
short_desc = Column(VARCHAR(100))
<|code_end|>
. Write the next line using the current file imports:
from database import TableBase, Column, ForeignKey, \
Integer, INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
and context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
, which may include functions, classes, or code. Output only the next line. | description = Column(LONGTEXT) |
Predict the next line after this snippet: <|code_start|>
class BiobrickUser(TableBase):
__tablename__ = 'parts_by_user'
part_id = Column(INTEGER(11), primary_key=True)
ok = Column(TINYINT(1))
part_name = Column(VARCHAR(255))
short_desc = Column(VARCHAR(100))
description = Column(LONGTEXT)
part_type = Column(VARCHAR(20))
author = Column(VARCHAR(200))
owning_group_id = Column(INTEGER(11))
status = Column(VARCHAR(20))
dominant = Column(TINYINT(1))
informational = Column(TINYINT(1))
discontinued = Column(INTEGER(11))
part_status = Column(VARCHAR(40))
sample_status = Column(VARCHAR(40))
p_status_cache = Column(VARCHAR(1000))
s_status_cache = Column(VARCHAR(1000))
<|code_end|>
using the current file's imports:
from database import TableBase, Column, ForeignKey, \
Integer, INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
and any relevant context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | creation_date = Column(DATE) |
Given the following code snippet before the placeholder: <|code_start|>
class BiobrickUser(TableBase):
__tablename__ = 'parts_by_user'
part_id = Column(INTEGER(11), primary_key=True)
ok = Column(TINYINT(1))
part_name = Column(VARCHAR(255))
short_desc = Column(VARCHAR(100))
description = Column(LONGTEXT)
part_type = Column(VARCHAR(20))
author = Column(VARCHAR(200))
owning_group_id = Column(INTEGER(11))
status = Column(VARCHAR(20))
dominant = Column(TINYINT(1))
informational = Column(TINYINT(1))
discontinued = Column(INTEGER(11))
part_status = Column(VARCHAR(40))
sample_status = Column(VARCHAR(40))
p_status_cache = Column(VARCHAR(1000))
s_status_cache = Column(VARCHAR(1000))
creation_date = Column(DATE)
<|code_end|>
, predict the next line using imports from the current file:
from database import TableBase, Column, ForeignKey, \
Integer, INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
and context including class names, function names, and sometimes code from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | m_datetime = Column(DATETIME) |
Next line prediction: <|code_start|> short_desc = Column(VARCHAR(100))
description = Column(LONGTEXT)
part_type = Column(VARCHAR(20))
author = Column(VARCHAR(200))
owning_group_id = Column(INTEGER(11))
status = Column(VARCHAR(20))
dominant = Column(TINYINT(1))
informational = Column(TINYINT(1))
discontinued = Column(INTEGER(11))
part_status = Column(VARCHAR(40))
sample_status = Column(VARCHAR(40))
p_status_cache = Column(VARCHAR(1000))
s_status_cache = Column(VARCHAR(1000))
creation_date = Column(DATE)
m_datetime = Column(DATETIME)
m_user_id = Column(INTEGER(11))
uses = Column(INTEGER(11))
doc_size = Column(INTEGER(11))
works = Column(VARCHAR(10))
favorite = Column(INTEGER(4))
specified_u_list = Column(LONGTEXT)
deep_u_list = Column(LONGTEXT)
deep_count = Column(INTEGER(11))
ps_string = Column(LONGTEXT)
scars = Column(VARCHAR(20))
default_scars = Column(VARCHAR(20))
owner_id = Column(INTEGER(11))
group_u_list = Column(LONGTEXT)
has_barcode = Column(TINYINT(1))
notes = Column(LONGTEXT)
<|code_end|>
. Use current file imports:
(from database import TableBase, Column, ForeignKey, \
Integer, INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE)
and context including class names, function names, or small code snippets from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | sources = Column(TEXT) |
Continue the code snippet: <|code_start|> owning_group_id = Column(INTEGER(11))
status = Column(VARCHAR(20))
dominant = Column(TINYINT(1))
informational = Column(TINYINT(1))
discontinued = Column(INTEGER(11))
part_status = Column(VARCHAR(40))
sample_status = Column(VARCHAR(40))
p_status_cache = Column(VARCHAR(1000))
s_status_cache = Column(VARCHAR(1000))
creation_date = Column(DATE)
m_datetime = Column(DATETIME)
m_user_id = Column(INTEGER(11))
uses = Column(INTEGER(11))
doc_size = Column(INTEGER(11))
works = Column(VARCHAR(10))
favorite = Column(INTEGER(4))
specified_u_list = Column(LONGTEXT)
deep_u_list = Column(LONGTEXT)
deep_count = Column(INTEGER(11))
ps_string = Column(LONGTEXT)
scars = Column(VARCHAR(20))
default_scars = Column(VARCHAR(20))
owner_id = Column(INTEGER(11))
group_u_list = Column(LONGTEXT)
has_barcode = Column(TINYINT(1))
notes = Column(LONGTEXT)
sources = Column(TEXT)
nickname = Column(VARCHAR(10))
categories = Column(VARCHAR(500))
sequence = Column(LONGTEXT)
<|code_end|>
. Use current file imports:
from database import TableBase, Column, ForeignKey, \
Integer, INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
and context (classes, functions, or code) from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | sequence_sha1 = Column(BINARY(20)) |
Continue the code snippet: <|code_start|> informational = Column(TINYINT(1))
discontinued = Column(INTEGER(11))
part_status = Column(VARCHAR(40))
sample_status = Column(VARCHAR(40))
p_status_cache = Column(VARCHAR(1000))
s_status_cache = Column(VARCHAR(1000))
creation_date = Column(DATE)
m_datetime = Column(DATETIME)
m_user_id = Column(INTEGER(11))
uses = Column(INTEGER(11))
doc_size = Column(INTEGER(11))
works = Column(VARCHAR(10))
favorite = Column(INTEGER(4))
specified_u_list = Column(LONGTEXT)
deep_u_list = Column(LONGTEXT)
deep_count = Column(INTEGER(11))
ps_string = Column(LONGTEXT)
scars = Column(VARCHAR(20))
default_scars = Column(VARCHAR(20))
owner_id = Column(INTEGER(11))
group_u_list = Column(LONGTEXT)
has_barcode = Column(TINYINT(1))
notes = Column(LONGTEXT)
sources = Column(TEXT)
nickname = Column(VARCHAR(10))
categories = Column(VARCHAR(500))
sequence = Column(LONGTEXT)
sequence_sha1 = Column(BINARY(20))
sequence_update = Column(INTEGER(11))
seq_edit_cache = Column(LONGTEXT)
<|code_end|>
. Use current file imports:
from database import TableBase, Column, ForeignKey, \
Integer, INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
and context (classes, functions, or code) from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | review_result = Column(DOUBLE(12, 0)) |
Next line prediction: <|code_start|> plt.plot(self.t_range, self.data_all[i, :], label='y' + str(i))
if self.unstable is not None:
plt.axvline(x=self.unstable, linewidth=3, color='r')
plt.show()
def main():
str_eqs ="""dy0dt = -10*y[0] + 10*y[1]
dy1dt = 28*y[0] - y[1]-y[0]*y[2]
dy2dt = -8/3 * y[2] + y[0] * y[1]"""
str_init = """y0 = 10
y1 = 5
y2 = 1.01"""
#str_eqs = """dy0dt = 3.8 * y[0] * (1 - y[0])"""
#str_init = """y0= 0.5"""
sim = bio_simulation(str_eqs, str_init)
sim.run_sim()
#print(repr(list(map(list, sim.data_all))))
sim.plot_data()
if __name__ in ("plugins.simulation", '__main__'):
main()
'''
<|code_end|>
. Use current file imports:
(from numpy import *
from scipy.integrate import odeint
from plugin import Plugin)
and context including class names, function names, or small code snippets from other files:
# Path: plugin.py
# class Plugin:
# def __init__(self):
# self.documents = Documents(self)
# try: self.name
# except: self.name = self.__class__.__name__.lower()
# try: self.description
# except: self.description = 'This plugin has no description.'
# if self.__class__ is Plugin:
# raise NotImplementedError
#
# @property
# def user(self):
# return app.current_user
#
# def process(self, request):
# pass
#
# def unload(self):
# pass
. Output only the next line. | class Simulation(Plugin): |
Continue the code snippet: <|code_start|>"""This is an ABACUS plugin.
request = {
"action": "design" or "singleMutationScan"
"id": user_id
"inpath": inputFilePath
"filename": filename
"amount": amount #optional
"tag":tag
"design": desginpath
"mutationScan": scanpath
"abacuspath": path
}
"""
abacuspath = 'plugins/ABACUS/ABACUS/bin/'
designpath = 'plugins/ABACUS/design.py'
mutationpath = 'plugins/ABACUS/singleMutationScan.py'
<|code_end|>
. Use current file imports:
from time import ctime
from subprocess import Popen
from os import mkdir, listdir, getcwd, chdir, path
from shutil import rmtree
from plugin import Plugin
from zipfile import ZipFile
from .callabacus import InternalError, FileFormatError
import os
import re
and context (classes, functions, or code) from other files:
# Path: plugin.py
# class Plugin:
# def __init__(self):
# self.documents = Documents(self)
# try: self.name
# except: self.name = self.__class__.__name__.lower()
# try: self.description
# except: self.description = 'This plugin has no description.'
# if self.__class__ is Plugin:
# raise NotImplementedError
#
# @property
# def user(self):
# return app.current_user
#
# def process(self, request):
# pass
#
# def unload(self):
# pass
#
# Path: plugins/ABACUS/callabacus.py
# class InternalError(Exception):
# pass
#
# class FileFormatError(Exception):
# pass
. Output only the next line. | class ABACUS(Plugin): |
Predict the next line for this snippet: <|code_start|>
class FeatureUser(TableBase):
__tablename__ = 'parts_seq_features_by_user'
feature_id = Column(INTEGER(11), primary_key=True)
feature_type = Column(VARCHAR(200))
start_pos = Column(INTEGER(11))
end_pos = Column(INTEGER(11))
label = Column(VARCHAR(200))
<|code_end|>
with the help of current file imports:
from database import TableBase, Column, ForeignKey, INTEGER, VARCHAR
and context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
, which may contain function names, class names, or code. Output only the next line. | part_id = Column(INTEGER(11), ForeignKey('parts.part_id')) |
Continue the code snippet: <|code_start|>
class FeatureUser(TableBase):
__tablename__ = 'parts_seq_features_by_user'
feature_id = Column(INTEGER(11), primary_key=True)
<|code_end|>
. Use current file imports:
from database import TableBase, Column, ForeignKey, INTEGER, VARCHAR
and context (classes, functions, or code) from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | feature_type = Column(VARCHAR(200)) |
Next line prediction: <|code_start|>
class FeatureOfficial(TableBase):
__tablename__ = 'parts_seq_features'
feature_id = Column(INTEGER(11), primary_key=True)
feature_type = Column(VARCHAR(200))
start_pos = Column(INTEGER(11))
end_pos = Column(INTEGER(11))
label = Column(VARCHAR(200))
<|code_end|>
. Use current file imports:
(from database import TableBase, Column, ForeignKey, INTEGER, VARCHAR)
and context including class names, function names, or small code snippets from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | part_id = Column(INTEGER(11), ForeignKey('parts.part_id')) |
Continue the code snippet: <|code_start|>
class FeatureOfficial(TableBase):
__tablename__ = 'parts_seq_features'
feature_id = Column(INTEGER(11), primary_key=True)
<|code_end|>
. Use current file imports:
from database import TableBase, Column, ForeignKey, INTEGER, VARCHAR
and context (classes, functions, or code) from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | feature_type = Column(VARCHAR(200)) |
Next line prediction: <|code_start|>
class Document(TableBase):
"""An object refer to an actual plugin-managed document.
Every actual document is not only saved in plugins' table, but also has an entry here, so that we can easily get all documents belong to a specific user."""
__tablename__ = 'document'
<|code_end|>
. Use current file imports:
(from .plugin_document import PluginDocument
from database import TableBase, Column, Integer, String, ForeignKey)
and context including class names, function names, or small code snippets from other files:
# Path: models/plugin_document.py
# class PluginDocument(object):
# """Abstract class for all plugins to make their own document type."""
#
# def __init__(self):
# super().__init__()
# if self.__class__ is PluginDocument:
# raise NotImplementedError
#
# id = Column(Integer(), primary_key=True)
# @declared_attr
# def owner(cls):
# return Column(Integer(), ForeignKey('user.id'))
# title = Column(String(256))
# last_modified = Column(Integer())
# description = Column(Text())
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | def __init__(self, plugin_name: str, doc: PluginDocument): |
Using the snippet: <|code_start|>
class Document(TableBase):
"""An object refer to an actual plugin-managed document.
Every actual document is not only saved in plugins' table, but also has an entry here, so that we can easily get all documents belong to a specific user."""
__tablename__ = 'document'
def __init__(self, plugin_name: str, doc: PluginDocument):
super().__init__()
self.owner = doc.owner
self.plugin_name = plugin_name
self.plugin_document_id = doc.id
<|code_end|>
, determine the next line of code. You have imports:
from .plugin_document import PluginDocument
from database import TableBase, Column, Integer, String, ForeignKey
and context (class names, function names, or code) available:
# Path: models/plugin_document.py
# class PluginDocument(object):
# """Abstract class for all plugins to make their own document type."""
#
# def __init__(self):
# super().__init__()
# if self.__class__ is PluginDocument:
# raise NotImplementedError
#
# id = Column(Integer(), primary_key=True)
# @declared_attr
# def owner(cls):
# return Column(Integer(), ForeignKey('user.id'))
# title = Column(String(256))
# last_modified = Column(Integer())
# description = Column(Text())
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | document_id = Column(Integer(), primary_key=True) |
Given the following code snippet before the placeholder: <|code_start|>
class Document(TableBase):
"""An object refer to an actual plugin-managed document.
Every actual document is not only saved in plugins' table, but also has an entry here, so that we can easily get all documents belong to a specific user."""
__tablename__ = 'document'
def __init__(self, plugin_name: str, doc: PluginDocument):
super().__init__()
self.owner = doc.owner
self.plugin_name = plugin_name
self.plugin_document_id = doc.id
<|code_end|>
, predict the next line using imports from the current file:
from .plugin_document import PluginDocument
from database import TableBase, Column, Integer, String, ForeignKey
and context including class names, function names, and sometimes code from other files:
# Path: models/plugin_document.py
# class PluginDocument(object):
# """Abstract class for all plugins to make their own document type."""
#
# def __init__(self):
# super().__init__()
# if self.__class__ is PluginDocument:
# raise NotImplementedError
#
# id = Column(Integer(), primary_key=True)
# @declared_attr
# def owner(cls):
# return Column(Integer(), ForeignKey('user.id'))
# title = Column(String(256))
# last_modified = Column(Integer())
# description = Column(Text())
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | document_id = Column(Integer(), primary_key=True) |
Using the snippet: <|code_start|>
class Document(TableBase):
"""An object refer to an actual plugin-managed document.
Every actual document is not only saved in plugins' table, but also has an entry here, so that we can easily get all documents belong to a specific user."""
__tablename__ = 'document'
def __init__(self, plugin_name: str, doc: PluginDocument):
super().__init__()
self.owner = doc.owner
self.plugin_name = plugin_name
self.plugin_document_id = doc.id
document_id = Column(Integer(), primary_key=True)
owner = Column(Integer(), ForeignKey('user.id'))
<|code_end|>
, determine the next line of code. You have imports:
from .plugin_document import PluginDocument
from database import TableBase, Column, Integer, String, ForeignKey
and context (class names, function names, or code) available:
# Path: models/plugin_document.py
# class PluginDocument(object):
# """Abstract class for all plugins to make their own document type."""
#
# def __init__(self):
# super().__init__()
# if self.__class__ is PluginDocument:
# raise NotImplementedError
#
# id = Column(Integer(), primary_key=True)
# @declared_attr
# def owner(cls):
# return Column(Integer(), ForeignKey('user.id'))
# title = Column(String(256))
# last_modified = Column(Integer())
# description = Column(Text())
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | plugin_name = Column(String(256)) |
Given snippet: <|code_start|>
class Document(TableBase):
"""An object refer to an actual plugin-managed document.
Every actual document is not only saved in plugins' table, but also has an entry here, so that we can easily get all documents belong to a specific user."""
__tablename__ = 'document'
def __init__(self, plugin_name: str, doc: PluginDocument):
super().__init__()
self.owner = doc.owner
self.plugin_name = plugin_name
self.plugin_document_id = doc.id
document_id = Column(Integer(), primary_key=True)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .plugin_document import PluginDocument
from database import TableBase, Column, Integer, String, ForeignKey
and context:
# Path: models/plugin_document.py
# class PluginDocument(object):
# """Abstract class for all plugins to make their own document type."""
#
# def __init__(self):
# super().__init__()
# if self.__class__ is PluginDocument:
# raise NotImplementedError
#
# id = Column(Integer(), primary_key=True)
# @declared_attr
# def owner(cls):
# return Column(Integer(), ForeignKey('user.id'))
# title = Column(String(256))
# last_modified = Column(Integer())
# description = Column(Text())
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
which might include code, classes, or functions. Output only the next line. | owner = Column(Integer(), ForeignKey('user.id')) |
Given the code snippet: <|code_start|>
plugin = Blueprint('plugin', __name__)
@plugin.route('/', methods=['GET', 'POST'])
def plugin_request():
plugin_name = request.values['plugin'] if 'plugin' in request.values else ''
req = {v: request.values[v] for v in request.values}
if 'file' in request.files and request.files['file'].filename:
req['file'] = request.files['file']
print('Got a file:', request.files['file'].filename)
<|code_end|>
, generate the next line using the imports in this file:
from flask import Blueprint, redirect, url_for, request
from flask_login import current_user, login_required, login_user, logout_user
from models import User
from plugin import plugin_manager
import json
and context (functions, classes, or occasionally code) from other files:
# Path: models/user.py
# class User(TableBase, UserMixin):
# """A user."""
#
# __tablename__ = 'user'
# id = Column(Integer, primary_key=True)
# email = Column(String(63), unique=True)
# passwordhash = Column(String(127), nullable=False)
# salt = Column(String(127), nullable=False)
# username = Column(String(127))
# if os.getenv('FLASK_TESTING'):
# avatar = Column(String(16777215))
# else:
# avatar = Column(MEDIUMTEXT())
# description = Column(Text())
# education = Column(Text())
# major = Column(Text())
#
# def __init__(self, email, password, username):
# self.email = email
# self.set_password(password)
# self.username = username
#
# def set_password(self, password):
# """hash and save the password"""
# self.salt = random_string(10)
# s = hashlib.sha256()
# s.update(password.encode('utf-8'))
# s.update(self.salt.encode('utf-8'))
# self.passwordhash = s.hexdigest()
#
# def check_password(self, password):
# """hash and check the password"""
# s = hashlib.sha256()
# s.update(password.encode('utf-8'))
# s.update(self.salt.encode('utf-8'))
# return self.passwordhash == s.hexdigest()
#
# @classmethod
# def get_user_by_email(cls, email):
# return session.query(cls).filter_by(email=email).first()
#
# @classmethod
# def get_user_by_id(cls, id):
# return session.query(cls).get(id)
#
# Path: plugin.py
# class Plugin:
# class PluginManager:
# class Documents:
# def __init__(self):
# def user(self):
# def process(self, request):
# def unload(self):
# def __init__(self):
# def load_plugin(self, name, reload=False):
# def get_plugins(self):
# def send_request(self, plugin, request):
# def __init__(self, plugin: Plugin):
# def set_document_type(self, name: str):
# def set_document_table(self, table):
# def get(self, pid):
# def list(self, owner):
# def create(self, pdoc: PluginDocument):
# def update(pdoc: PluginDocument):
# def delete(self, pdoc: PluginDocument):
. Output only the next line. | rtv = plugin_manager.send_request(plugin_name, req) |
Given snippet: <|code_start|>
class Link(TableBase):
"""A link between two nodes, for path_finder."""
__tablename__ = 'link'
link_id = Column(Integer, primary_key=True, autoincrement=True)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from database import TableBase, Column, String, ForeignKey, Integer
and context:
# Path: database.py
# def get_session():
# def teardown_session(exception):
which might include code, classes, or functions. Output only the next line. | tax_id = Column(String(10)) |
Given the following code snippet before the placeholder: <|code_start|>dis = {}
node_count = 0
class State:
def __init__(self, f, g, cur, prepath): # f is the distance to src, g is the distance to dst
self.f = f
self.g = g
self.cur = cur
self.prepath = prepath
def __lt__(self, x):
if self.f == x.f:
return self.g < x.g
else:
return self.f < x.f
def calcu_dis(dst, n, maxlen):
global dis
visited = {}
queue = Queue()
dis[dst] = 0
visited[dst] = True
queue.put(dst)
while not queue.empty():
u = queue.get()
# visited[u] = False
Graph[u] = []
<|code_end|>
, predict the next line using imports from the current file:
from queue import Queue, PriorityQueue
from datetime import *
from database import session
from plugin import Plugin
from .dbupload.dbprofile import biosys_single, Gene
and context including class names, function names, and sometimes code from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: plugin.py
# class Plugin:
# def __init__(self):
# self.documents = Documents(self)
# try: self.name
# except: self.name = self.__class__.__name__.lower()
# try: self.description
# except: self.description = 'This plugin has no description.'
# if self.__class__ is Plugin:
# raise NotImplementedError
#
# @property
# def user(self):
# return app.current_user
#
# def process(self, request):
# pass
#
# def unload(self):
# pass
#
# Path: plugins/dbupload/dbprofile.py
# class biosys_single(TableBase):
# __tablename__ = 'biosys_562'
# id = Column(Integer, primary_key=True, autoincrement=True)
# tax_id = Column(String(10))
# gene_id = Column(String(10))
# bsid = Column(Integer)
# Symbol = Column(String(64))
#
# class Gene(TableBase):
# __tablename__ = 'allgeneinfo_all'
# tax_id = Column(String(10))
# gene_id = Column(String(10), primary_key=True)
# Symbol = Column(String(64))
# LocusTag = Column(Text)
# Synonyms = Column(Text)
# dbXrefs = Column(Text)
# chromosome = Column(Text)
# map_location = Column(Text)
# description = Column(Text)
# type_of_gene = Column(Text)
# Symbol_from_nomenclature_authority = Column(Text)
# Full_name_from_nomenclature_authority = Column(Text)
# Nomenclature_status = Column(Text)
# Other_designations = Column(Text)
# Modification_date = Column(Date)
. Output only the next line. | for u_node in session.query(biosys_single).filter(biosys_single.gene_id == u): |
Predict the next line for this snippet: <|code_start|> p_queue.put(State(s.g + 1 + dis[v], s.g + 1, v, s.prepath + [v]))
if (datetime.now() - time_monitor).seconds > 5:
yield "Timeout"
return
def path_finder(s, t, k, maxlen): # s:starting point, t:terminal point, k:number of paths required
calcu_dis(t, node_count, maxlen)
path_list = [] # contain the found paths
node_pool = []
requested = {}
for p in a_star(s, t, k):
if p == "None" or p == "Timeout":
break
else:
for gene_id in p:
if gene_id not in requested:
requested[gene_id] = True
node = session.query(Gene).get(gene_id)
result = {"gene_id": gene_id}
result["tax_id"] = node.tax_id
result["name"] = node.Symbol
result["info"] = node.description
node_pool.append(result)
path_list.append(p)
print(node_pool)
return node_pool, path_list
<|code_end|>
with the help of current file imports:
from queue import Queue, PriorityQueue
from datetime import *
from database import session
from plugin import Plugin
from .dbupload.dbprofile import biosys_single, Gene
and context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: plugin.py
# class Plugin:
# def __init__(self):
# self.documents = Documents(self)
# try: self.name
# except: self.name = self.__class__.__name__.lower()
# try: self.description
# except: self.description = 'This plugin has no description.'
# if self.__class__ is Plugin:
# raise NotImplementedError
#
# @property
# def user(self):
# return app.current_user
#
# def process(self, request):
# pass
#
# def unload(self):
# pass
#
# Path: plugins/dbupload/dbprofile.py
# class biosys_single(TableBase):
# __tablename__ = 'biosys_562'
# id = Column(Integer, primary_key=True, autoincrement=True)
# tax_id = Column(String(10))
# gene_id = Column(String(10))
# bsid = Column(Integer)
# Symbol = Column(String(64))
#
# class Gene(TableBase):
# __tablename__ = 'allgeneinfo_all'
# tax_id = Column(String(10))
# gene_id = Column(String(10), primary_key=True)
# Symbol = Column(String(64))
# LocusTag = Column(Text)
# Synonyms = Column(Text)
# dbXrefs = Column(Text)
# chromosome = Column(Text)
# map_location = Column(Text)
# description = Column(Text)
# type_of_gene = Column(Text)
# Symbol_from_nomenclature_authority = Column(Text)
# Full_name_from_nomenclature_authority = Column(Text)
# Nomenclature_status = Column(Text)
# Other_designations = Column(Text)
# Modification_date = Column(Date)
, which may contain function names, class names, or code. Output only the next line. | class Path_Finder(Plugin): |
Based on the snippet: <|code_start|>dis = {}
node_count = 0
class State:
def __init__(self, f, g, cur, prepath): # f is the distance to src, g is the distance to dst
self.f = f
self.g = g
self.cur = cur
self.prepath = prepath
def __lt__(self, x):
if self.f == x.f:
return self.g < x.g
else:
return self.f < x.f
def calcu_dis(dst, n, maxlen):
global dis
visited = {}
queue = Queue()
dis[dst] = 0
visited[dst] = True
queue.put(dst)
while not queue.empty():
u = queue.get()
# visited[u] = False
Graph[u] = []
<|code_end|>
, predict the immediate next line with the help of imports:
from queue import Queue, PriorityQueue
from datetime import *
from database import session
from plugin import Plugin
from .dbupload.dbprofile import biosys_single, Gene
and context (classes, functions, sometimes code) from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: plugin.py
# class Plugin:
# def __init__(self):
# self.documents = Documents(self)
# try: self.name
# except: self.name = self.__class__.__name__.lower()
# try: self.description
# except: self.description = 'This plugin has no description.'
# if self.__class__ is Plugin:
# raise NotImplementedError
#
# @property
# def user(self):
# return app.current_user
#
# def process(self, request):
# pass
#
# def unload(self):
# pass
#
# Path: plugins/dbupload/dbprofile.py
# class biosys_single(TableBase):
# __tablename__ = 'biosys_562'
# id = Column(Integer, primary_key=True, autoincrement=True)
# tax_id = Column(String(10))
# gene_id = Column(String(10))
# bsid = Column(Integer)
# Symbol = Column(String(64))
#
# class Gene(TableBase):
# __tablename__ = 'allgeneinfo_all'
# tax_id = Column(String(10))
# gene_id = Column(String(10), primary_key=True)
# Symbol = Column(String(64))
# LocusTag = Column(Text)
# Synonyms = Column(Text)
# dbXrefs = Column(Text)
# chromosome = Column(Text)
# map_location = Column(Text)
# description = Column(Text)
# type_of_gene = Column(Text)
# Symbol_from_nomenclature_authority = Column(Text)
# Full_name_from_nomenclature_authority = Column(Text)
# Nomenclature_status = Column(Text)
# Other_designations = Column(Text)
# Modification_date = Column(Date)
. Output only the next line. | for u_node in session.query(biosys_single).filter(biosys_single.gene_id == u): |
Here is a snippet: <|code_start|> return
p_queue.put(State(dis[src], 0, src, [src]))
while not p_queue.empty():
s = p_queue.get()
if s.cur == dst:
yield s.prepath
cnt += 1
if cnt == pathnum:
break
for v in Graph[s.cur]:
if v not in s.prepath:
p_queue.put(State(s.g + 1 + dis[v], s.g + 1, v, s.prepath + [v]))
if (datetime.now() - time_monitor).seconds > 5:
yield "Timeout"
return
def path_finder(s, t, k, maxlen): # s:starting point, t:terminal point, k:number of paths required
calcu_dis(t, node_count, maxlen)
path_list = [] # contain the found paths
node_pool = []
requested = {}
for p in a_star(s, t, k):
if p == "None" or p == "Timeout":
break
else:
for gene_id in p:
if gene_id not in requested:
requested[gene_id] = True
<|code_end|>
. Write the next line using the current file imports:
from queue import Queue, PriorityQueue
from datetime import *
from database import session
from plugin import Plugin
from .dbupload.dbprofile import biosys_single, Gene
and context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: plugin.py
# class Plugin:
# def __init__(self):
# self.documents = Documents(self)
# try: self.name
# except: self.name = self.__class__.__name__.lower()
# try: self.description
# except: self.description = 'This plugin has no description.'
# if self.__class__ is Plugin:
# raise NotImplementedError
#
# @property
# def user(self):
# return app.current_user
#
# def process(self, request):
# pass
#
# def unload(self):
# pass
#
# Path: plugins/dbupload/dbprofile.py
# class biosys_single(TableBase):
# __tablename__ = 'biosys_562'
# id = Column(Integer, primary_key=True, autoincrement=True)
# tax_id = Column(String(10))
# gene_id = Column(String(10))
# bsid = Column(Integer)
# Symbol = Column(String(64))
#
# class Gene(TableBase):
# __tablename__ = 'allgeneinfo_all'
# tax_id = Column(String(10))
# gene_id = Column(String(10), primary_key=True)
# Symbol = Column(String(64))
# LocusTag = Column(Text)
# Synonyms = Column(Text)
# dbXrefs = Column(Text)
# chromosome = Column(Text)
# map_location = Column(Text)
# description = Column(Text)
# type_of_gene = Column(Text)
# Symbol_from_nomenclature_authority = Column(Text)
# Full_name_from_nomenclature_authority = Column(Text)
# Nomenclature_status = Column(Text)
# Other_designations = Column(Text)
# Modification_date = Column(Date)
, which may include functions, classes, or code. Output only the next line. | node = session.query(Gene).get(gene_id) |
Given the following code snippet before the placeholder: <|code_start|>
#from .FeatureOfficial import FeatureOfficial
class BiobrickOfficial(TableBase):
__tablename__ = 'parts'
part_id = Column(INTEGER(11), primary_key=True)
<|code_end|>
, predict the next line using imports from the current file:
from database import TableBase, Column, \
INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
from database import session
and context including class names, function names, and sometimes code from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | ok = Column(TINYINT(1)) |
Given snippet: <|code_start|>
#from .FeatureOfficial import FeatureOfficial
class BiobrickOfficial(TableBase):
__tablename__ = 'parts'
part_id = Column(INTEGER(11), primary_key=True)
ok = Column(TINYINT(1))
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from database import TableBase, Column, \
INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
from database import session
and context:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
which might include code, classes, or functions. Output only the next line. | part_name = Column(VARCHAR(255)) |
Here is a snippet: <|code_start|>
#from .FeatureOfficial import FeatureOfficial
class BiobrickOfficial(TableBase):
__tablename__ = 'parts'
part_id = Column(INTEGER(11), primary_key=True)
ok = Column(TINYINT(1))
part_name = Column(VARCHAR(255))
short_desc = Column(VARCHAR(100))
<|code_end|>
. Write the next line using the current file imports:
from database import TableBase, Column, \
INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
from database import session
and context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
, which may include functions, classes, or code. Output only the next line. | description = Column(LONGTEXT) |
Predict the next line for this snippet: <|code_start|>
#from .FeatureOfficial import FeatureOfficial
class BiobrickOfficial(TableBase):
__tablename__ = 'parts'
part_id = Column(INTEGER(11), primary_key=True)
ok = Column(TINYINT(1))
part_name = Column(VARCHAR(255))
short_desc = Column(VARCHAR(100))
description = Column(LONGTEXT)
part_type = Column(VARCHAR(20))
author = Column(VARCHAR(200))
owning_group_id = Column(INTEGER(11))
status = Column(VARCHAR(20))
dominant = Column(TINYINT(1))
informational = Column(TINYINT(1))
discontinued = Column(INTEGER(11))
part_status = Column(VARCHAR(40))
sample_status = Column(VARCHAR(40))
p_status_cache = Column(VARCHAR(1000))
s_status_cache = Column(VARCHAR(1000))
<|code_end|>
with the help of current file imports:
from database import TableBase, Column, \
INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
from database import session
and context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
, which may contain function names, class names, or code. Output only the next line. | creation_date = Column(DATE) |
Predict the next line after this snippet: <|code_start|>
#from .FeatureOfficial import FeatureOfficial
class BiobrickOfficial(TableBase):
__tablename__ = 'parts'
part_id = Column(INTEGER(11), primary_key=True)
ok = Column(TINYINT(1))
part_name = Column(VARCHAR(255))
short_desc = Column(VARCHAR(100))
description = Column(LONGTEXT)
part_type = Column(VARCHAR(20))
author = Column(VARCHAR(200))
owning_group_id = Column(INTEGER(11))
status = Column(VARCHAR(20))
dominant = Column(TINYINT(1))
informational = Column(TINYINT(1))
discontinued = Column(INTEGER(11))
part_status = Column(VARCHAR(40))
sample_status = Column(VARCHAR(40))
p_status_cache = Column(VARCHAR(1000))
s_status_cache = Column(VARCHAR(1000))
creation_date = Column(DATE)
<|code_end|>
using the current file's imports:
from database import TableBase, Column, \
INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
from database import session
and any relevant context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | m_datetime = Column(DATETIME) |
Given the code snippet: <|code_start|> short_desc = Column(VARCHAR(100))
description = Column(LONGTEXT)
part_type = Column(VARCHAR(20))
author = Column(VARCHAR(200))
owning_group_id = Column(INTEGER(11))
status = Column(VARCHAR(20))
dominant = Column(TINYINT(1))
informational = Column(TINYINT(1))
discontinued = Column(INTEGER(11))
part_status = Column(VARCHAR(40))
sample_status = Column(VARCHAR(40))
p_status_cache = Column(VARCHAR(1000))
s_status_cache = Column(VARCHAR(1000))
creation_date = Column(DATE)
m_datetime = Column(DATETIME)
m_user_id = Column(INTEGER(11))
uses = Column(INTEGER(11))
doc_size = Column(INTEGER(11))
works = Column(VARCHAR(10))
favorite = Column(INTEGER(4))
specified_u_list = Column(LONGTEXT)
deep_u_list = Column(LONGTEXT)
deep_count = Column(INTEGER(11))
ps_string = Column(LONGTEXT)
scars = Column(VARCHAR(20))
default_scars = Column(VARCHAR(20))
owner_id = Column(INTEGER(11))
group_u_list = Column(LONGTEXT)
has_barcode = Column(TINYINT(1))
notes = Column(LONGTEXT)
<|code_end|>
, generate the next line using the imports in this file:
from database import TableBase, Column, \
INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
from database import session
and context (functions, classes, or occasionally code) from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | source = Column(TEXT) |
Using the snippet: <|code_start|> owning_group_id = Column(INTEGER(11))
status = Column(VARCHAR(20))
dominant = Column(TINYINT(1))
informational = Column(TINYINT(1))
discontinued = Column(INTEGER(11))
part_status = Column(VARCHAR(40))
sample_status = Column(VARCHAR(40))
p_status_cache = Column(VARCHAR(1000))
s_status_cache = Column(VARCHAR(1000))
creation_date = Column(DATE)
m_datetime = Column(DATETIME)
m_user_id = Column(INTEGER(11))
uses = Column(INTEGER(11))
doc_size = Column(INTEGER(11))
works = Column(VARCHAR(10))
favorite = Column(INTEGER(4))
specified_u_list = Column(LONGTEXT)
deep_u_list = Column(LONGTEXT)
deep_count = Column(INTEGER(11))
ps_string = Column(LONGTEXT)
scars = Column(VARCHAR(20))
default_scars = Column(VARCHAR(20))
owner_id = Column(INTEGER(11))
group_u_list = Column(LONGTEXT)
has_barcode = Column(TINYINT(1))
notes = Column(LONGTEXT)
source = Column(TEXT)
nickname = Column(VARCHAR(10))
categories = Column(VARCHAR(500))
sequence = Column(LONGTEXT)
<|code_end|>
, determine the next line of code. You have imports:
from database import TableBase, Column, \
INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
from database import session
and context (class names, function names, or code) available:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | sequence_sha1 = Column(BINARY(20)) |
Predict the next line after this snippet: <|code_start|> informational = Column(TINYINT(1))
discontinued = Column(INTEGER(11))
part_status = Column(VARCHAR(40))
sample_status = Column(VARCHAR(40))
p_status_cache = Column(VARCHAR(1000))
s_status_cache = Column(VARCHAR(1000))
creation_date = Column(DATE)
m_datetime = Column(DATETIME)
m_user_id = Column(INTEGER(11))
uses = Column(INTEGER(11))
doc_size = Column(INTEGER(11))
works = Column(VARCHAR(10))
favorite = Column(INTEGER(4))
specified_u_list = Column(LONGTEXT)
deep_u_list = Column(LONGTEXT)
deep_count = Column(INTEGER(11))
ps_string = Column(LONGTEXT)
scars = Column(VARCHAR(20))
default_scars = Column(VARCHAR(20))
owner_id = Column(INTEGER(11))
group_u_list = Column(LONGTEXT)
has_barcode = Column(TINYINT(1))
notes = Column(LONGTEXT)
source = Column(TEXT)
nickname = Column(VARCHAR(10))
categories = Column(VARCHAR(500))
sequence = Column(LONGTEXT)
sequence_sha1 = Column(BINARY(20))
sequence_update = Column(INTEGER(11))
seq_edit_cache = Column(LONGTEXT)
<|code_end|>
using the current file's imports:
from database import TableBase, Column, \
INTEGER, TINYINT, VARCHAR, LONGTEXT, DATE, DATETIME, TEXT, BINARY, DOUBLE
from database import session
and any relevant context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | review_result = Column(DOUBLE(12, 0)) |
Given snippet: <|code_start|> return {'success': False, 'reason': 'plugin not found'}
try:
rtv = self.plugins[plugin].process(request)
if 'success' not in rtv:
rtv['success'] = True
except Exception as e:
rtv = {'success': False, 'reason': type(e).__name__ + ': ' + str(e)}
return rtv
plugin_manager = PluginManager()
class Documents:
def __init__(self, plugin: Plugin):
self.plugin = plugin
self.type_name = None
self.document_table = None
def set_document_type(self, name: str):
self.type_name = name
def set_document_table(self, table):
self.document_table = table
try:
table.__table__.create(engine)
except:
pass
def get(self, pid):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import importlib
import app
from database import session, engine
from models import Document, PluginDocument
and context:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: models/document.py
# class Document(TableBase):
# """An object refer to an actual plugin-managed document.
#
# Every actual document is not only saved in plugins' table, but also has an entry here, so that we can easily get all documents belong to a specific user."""
#
# __tablename__ = 'document'
#
# def __init__(self, plugin_name: str, doc: PluginDocument):
# super().__init__()
# self.owner = doc.owner
# self.plugin_name = plugin_name
# self.plugin_document_id = doc.id
#
# document_id = Column(Integer(), primary_key=True)
# owner = Column(Integer(), ForeignKey('user.id'))
# plugin_name = Column(String(256))
# plugin_document_id = Column(Integer())
#
# Path: models/plugin_document.py
# class PluginDocument(object):
# """Abstract class for all plugins to make their own document type."""
#
# def __init__(self):
# super().__init__()
# if self.__class__ is PluginDocument:
# raise NotImplementedError
#
# id = Column(Integer(), primary_key=True)
# @declared_attr
# def owner(cls):
# return Column(Integer(), ForeignKey('user.id'))
# title = Column(String(256))
# last_modified = Column(Integer())
# description = Column(Text())
which might include code, classes, or functions. Output only the next line. | return session.query(self.document_table).get(pid) |
Next line prediction: <|code_start|> def get_plugins(self):
return self.plugins
def send_request(self, plugin, request):
if plugin not in self.plugins:
return {'success': False, 'reason': 'plugin not found'}
try:
rtv = self.plugins[plugin].process(request)
if 'success' not in rtv:
rtv['success'] = True
except Exception as e:
rtv = {'success': False, 'reason': type(e).__name__ + ': ' + str(e)}
return rtv
plugin_manager = PluginManager()
class Documents:
def __init__(self, plugin: Plugin):
self.plugin = plugin
self.type_name = None
self.document_table = None
def set_document_type(self, name: str):
self.type_name = name
def set_document_table(self, table):
self.document_table = table
try:
<|code_end|>
. Use current file imports:
(import importlib
import app
from database import session, engine
from models import Document, PluginDocument)
and context including class names, function names, or small code snippets from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: models/document.py
# class Document(TableBase):
# """An object refer to an actual plugin-managed document.
#
# Every actual document is not only saved in plugins' table, but also has an entry here, so that we can easily get all documents belong to a specific user."""
#
# __tablename__ = 'document'
#
# def __init__(self, plugin_name: str, doc: PluginDocument):
# super().__init__()
# self.owner = doc.owner
# self.plugin_name = plugin_name
# self.plugin_document_id = doc.id
#
# document_id = Column(Integer(), primary_key=True)
# owner = Column(Integer(), ForeignKey('user.id'))
# plugin_name = Column(String(256))
# plugin_document_id = Column(Integer())
#
# Path: models/plugin_document.py
# class PluginDocument(object):
# """Abstract class for all plugins to make their own document type."""
#
# def __init__(self):
# super().__init__()
# if self.__class__ is PluginDocument:
# raise NotImplementedError
#
# id = Column(Integer(), primary_key=True)
# @declared_attr
# def owner(cls):
# return Column(Integer(), ForeignKey('user.id'))
# title = Column(String(256))
# last_modified = Column(Integer())
# description = Column(Text())
. Output only the next line. | table.__table__.create(engine) |
Next line prediction: <|code_start|>
plugin_manager = PluginManager()
class Documents:
def __init__(self, plugin: Plugin):
self.plugin = plugin
self.type_name = None
self.document_table = None
def set_document_type(self, name: str):
self.type_name = name
def set_document_table(self, table):
self.document_table = table
try:
table.__table__.create(engine)
except:
pass
def get(self, pid):
return session.query(self.document_table).get(pid)
def list(self, owner):
return session.query(self.document_table).filter(self.document_table.owner == owner).all()
def create(self, pdoc: PluginDocument):
session.add(pdoc)
session.commit()
<|code_end|>
. Use current file imports:
(import importlib
import app
from database import session, engine
from models import Document, PluginDocument)
and context including class names, function names, or small code snippets from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: models/document.py
# class Document(TableBase):
# """An object refer to an actual plugin-managed document.
#
# Every actual document is not only saved in plugins' table, but also has an entry here, so that we can easily get all documents belong to a specific user."""
#
# __tablename__ = 'document'
#
# def __init__(self, plugin_name: str, doc: PluginDocument):
# super().__init__()
# self.owner = doc.owner
# self.plugin_name = plugin_name
# self.plugin_document_id = doc.id
#
# document_id = Column(Integer(), primary_key=True)
# owner = Column(Integer(), ForeignKey('user.id'))
# plugin_name = Column(String(256))
# plugin_document_id = Column(Integer())
#
# Path: models/plugin_document.py
# class PluginDocument(object):
# """Abstract class for all plugins to make their own document type."""
#
# def __init__(self):
# super().__init__()
# if self.__class__ is PluginDocument:
# raise NotImplementedError
#
# id = Column(Integer(), primary_key=True)
# @declared_attr
# def owner(cls):
# return Column(Integer(), ForeignKey('user.id'))
# title = Column(String(256))
# last_modified = Column(Integer())
# description = Column(Text())
. Output only the next line. | doc = Document(self.plugin.name, pdoc) |
Given the code snippet: <|code_start|> except Exception as e:
rtv = {'success': False, 'reason': type(e).__name__ + ': ' + str(e)}
return rtv
plugin_manager = PluginManager()
class Documents:
def __init__(self, plugin: Plugin):
self.plugin = plugin
self.type_name = None
self.document_table = None
def set_document_type(self, name: str):
self.type_name = name
def set_document_table(self, table):
self.document_table = table
try:
table.__table__.create(engine)
except:
pass
def get(self, pid):
return session.query(self.document_table).get(pid)
def list(self, owner):
return session.query(self.document_table).filter(self.document_table.owner == owner).all()
<|code_end|>
, generate the next line using the imports in this file:
import importlib
import app
from database import session, engine
from models import Document, PluginDocument
and context (functions, classes, or occasionally code) from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
#
# Path: models/document.py
# class Document(TableBase):
# """An object refer to an actual plugin-managed document.
#
# Every actual document is not only saved in plugins' table, but also has an entry here, so that we can easily get all documents belong to a specific user."""
#
# __tablename__ = 'document'
#
# def __init__(self, plugin_name: str, doc: PluginDocument):
# super().__init__()
# self.owner = doc.owner
# self.plugin_name = plugin_name
# self.plugin_document_id = doc.id
#
# document_id = Column(Integer(), primary_key=True)
# owner = Column(Integer(), ForeignKey('user.id'))
# plugin_name = Column(String(256))
# plugin_document_id = Column(Integer())
#
# Path: models/plugin_document.py
# class PluginDocument(object):
# """Abstract class for all plugins to make their own document type."""
#
# def __init__(self):
# super().__init__()
# if self.__class__ is PluginDocument:
# raise NotImplementedError
#
# id = Column(Integer(), primary_key=True)
# @declared_attr
# def owner(cls):
# return Column(Integer(), ForeignKey('user.id'))
# title = Column(String(256))
# last_modified = Column(Integer())
# description = Column(Text())
. Output only the next line. | def create(self, pdoc: PluginDocument): |
Continue the code snippet: <|code_start|>"""This plugin can search other plugins, list them and auto-load some plugins."""
class Plugins(Plugin):
auto_load_list_file = 'plugins/plugins/auto_load_list'
def __init__(self):
super().__init__()
for p in self.auto_load_list:
<|code_end|>
. Use current file imports:
from os import listdir, path
from plugin import Plugin, plugin_manager
and context (classes, functions, or code) from other files:
# Path: plugin.py
# class Plugin:
# class PluginManager:
# class Documents:
# def __init__(self):
# def user(self):
# def process(self, request):
# def unload(self):
# def __init__(self):
# def load_plugin(self, name, reload=False):
# def get_plugins(self):
# def send_request(self, plugin, request):
# def __init__(self, plugin: Plugin):
# def set_document_type(self, name: str):
# def set_document_table(self, table):
# def get(self, pid):
# def list(self, owner):
# def create(self, pdoc: PluginDocument):
# def update(pdoc: PluginDocument):
# def delete(self, pdoc: PluginDocument):
. Output only the next line. | plugin_manager.load_plugin(p) |
Using the snippet: <|code_start|>
def random_string(N):
return ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for i in range(N))
class User(TableBase, UserMixin):
"""A user."""
__tablename__ = 'user'
<|code_end|>
, determine the next line of code. You have imports:
from database import TableBase, Column, Integer, String, session, Text, MEDIUMTEXT
from flask_login import UserMixin
import hashlib
import random
import string
import os
and context (class names, function names, or code) available:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | id = Column(Integer, primary_key=True) |
Here is a snippet: <|code_start|>
def random_string(N):
return ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for i in range(N))
class User(TableBase, UserMixin):
"""A user."""
__tablename__ = 'user'
<|code_end|>
. Write the next line using the current file imports:
from database import TableBase, Column, Integer, String, session, Text, MEDIUMTEXT
from flask_login import UserMixin
import hashlib
import random
import string
import os
and context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
, which may include functions, classes, or code. Output only the next line. | id = Column(Integer, primary_key=True) |
Using the snippet: <|code_start|>
def random_string(N):
return ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for i in range(N))
class User(TableBase, UserMixin):
"""A user."""
__tablename__ = 'user'
id = Column(Integer, primary_key=True)
<|code_end|>
, determine the next line of code. You have imports:
from database import TableBase, Column, Integer, String, session, Text, MEDIUMTEXT
from flask_login import UserMixin
import hashlib
import random
import string
import os
and context (class names, function names, or code) available:
# Path: database.py
# def get_session():
# def teardown_session(exception):
. Output only the next line. | email = Column(String(63), unique=True) |
Predict the next line for this snippet: <|code_start|> if os.getenv('FLASK_TESTING'):
avatar = Column(String(16777215))
else:
avatar = Column(MEDIUMTEXT())
description = Column(Text())
education = Column(Text())
major = Column(Text())
def __init__(self, email, password, username):
self.email = email
self.set_password(password)
self.username = username
def set_password(self, password):
"""hash and save the password"""
self.salt = random_string(10)
s = hashlib.sha256()
s.update(password.encode('utf-8'))
s.update(self.salt.encode('utf-8'))
self.passwordhash = s.hexdigest()
def check_password(self, password):
"""hash and check the password"""
s = hashlib.sha256()
s.update(password.encode('utf-8'))
s.update(self.salt.encode('utf-8'))
return self.passwordhash == s.hexdigest()
@classmethod
def get_user_by_email(cls, email):
<|code_end|>
with the help of current file imports:
from database import TableBase, Column, Integer, String, session, Text, MEDIUMTEXT
from flask_login import UserMixin
import hashlib
import random
import string
import os
and context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
, which may contain function names, class names, or code. Output only the next line. | return session.query(cls).filter_by(email=email).first() |
Here is a snippet: <|code_start|>
def random_string(N):
return ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for i in range(N))
class User(TableBase, UserMixin):
"""A user."""
__tablename__ = 'user'
id = Column(Integer, primary_key=True)
email = Column(String(63), unique=True)
passwordhash = Column(String(127), nullable=False)
salt = Column(String(127), nullable=False)
username = Column(String(127))
if os.getenv('FLASK_TESTING'):
avatar = Column(String(16777215))
else:
avatar = Column(MEDIUMTEXT())
<|code_end|>
. Write the next line using the current file imports:
from database import TableBase, Column, Integer, String, session, Text, MEDIUMTEXT
from flask_login import UserMixin
import hashlib
import random
import string
import os
and context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
, which may include functions, classes, or code. Output only the next line. | description = Column(Text()) |
Predict the next line for this snippet: <|code_start|>
def random_string(N):
return ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for i in range(N))
class User(TableBase, UserMixin):
"""A user."""
__tablename__ = 'user'
id = Column(Integer, primary_key=True)
email = Column(String(63), unique=True)
passwordhash = Column(String(127), nullable=False)
salt = Column(String(127), nullable=False)
username = Column(String(127))
if os.getenv('FLASK_TESTING'):
avatar = Column(String(16777215))
else:
<|code_end|>
with the help of current file imports:
from database import TableBase, Column, Integer, String, session, Text, MEDIUMTEXT
from flask_login import UserMixin
import hashlib
import random
import string
import os
and context from other files:
# Path: database.py
# def get_session():
# def teardown_session(exception):
, which may contain function names, class names, or code. Output only the next line. | avatar = Column(MEDIUMTEXT()) |
Using the snippet: <|code_start|> subprocess.check_output('gcc -o ../logparser/SLCT/slct -O2 ../logparser/SLCT/cslct.c',
stderr=subprocess.STDOUT, shell=True)
except:
print("Compile error! Please check GCC installed.\n")
raise
headers, regex = generate_logformat_regex(log_format)
df_log = log_to_dataframe(logname, regex, headers, log_format)
# Generate input file
with open('slct_input.log', 'w') as fw:
for line in df_log['Content']:
if rex:
for currentRex in rex:
line = re.sub(currentRex, '<*>', line)
fw.write(line + '\n')
# Run SLCT command
SLCT_command = extract_command(para, "slct_input.log")
try:
print ("Run SLCT...\n>> {}".format(SLCT_command))
subprocess.check_call(SLCT_command, shell=True)
except:
print("SLCT executable is invalid! Please compile it using GCC.\n")
raise
# Collect and dump templates
tempParameter = TempPara(path = "./", savePath=para['savePath'], logname="slct_input.log")
tempProcess(tempParameter)
<|code_end|>
, determine the next line of code. You have imports:
import sys
import hashlib
import pandas as pd
import re
import subprocess
import os
from datetime import datetime
from ..logmatch import regexmatch
and context (class names, function names, or code) available:
# Path: logparser/logmatch/regexmatch.py
# class PatternMatch(object):
# def __init__(self, outdir='./result/', n_workers=1, optimized=False, logformat=None):
# def add_event_template(self, event_template, event_Id=None):
# def _generate_template_regex(self, template):
# def match_event(self, event_list):
# def read_template_from_csv(self, template_filepath):
# def match(self, log_filepath, template_filepath):
# def _dump_match_result(self, log_filename, log_dataframe):
# def _generate_hash_eventId(self, template_str):
# def _get_parameter_list(self, row):
# def match_fn(event_list, template_match_dict, optimized=True):
# def regex_match(msg, template_match_dict, optimized):
. Output only the next line. | matcher = regexmatch.PatternMatch(outdir=para['savePath'], logformat=log_format)
|
Given the following code snippet before the placeholder: <|code_start|>
class Chromosome:
""" A chromosome in this class is a dictionary
key: int
value: List[Templates]
"""
def __init__(self, p_templates: dict()):
""" The constructor with an attribute of type List of Template
:param p_templates: a dictionary of Template
"""
self.templates = p_templates
self.coverage = 0
<|code_end|>
, predict the next line using imports from the current file:
from .template import Template
and context including class names, function names, and sometimes code from other files:
# Path: logparser/MoLFI/main/org/core/chromosome/template.py
# class Template:
# """ An object representing the smallest element of a chromosome which is a template
# Template is a list of strings
# """
#
# def __init__(self, p_template: List[str]):
# """ The constructor of the Class Template
# initialize the object with a list of strings
# and initialize the frequency and specificity with 0.0
# and an empty list that will contain the line number matching the template
# """
# self.token = p_template
# self.specificity = 0.0
# self.matched_lines = []
# self.changed = True
#
# def get_length(self):
# """ Gets the number of strings in the list
# """
# return len(self.token)
#
# def to_string(self):
# """ Returns the template's token as one string
# """
# s = "[ "
# for i in self.token:
# s = s+i+' '
#
# s = s + ']'
# return s
#
# def is_changed(self):
# """ Returns the status of the template (changed or did not change)
# """
# return self.changed
#
# def set_changed(self, p_changed : bool):
# """ Sets the status of a template to True if one of its tokens changes,
# else the status is False (not changed)
# """
# self.changed = p_changed
. Output only the next line. | def add_template(self, template: Template):
|
Predict the next line after this snippet: <|code_start|>
is_hex1 = re.findall('(^|\s)([0-9a-f]){8,}(\s|$)', log_message)
if is_hex1:
log_message = re.sub('(^|\s)([0-9a-f]){8,}(\s|$)', sub_sign, log_message)
is_mac_address = re.findall('([0-9A-F]{2}[:-]){5,}([0-9A-F]{2})', log_message)
if is_mac_address:
log_message = re.sub('([0-9A-F]{2}[:-]){5,}([0-9A-F]{2})', sub_sign, log_message)
is_number = re.findall('(^| )\d+( |$)', log_message)
if is_number:
log_message = re.sub('(^| )\d+( |$)', sub_sign, log_message)
# add space around '-->' [=:,] <> () [ ] { }
log_message = re.sub("([<>=:,;'\(\)\{\}\[\]])", r' \1 ', log_message)
# regex is empty if not given as parameter
if regex is None:
regex = []
for i in range(len(regex)):
match = re.findall(regex[i], log_message)
if match:
log_message = re.sub(regex[i], sub_sign, log_message)
# let's identify the prefixes that we don't have to change
prefix_regex = "^[ ]*\[[A-Z *]+\]"
match = re.findall(prefix_regex, log_message)
if len(match) > 0:
log_message = log_message.replace(match[0], match[0].replace(' ', ''))
log_message = log_message.replace("-- >", "-->")
<|code_end|>
using the current file's imports:
import re
from numpy.core.defchararray import startswith
from ..utility.message import Message
and any relevant context from other files:
# Path: logparser/MoLFI/main/org/core/utility/message.py
# class Message:
# """ This class represents a log message as a list of strings
# """
#
# def __init__(self, p_message: List[str]):
# """ Initialize the objet with an list of strings
# :param p_message
# """
# self.words = p_message
#
# def get_length(self):
# """ Get the number of strings in the list
# """
# return len(self.words)
#
# def to_string(self):
# """ Convert the list of words to one string
# """
# string = ""
# for index in range(0, len(self.words)):
# if index < len(self.words) - 1:
# string = string + self.words[index] + " "
# else:
# string = string + self.words[index]
# return string
. Output only the next line. | message = Message(log_message.split())
|
Predict the next line after this snippet: <|code_start|>#!/usr/bin/env python
sys.path.append('../')
input_dir = '../logs/HDFS/' # The input directory
output_dir = 'logmatch_result/' # The result directory
log_filepath = input_dir + 'HDFS_2k.log' # The input log file path
log_format = '<Date> <Time> <Pid> <Level> <Component>: <Content>' # HDFS log format
n_workers = 1 # The number of workers in parallel
template_filepath = log_filepath + '_templates.csv' # The event template file path
if __name__ == "__main__":
<|code_end|>
using the current file's imports:
import sys
from logparser.logmatch import regexmatch
and any relevant context from other files:
# Path: logparser/logmatch/regexmatch.py
# class PatternMatch(object):
# def __init__(self, outdir='./result/', n_workers=1, optimized=False, logformat=None):
# def add_event_template(self, event_template, event_Id=None):
# def _generate_template_regex(self, template):
# def match_event(self, event_list):
# def read_template_from_csv(self, template_filepath):
# def match(self, log_filepath, template_filepath):
# def _dump_match_result(self, log_filename, log_dataframe):
# def _generate_hash_eventId(self, template_str):
# def _get_parameter_list(self, row):
# def match_fn(event_list, template_match_dict, optimized=True):
# def regex_match(msg, template_match_dict, optimized):
. Output only the next line. | matcher = regexmatch.PatternMatch(outdir=output_dir, n_workers=n_workers, logformat=log_format)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.