Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Here is a snippet: <|code_start|>
def StripLabel(self,line,line_num,col_num,next):
# deferred to subclass
return line
# ---------------------------------------------------------------------------
def StripContMark(self,line,line_num,col_num,next):
# deferred to subclass
return line
# ---------------------------------------------------------------------------
def StripContQuote(self,line,line_num,col_num,next):
# deferred to subclass
return line
# ---------------------------------------------------------------------------
def AppendAttribute(self, att):
# If a continuation marker is written, a previously written
# end of statement marker is invalid and must be removed. An
# eos marker can not have any attributes, so no need to check this.
# It is more efficient to remove a previously appended marker than
# checking whenever a tok_SEPARATOR is written if the next (non
# comment, ...) line is not a continuation (at least for fixed format):
# 1) we had to find the next non-{comment, pre-directive,
# compiler-directive} line - which involves regexp comparisons
# 2) Many more lines are not continued (i.e. the marker doesn't
# have to be removed) than continued, so we remove less lines
# than we had to check otherwise
<|code_end|>
. Write the next line using the current file imports:
import re
from string import expandtabs,rstrip,lstrip,strip, upper
from Token import Token, Token2Name
from AOR.AttributeString import AttributeString
from AOR.SpecialStatements import Comment, ContMarker, CommentLine
from Tools.Project import Project
from Tools.Project import Project
from Test.ScannerTest import RunAllTests
and context from other files:
# Path: AOR/AttributeString.py
# class AttributeString(str):
# def __init__(self, s):
# str.__init__(self, s)
# # If this object is initialised with an AttributeString,
# # copy the attributes as well
# if isinstance(s, AttributeString):
# self.lPrefix = s.GetPrefixAttributes()[:]
# self.lPostfix = s.GetPostfixAttributes()[:]
# else:
# self.lPrefix = []
# self.lPostfix = []
# # --------------------------------------------------------------------------
# # Creates a new attribute string which has the same pre- and postfix
# # attributes, but a new string.
# def sCreateCopy(self, s):
# new = AttributeString(s)
# new.SetPrefixAttributes(self.GetPrefixAttributes())
# new.SetPostfixAttributes(self.GetPostfixAttributes())
# return new
# # --------------------------------------------------------------------------
# # Splits an AttributeString into two strings, the first one containing
# # all prefix attributes, the second one all postfix ones. The parameter
# # n specified the number of character to for the first string.
# def tSplitString(self, n):
# s1 = AttributeString(self[0:n])
# s2 = AttributeString(self[n: ])
# s1.SetPrefixAttributes(self.GetPrefixAttributes())
# s2.SetPostfixAttributes(self.GetPostfixAttributes())
# return s1,s2
# # --------------------------------------------------------------------------
# def SetPrefixAttributes(self, l) : self.lPrefix = l[:]
# # --------------------------------------------------------------------------
# def SetPostfixAttributes(self, l) : self.lPostfix = l[:]
# # --------------------------------------------------------------------------
# def AppendPrefix(self, o):
# if type(o)==ListType:
# self.lPrefix.extend(o)
# else:
# self.lPrefix.append(o)
# # --------------------------------------------------------------------------
# def AppendPostfix(self, o):
# if type(o)==ListType:
# self.lPostfix.extend(o)
# else:
# self.lPostfix.append(o)
# # --------------------------------------------------------------------------
# def GetPrefixAttributes(self ): return self.lPrefix
# # --------------------------------------------------------------------------
# def GetPostfixAttributes(self): return self.lPostfix
# # --------------------------------------------------------------------------
# def GetString(self): return str.__str__(self)
# # --------------------------------------------------------------------------
# # We have to overwrite this method so that a new AttributeString is
# # returned!
# def upper(self):
# return self.sCreateCopy(str.__str__(self).upper())
# # --------------------------------------------------------------------------
# # We have to overwrite this method so that a new AttributeString is
# # returned!
# def lower(self):
# return self.sCreateCopy(str.__str__(self).lower())
# # --------------------------------------------------------------------------
# # We have to overwrite this method so that a new AttributeString is
# # returned!
# def capitalize(self):
# return self.sCreateCopy(str.__str__(self).capitalize())
# # --------------------------------------------------------------------------
# #def ToList(self, stylesheet, l): return l.append(str.__str__(self))
# def ToList(self, stylesheet, l): return l.append(self)
# # --------------------------------------------------------------------------
# #def __repr__(self): return str.__str__(self)
# # Debug: output an attribute string with all attributes
# def __repr__(self):
# return "%s-%s-%s"%(`self.lPrefix`,str.__str__(self),`self.lPostfix`)
#
# Path: AOR/SpecialStatements.py
# class Comment(BasicNonStatement):
# def __init__(self, sComment, loc):
# BasicNonStatement.__init__(self, sComment, loc)
#
# class ContMarker(BasicNonStatement):
# def __init__(self, sContMarker, loc):
# BasicNonStatement.__init__(self, sContMarker, loc)
#
# class CommentLine(BasicNonStatement):
# def __init__(self, sComment, loc=None):
# BasicNonStatement.__init__(self, sComment, loc)
, which may include functions, classes, or code. Output only the next line. | if att.__class__==ContMarker: |
Continue the code snippet: <|code_start|> specific tokens
"""
text = self.GetLines()
# some aspects of fortran are context dependant, eg in free form only
# look for a label at the start of a statement, and a leading continuation
# marker if a trailing one was found on the previous line. line_type
# indicates the current context
line_type = self.NEW_STATEMENT
i = -1
while i<len(text)-1:
i = i+1
line_num = i+1
# untangle tab stops right upfront
line = expandtabs(rstrip(text[i]))
# catch compiler directives
if self.re_directive.match(line):
col_num = len(line)-len(lstrip(line)) + 1
self.AppendToken(line_num, col_num, self.tok_DIRECTIVE, line)
self.AppendToken(line_num, len(line), self.tok_SEPARATOR, "")
continue
# catch other comment lines (which includes empty lines)
if line.strip()=='' or self.re_commentline.match(line):
col_num = len(line)-len(lstrip(line)) + 1
if line_type!=self.NEW_STATEMENT:
<|code_end|>
. Use current file imports:
import re
from string import expandtabs,rstrip,lstrip,strip, upper
from Token import Token, Token2Name
from AOR.AttributeString import AttributeString
from AOR.SpecialStatements import Comment, ContMarker, CommentLine
from Tools.Project import Project
from Tools.Project import Project
from Test.ScannerTest import RunAllTests
and context (classes, functions, or code) from other files:
# Path: AOR/AttributeString.py
# class AttributeString(str):
# def __init__(self, s):
# str.__init__(self, s)
# # If this object is initialised with an AttributeString,
# # copy the attributes as well
# if isinstance(s, AttributeString):
# self.lPrefix = s.GetPrefixAttributes()[:]
# self.lPostfix = s.GetPostfixAttributes()[:]
# else:
# self.lPrefix = []
# self.lPostfix = []
# # --------------------------------------------------------------------------
# # Creates a new attribute string which has the same pre- and postfix
# # attributes, but a new string.
# def sCreateCopy(self, s):
# new = AttributeString(s)
# new.SetPrefixAttributes(self.GetPrefixAttributes())
# new.SetPostfixAttributes(self.GetPostfixAttributes())
# return new
# # --------------------------------------------------------------------------
# # Splits an AttributeString into two strings, the first one containing
# # all prefix attributes, the second one all postfix ones. The parameter
# # n specified the number of character to for the first string.
# def tSplitString(self, n):
# s1 = AttributeString(self[0:n])
# s2 = AttributeString(self[n: ])
# s1.SetPrefixAttributes(self.GetPrefixAttributes())
# s2.SetPostfixAttributes(self.GetPostfixAttributes())
# return s1,s2
# # --------------------------------------------------------------------------
# def SetPrefixAttributes(self, l) : self.lPrefix = l[:]
# # --------------------------------------------------------------------------
# def SetPostfixAttributes(self, l) : self.lPostfix = l[:]
# # --------------------------------------------------------------------------
# def AppendPrefix(self, o):
# if type(o)==ListType:
# self.lPrefix.extend(o)
# else:
# self.lPrefix.append(o)
# # --------------------------------------------------------------------------
# def AppendPostfix(self, o):
# if type(o)==ListType:
# self.lPostfix.extend(o)
# else:
# self.lPostfix.append(o)
# # --------------------------------------------------------------------------
# def GetPrefixAttributes(self ): return self.lPrefix
# # --------------------------------------------------------------------------
# def GetPostfixAttributes(self): return self.lPostfix
# # --------------------------------------------------------------------------
# def GetString(self): return str.__str__(self)
# # --------------------------------------------------------------------------
# # We have to overwrite this method so that a new AttributeString is
# # returned!
# def upper(self):
# return self.sCreateCopy(str.__str__(self).upper())
# # --------------------------------------------------------------------------
# # We have to overwrite this method so that a new AttributeString is
# # returned!
# def lower(self):
# return self.sCreateCopy(str.__str__(self).lower())
# # --------------------------------------------------------------------------
# # We have to overwrite this method so that a new AttributeString is
# # returned!
# def capitalize(self):
# return self.sCreateCopy(str.__str__(self).capitalize())
# # --------------------------------------------------------------------------
# #def ToList(self, stylesheet, l): return l.append(str.__str__(self))
# def ToList(self, stylesheet, l): return l.append(self)
# # --------------------------------------------------------------------------
# #def __repr__(self): return str.__str__(self)
# # Debug: output an attribute string with all attributes
# def __repr__(self):
# return "%s-%s-%s"%(`self.lPrefix`,str.__str__(self),`self.lPostfix`)
#
# Path: AOR/SpecialStatements.py
# class Comment(BasicNonStatement):
# def __init__(self, sComment, loc):
# BasicNonStatement.__init__(self, sComment, loc)
#
# class ContMarker(BasicNonStatement):
# def __init__(self, sContMarker, loc):
# BasicNonStatement.__init__(self, sContMarker, loc)
#
# class CommentLine(BasicNonStatement):
# def __init__(self, sComment, loc=None):
# BasicNonStatement.__init__(self, sComment, loc)
. Output only the next line. | self.AppendAttribute(CommentLine(line)) |
Based on the snippet: <|code_start|> var=Variable(sName, self.dVarsData[sName.lower()])
for k,v in d.items():
var.SetAttribute(k,v)
# If the variable was undefined up to now, remove the
# undefined attribute. This happens e.g. for arguments,
# which are added as undefined when parsing the subroutine
# statement, and are declared later
if k=="type":
if var['undefined']: del var['undefined']
return var
except KeyError:
if bAutoAdd:
if not d.get('type',None): d['undefined'] = 1
return self.AddVariable(sName, d)
else:
return None
# --------------------------------------------------------------------------
def GetAttributes(self, sName):
return self.dVarsData.get(string.lower(sName), {})
# --------------------------------------------------------------------------
def lGetAllVariables(self):
return self.dVarsData.values()
# --------------------------------------------------------------------------
def SetImplicit(self, type, sFrom, sTo=None):
if not sTo: sTo=sFrom
# If this is the first implicit statement, a dictionary for the type
# mapping is created:
if not self.dImplicit:
self.dImplit={}
for i in 'ABCDEFGHOPQRSTUVWXYZ':
<|code_end|>
, predict the immediate next line with the help of imports:
import string
from Variable import Variable, VariableData
from AOR.Declaration import Type
from AOR.Test.VariablesTest import RunTest
and context (classes, functions, sometimes code) from other files:
# Path: AOR/Declaration.py
# class Type(BasicRepr):
#
# # Constructor. Parameters:
# #
# # sType -- The basic type
# #
# # sType2 -- Used for double precision
# #
# def __init__(self, sType, sType2=None):
# self.sType = sType
# self.sType2 = sType2
# self.sStar = None
# self.len = None
# self.lKind = []
# # --------------------------------------------------------------------------
# def bIsType(self, sType):
# return string.upper(self.sType)==string.upper(sType)
# # --------------------------------------------------------------------------
# def SetStar(self, sStar): self.sStar = sStar
# # --------------------------------------------------------------------------
# def SetLen(self, l) : self.lKind = [l]
# # --------------------------------------------------------------------------
# def SetParOpen(self, sParOpen): self.lKind.append(sParOpen)
# # --------------------------------------------------------------------------
# def SetParClose(self, sParClose): self.lKind.append(sParClose)
# # --------------------------------------------------------------------------
# # Adds the kind information: Either '(5)', or '(kind=5)'
# def AddKindOrLen(self, sKeyword=None, sEqual=None, obj=None, sComma=None):
# if sKeyword:
# self.lKind.append( (sKeyword, sEqual, obj) )
# else:
# self.lKind.append(obj)
# if sComma: self.lKind.append(sComma)
# # --------------------------------------------------------------------------
# # The tuple t is either (keyword,'=',exp) or a single exp obj. This will
# # return a tuple where the keyword is handled by the stylesheet
# def HandleKeywords(self, t, stylesheet, l):
# if type(t)==TupleType:
# l.append(stylesheet.sKeyword(t[0]))
# l.append(t[1])
# stylesheet.ToList(t[2], l)
# else:
# stylesheet.ToList(t, l)
# # --------------------------------------------------------------------------
# # Convert a basic type into a list.
# def ToList(self, stylesheet, l):
# l.append(stylesheet.sKeyword(self.sType))
# if self.sType2:
# l.append(stylesheet.sKeyword(self.sType2))
# if self.sStar:
# l.append(self.sStar)
#
# if not self.lKind:
# return
# # E.g. integer *8
# if len(self.lKind)==1:
# stylesheet.ToList(self.lKind[0], l)
# # E.g. (4) or (KIND=4), since ('KIND','=',4) is a single tuple.
# elif len(self.lKind)==3:
# l.append(self.lKind[0]) # (
# self.HandleKeywords(self.lKind[1], stylesheet, l) # 3
# l.append(self.lKind[2]) # )
# # E.g. (3, len=5)
# else:
# l.append(self.lKind[0]) # (
# self.HandleKeywords(self.lKind[1],stylesheet, l) # 4
# l.append(self.lKind[2]) # ,
# self.HandleKeywords(self.lKind[3], stylesheet, l) # 5
# l.append(self.lKind[4], nIndentNext=1) # )
. Output only the next line. | self.dImplicit[i] = Type('REAL') |
Given the following code snippet before the placeholder: <|code_start|> # --------------------------------------------------------------------------
# Adds a sqrt:
# | a |
def abs(self):
self.MoveRight(1)
for i in range(self.nHeight):
self.lElements.insert(0, "|")
self.lPosX.insert(0, 0)
self.lPosY.insert(0, i)
self.lElements.append("|")
self.lPosX.append(self.nWidth+1)
self.lPosY.append(i)
self.nWidth = self.nWidth + 2
return
# ==============================================================================
# A special layout2d class, where each entry is on a new line
class MultiLine2d(Layout2d):
def __init__(self):
Layout2d.__init__(self)
self.nHeight = 0
# --------------------------------------------------------------------------
def append(self, o, attribute=None, nIndent = 0, nIndentNext = 0):
if isinstance(o, Layout2d) and o.nHeight>1:
o.MoveDown(1)
o.nHeight = o.nHeight + 1
self.nWidth = max(self.nWidth, len(o))
self.lElements.append(o)
self.lPosX.append(0)
self.lPosY.append(self.nHeight)
<|code_end|>
, predict the next line using imports from the current file:
from types import StringType
from AOR.AttributeString import AttributeString
import sys
and context including class names, function names, and sometimes code from other files:
# Path: AOR/AttributeString.py
# class AttributeString(str):
# def __init__(self, s):
# str.__init__(self, s)
# # If this object is initialised with an AttributeString,
# # copy the attributes as well
# if isinstance(s, AttributeString):
# self.lPrefix = s.GetPrefixAttributes()[:]
# self.lPostfix = s.GetPostfixAttributes()[:]
# else:
# self.lPrefix = []
# self.lPostfix = []
# # --------------------------------------------------------------------------
# # Creates a new attribute string which has the same pre- and postfix
# # attributes, but a new string.
# def sCreateCopy(self, s):
# new = AttributeString(s)
# new.SetPrefixAttributes(self.GetPrefixAttributes())
# new.SetPostfixAttributes(self.GetPostfixAttributes())
# return new
# # --------------------------------------------------------------------------
# # Splits an AttributeString into two strings, the first one containing
# # all prefix attributes, the second one all postfix ones. The parameter
# # n specified the number of character to for the first string.
# def tSplitString(self, n):
# s1 = AttributeString(self[0:n])
# s2 = AttributeString(self[n: ])
# s1.SetPrefixAttributes(self.GetPrefixAttributes())
# s2.SetPostfixAttributes(self.GetPostfixAttributes())
# return s1,s2
# # --------------------------------------------------------------------------
# def SetPrefixAttributes(self, l) : self.lPrefix = l[:]
# # --------------------------------------------------------------------------
# def SetPostfixAttributes(self, l) : self.lPostfix = l[:]
# # --------------------------------------------------------------------------
# def AppendPrefix(self, o):
# if type(o)==ListType:
# self.lPrefix.extend(o)
# else:
# self.lPrefix.append(o)
# # --------------------------------------------------------------------------
# def AppendPostfix(self, o):
# if type(o)==ListType:
# self.lPostfix.extend(o)
# else:
# self.lPostfix.append(o)
# # --------------------------------------------------------------------------
# def GetPrefixAttributes(self ): return self.lPrefix
# # --------------------------------------------------------------------------
# def GetPostfixAttributes(self): return self.lPostfix
# # --------------------------------------------------------------------------
# def GetString(self): return str.__str__(self)
# # --------------------------------------------------------------------------
# # We have to overwrite this method so that a new AttributeString is
# # returned!
# def upper(self):
# return self.sCreateCopy(str.__str__(self).upper())
# # --------------------------------------------------------------------------
# # We have to overwrite this method so that a new AttributeString is
# # returned!
# def lower(self):
# return self.sCreateCopy(str.__str__(self).lower())
# # --------------------------------------------------------------------------
# # We have to overwrite this method so that a new AttributeString is
# # returned!
# def capitalize(self):
# return self.sCreateCopy(str.__str__(self).capitalize())
# # --------------------------------------------------------------------------
# #def ToList(self, stylesheet, l): return l.append(str.__str__(self))
# def ToList(self, stylesheet, l): return l.append(self)
# # --------------------------------------------------------------------------
# #def __repr__(self): return str.__str__(self)
# # Debug: output an attribute string with all attributes
# def __repr__(self):
# return "%s-%s-%s"%(`self.lPrefix`,str.__str__(self),`self.lPostfix`)
. Output only the next line. | if type(o) is StringType or type(o) is AttributeString: |
Given the code snippet: <|code_start|># Since this can be ignored for the scanner tests (project is only needed
# for include file name resolution), we just 'pass' in case of an error.
try:
except ImportError:
pass
class Project:
dConfig = {}
dAddFileInfo = {'amip1sst.F' : {'linelength':132},
'landmask.F' : {'linelength':132},
'sstmskgh.F' : {'linelength':132},
'mod_calendar.F90' : {'linelength':132},
'cuascn.intfb.h' : {'format':"free"},
'cubasen.intfb.h' : {'format':"free"},
'cubasmcn.intfb.h' : {'format':"free"},
'cubidiag.intfb.h' : {'format':"free"},
'cuctracer.intfb.h': {'format':"free"},
'cuddrafn.intfb.h' : {'format':"free"},
'cudlfsn.intfb.h' : {'format':"free"},
'cudtdqn.intfb.h' : {'format':"free"},
'cududvn.intfb.h' : {'format':"free"},
'cududvn.intfb.h' : {'format':"free"},
'cuentrn.intfb.h' : {'format':"free"},
'cuflxn.intfb.h' : {'format':"free"},
'cuinin.intfb.h' : {'format':"free"},
'sucumfn.intfb.h' : {'format':"free"},
'fcttre_new.h' : {'format':"free", 'linelength':132},
'zevpmx.F': {'linelength':132} }
def __init__(self,sProject=None):
self.dConfig = Project.dConfig
<|code_end|>
, generate the next line using the imports in this file:
import os
from Tools.Cache import Cache
from Grammar.Parser import Parser
and context (functions, classes, or occasionally code) from other files:
# Path: Tools/Cache.py
# class Cache:
# def __init__(self, nSize=10, sProject=""):
# try:
# from Tools.Database import Database
# self.DB=Database(sProject)
# except:
# self.DB=None
#
# self.nSize = nSize
# # lCache contains pointers to the objects, and is used to implement
# # a last recently used strategy
# # dcache is used to find the information quickly.
# self.lCache = []
# self.dCache = {}
# # --------------------------------------------------------------------------
# def DeleteFile(self, oFile):
# if self.dCache.get(oFile.sGetFilename(), None) == None: return
# for i in range(len(self.lCache)):
# if self.lCache[i]==oFile:
# print "Deleting '%s' from cache"%oFile.sGetFilename()
# del self.lCache[i]
# del self.dCache[oFile.sGetFilename()]
# return
# # --------------------------------------------------------------------------
# def Store(self, oFile, bNoDBUpdate=0):
# sFilename = oFile.sGetFilename()
# nCount = 0
# oldObj = self.dCache.get(sFilename, None)
# if oldObj:
# for i in self.lCache:
# if i == oldObj:
# self.lCache[nCount ] = oFile
# self.dCache[sFilename] = oFile
# break
# nCount=nCount + 1
# else:
# # Otherwise put the file into the cache list
# while len(self.lCache)>=self.nSize:
# print len(self.lCache), self.nSize
# nOldLen = len(self.lCache)
# self.DeleteFile(self.lCache[-1])
# if nOldLen==len(self.lCache):
# print "Deadloch, last entry not removed",nOldLen,len(self.lCache)
# print "lCache:"
# for i in self.lCache:
# print i.sGetFilename()
# print "dCache:"
# for i,j in self.dCache.items():
# print i,j.sGetFilename()
# import sys
# sys.exit(-1)
# self.dCache[sFilename]=oFile
# self.lCache = [oFile] + self.lCache
#
# # Now remove a previously existing copy from the datbase backend
# if not bNoDBUpdate and self.DB:
# self.DB.AddFile(oFile)
#
# # --------------------------------------------------------------------------
# def oGetFile(self, sIdentifier, sType):
# # First check the cache
# if sType=="file":
# oFile = self.dCache.get(sIdentifier, None)
# if oFile!=None:
# print "Returning %s from cache, moving to front of list"%sIdentifier
# # Well, some overhead here, but easy to implement :)
# self.DeleteFile(oFile)
# self.Store(oFile, bNoDBUpdate=1)
# return self.lCache[n]
# else:
# for oFile in self.lCache:
# o = oFile.GetIdentifier(sIdentifier, sType)
# if o:
# print "Returning '%s' of type '%s' from cache, moving to front of list"%\
# (sIdentifier, sType)
# self.DeleteFile(oFile)
# self.Store(oFile, bNoDBUpdate=1)
# return o
# # Now try to get the object from the database backend
# if self.DB:
# oFile = self.DB.oGetFile(sIdentifier, sType)
# if self.DB and oFile:
# if sType=="file":
# o = oFile
# else:
# o = oFile.GetIdentifier(sIdentifier, sType)
# print "Returning '%s' from database, storing in cache"%sIdentifier
# self.DeleteFile(oFile)
# self.Store(oFile, bNoDBUpdate=1)
# return o
# return None
. Output only the next line. | self.Cache = Cache(nSize=10, sProject=sProject) |
Given the code snippet: <|code_start|>#! /usr/bin/env python
# This is the base class for all output functions
class Output(Config):
# Constructor. Parameter:
#
# f -- file object to output
def __init__(self, f, nMaxCols=72, sFormat='fixed'):
dClass2Func = { Comment : self.CommentLine,
<|code_end|>
, generate the next line using the imports in this file:
import string
import sys
import getopt
import profile
from UserList import UserList
from AOR.Subroutine import Subroutine
from AOR.Function import Function
from AOR.Program import Program
from AOR.AttributeString import Comment
from Tools.Config import Config
from Grammar.Parser import Parser
from AOR.AttributeString import Comment
from Analyser.Interface import GenerateInterface
and context (functions, classes, or occasionally code) from other files:
# Path: AOR/Subroutine.py
# class Subroutine(ProgUnit):
# # Constructor for a subroutine object. Parameter:
# #
# # sSubName -- Name of function
# #
# def __init__(self, subStatement=None):
# ProgUnit.__init__(self, subStatement)
#
# Path: AOR/Function.py
# class Function(ProgUnit):
# # Constructor for a subroutine object. Parameter:
# #
# # sSubName -- Name of function
# #
# def __init__(self, FuncStatement):
# ProgUnit.__init__(self, FuncStatement)
#
# Path: AOR/Program.py
# class Program(ProgUnit):
# # Constructor for a program object. Parameter:
# #
# # sProgName -- Name of function
# #
# def __init__(self, progStatement=None):
# ProgUnit.__init__(self, progStatement)
#
# Path: AOR/AttributeString.py
# class AttributeString(str):
# def __init__(self, s):
# def sCreateCopy(self, s):
# def tSplitString(self, n):
# def SetPrefixAttributes(self, l) : self.lPrefix = l[:]
# def SetPostfixAttributes(self, l) : self.lPostfix = l[:]
# def AppendPrefix(self, o):
# def AppendPostfix(self, o):
# def GetPrefixAttributes(self ): return self.lPrefix
# def GetPostfixAttributes(self): return self.lPostfix
# def GetString(self): return str.__str__(self)
# def upper(self):
# def lower(self):
# def capitalize(self):
# def ToList(self, stylesheet, l): return l.append(self)
# def __repr__(self):
#
# Path: Tools/Config.py
# class Config:
# # Class attribut with all general (i.e. not format specific)
# # attributes
# dDefault = { 'stylesheet' : {'labelalignright' : 1,
# 'indent' : 3,
# 'keywordcase' : 'upper',
# 'variablecase' : 'lower',
# 'contlinemarker' : '&',
# 'spacebetweencommalist': 1,
# 'format' : 'fixed',
# 'maxcols' : {'fixed' : 72, 'free' : 132},
# 'startcolumn' : {'fixed' : 7, 'free' : 1},
# },
# 'files' : {'amip1sst.F': {'linelength':132},
# 'landmask.F': {'linelength':132},
# 'sstmskgh.F': {'linelength':132},
# 'zevpmx.F' : {'linelength':132}
# },
# 'project' : {'paths' : [".","whatever/directory"]
# },
# }
#
# # Special character used to separate entries for dictionary in dict in ...
# # e.g.: "project|paths" instead of ["project"]["path"]
# sSeparatorChar = "|"
#
# # The actual configuration information (as a class variable)
# dConfig = {}
# # --------------------------------------------------------------------------
# # Init: save the config filename and read the config file
# def __init__(self, sConfigFilename="stanrc"):
# if not Config.dConfig:
# Config.sConfigFilename=sConfigFilename
# self.GetConfig()
#
# # -------------------------------------------------------------------------
# def GetConfig(self):
# # Try reading the config file. If it doesn't exist (or any other
# # error occurs), get the default values
# try:
# f=open(Config.sConfigFilename,'r')
# l=f.readlines()
# f.close()
# s="\n".join(l)
# Config.dConfig=eval(s)
# except IOError:
# Config.dConfig = Config.dDefault.copy()
# self.WriteConfigFile()
#
# # -------------------------------------------------------------------------
# # Save the config dictionary
# def WriteConfigFile(self):
# try:
# f=open(Config.sConfigFilename,'w')
# except IOError:
# print "Couldn't open",Config.sConfigFilename
# return
# f.write(`Config.dConfig`)
# f.write("\n")
# f.close()
#
# # -------------------------------------------------------------------------
# # Access to the configuration data via a dictionary like interface.
# # As a shortcut, one can use "|" (see sSeparatorChar) to divide several
# # nested dictionaries, i.e. ["a|b|c"] instead of ["a"]["b"]["b"]
# def __getitem__(self, sKey):
# l = sKey.split(Config.sSeparatorChar)
# d = Config.dConfig
# for i in l:
# d=d.get(i,None)
# if not d:
# return None
# return d
# # -------------------------------------------------------------------------
# # Set configuration data via a dictionary like interface.
# # As a shortcut, one can use "|" (see sSeparatorChar) to divide several
# # nested dictionaries, i.e. ["a|b|c"]=1 instead of ["a"]["b"]["b"]=1
# def __setitem__(self, sKey, value):
# l = sKey.split(Config.sSeparatorChar)
# d = Config.dConfig
# # Follow the tree:
# for i in range(len(l)-1):
# d1=d.get(l[i],None) # goto next dictionary
# # Create new entry for all remaining entries
# if not d1:
# for j in range(i, len(l)-1):
# d[l[j]] = {}
# d = d[l[j]]
# d[l[-1]] = value
# self.WriteConfigFile() # save the modified config file
# return
# d=d1
# d[l[-1]] = value
#
# self.WriteConfigFile() # save the modified config file
. Output only the next line. | Subroutine: self.Subroutine, |
Here is a snippet: <|code_start|> # Adds a sqrt:
# | a |
def abs(self):
self.MoveRight(1)
for i in range(self.nHeight):
self.lElements.insert(0, "|")
self.lPosX.insert(0, 0)
self.lPosY.insert(0, i)
self.lElements.append("|")
self.lPosX.append(self.nWidth+1)
self.lPosY.append(i)
self.nWidth = self.nWidth + 2
return
# ==============================================================================
# A special layout2d class, where each entry is on a new line
class MultiLine2d(Layout2d):
def __init__(self):
Layout2d.__init__(self)
self.nHeight = 0
# --------------------------------------------------------------------------
def append(self, o, attribute=None, nIndent = 0, nIndentNext = 0):
# Add one empty line at top for real multi-line objects
if isinstance(o, Layout2d) and o.nHeight>1:
o.MoveDown(1)
o.nHeight = o.nHeight + 1
self.nWidth = max(self.nWidth, len(o))
self.lElements.append(o)
self.lPosX.append(0)
self.lPosY.append(self.nHeight)
<|code_end|>
. Write the next line using the current file imports:
import string
import sys
from types import StringType
from AOR.AttributeString import AttributeString
and context from other files:
# Path: AOR/AttributeString.py
# class AttributeString(str):
# def __init__(self, s):
# str.__init__(self, s)
# # If this object is initialised with an AttributeString,
# # copy the attributes as well
# if isinstance(s, AttributeString):
# self.lPrefix = s.GetPrefixAttributes()[:]
# self.lPostfix = s.GetPostfixAttributes()[:]
# else:
# self.lPrefix = []
# self.lPostfix = []
# # --------------------------------------------------------------------------
# # Creates a new attribute string which has the same pre- and postfix
# # attributes, but a new string.
# def sCreateCopy(self, s):
# new = AttributeString(s)
# new.SetPrefixAttributes(self.GetPrefixAttributes())
# new.SetPostfixAttributes(self.GetPostfixAttributes())
# return new
# # --------------------------------------------------------------------------
# # Splits an AttributeString into two strings, the first one containing
# # all prefix attributes, the second one all postfix ones. The parameter
# # n specified the number of character to for the first string.
# def tSplitString(self, n):
# s1 = AttributeString(self[0:n])
# s2 = AttributeString(self[n: ])
# s1.SetPrefixAttributes(self.GetPrefixAttributes())
# s2.SetPostfixAttributes(self.GetPostfixAttributes())
# return s1,s2
# # --------------------------------------------------------------------------
# def SetPrefixAttributes(self, l) : self.lPrefix = l[:]
# # --------------------------------------------------------------------------
# def SetPostfixAttributes(self, l) : self.lPostfix = l[:]
# # --------------------------------------------------------------------------
# def AppendPrefix(self, o):
# if type(o)==ListType:
# self.lPrefix.extend(o)
# else:
# self.lPrefix.append(o)
# # --------------------------------------------------------------------------
# def AppendPostfix(self, o):
# if type(o)==ListType:
# self.lPostfix.extend(o)
# else:
# self.lPostfix.append(o)
# # --------------------------------------------------------------------------
# def GetPrefixAttributes(self ): return self.lPrefix
# # --------------------------------------------------------------------------
# def GetPostfixAttributes(self): return self.lPostfix
# # --------------------------------------------------------------------------
# def GetString(self): return str.__str__(self)
# # --------------------------------------------------------------------------
# # We have to overwrite this method so that a new AttributeString is
# # returned!
# def upper(self):
# return self.sCreateCopy(str.__str__(self).upper())
# # --------------------------------------------------------------------------
# # We have to overwrite this method so that a new AttributeString is
# # returned!
# def lower(self):
# return self.sCreateCopy(str.__str__(self).lower())
# # --------------------------------------------------------------------------
# # We have to overwrite this method so that a new AttributeString is
# # returned!
# def capitalize(self):
# return self.sCreateCopy(str.__str__(self).capitalize())
# # --------------------------------------------------------------------------
# #def ToList(self, stylesheet, l): return l.append(str.__str__(self))
# def ToList(self, stylesheet, l): return l.append(self)
# # --------------------------------------------------------------------------
# #def __repr__(self): return str.__str__(self)
# # Debug: output an attribute string with all attributes
# def __repr__(self):
# return "%s-%s-%s"%(`self.lPrefix`,str.__str__(self),`self.lPostfix`)
, which may include functions, classes, or code. Output only the next line. | if type(o) is StringType or type(o) is AttributeString: |
Predict the next line after this snippet: <|code_start|>#!/usr/bin/env python
class ControlLessDo(BasicNamedStatement):
# Stores a Do loop without loop control
def __init__(self, sLabel=None, sName=None, loc=None,
sDo="DO", sDoLabel=None, nIndent=0):
self.sDo = sDo
self.sDoLabel = sDoLabel
self.lLoopData = []
BasicNamedStatement.__init__(self, sLabel, sName, loc, nIndent,
isDeclaration=0)
# --------------------------------------------------------------------------
def GetVarUsage(self, varUsage): return
# --------------------------------------------------------------------------
def ToList(self, stylesheet, l):
BasicNamedStatement.ToList(self, stylesheet, l)
l.append(stylesheet.sKeyword(self.sDo))
if self.sDoLabel:
l.append(self.sDoLabel, nIndent=1)
# ==============================================================================
# Exit statement
<|code_end|>
using the current file's imports:
import string
from AOR.BasicStatement import BasicNamedStatement, BasicStatement
from AOR.Test.DoTest import RunTest
and any relevant context from other files:
# Path: AOR/BasicStatement.py
# class BasicNamedStatement(BasicStatement):
#
# def __init__(self, sLabel=None, sName=None, loc=None, nIndent=0,
# isDeclaration=1):
# self.sName=sName
# BasicStatement.__init__(self, sLabel, loc, nIndent,
# isDeclaration=isDeclaration)
# # --------------------------------------------------------------------------
# def SetName(self, s): self.sName=s
# # --------------------------------------------------------------------------
# def NameIs(self, s):
# return self.sName and string.upper(self.sName) == string.upper(s)
# # --------------------------------------------------------------------------
# def GetName(self): return self.sName
# # --------------------------------------------------------------------------
# def ToList(self, stylesheet, l, bAddSpace=0):
# BasicStatement.ToList(self, stylesheet, l)
# if self.sName:
# if bAddSpace:
# l.append(self.sName,nIndentNext=1)
# else:
# l.append(self.sName)
#
# class BasicStatement(Label, Location):
#
# def __init__(self, sLabel=None, loc=None, nIndent=0, isDeclaration=1):
# Label.__init__(self, sLabel)
# Location.__init__(self, loc)
# self._isDeclaration=isDeclaration
# self.nIndent=nIndent
# # --------------------------------------------------------------------------
# def isA(self, c):
# return self.__class__ == c
# # --------------------------------------------------------------------------
# # Returns true if the statement is a 'real' fortran statement (as opposed to
# # a compiler directive, comment line, preprocessor directive). This method
# # is overwritten in those classes.
# def isStatement(self): return 1
# # --------------------------------------------------------------------------
# # Returns if this statement is a declaration statement or not
# def isDeclaration(self): return self._isDeclaration
# # --------------------------------------------------------------------------
# def ToString(self, stylesheet): return stylesheet.ToString(self)
# # --------------------------------------------------------------------------
# def GetIndentation(self): return self.nIndent
# # --------------------------------------------------------------------------
# def GetVarUsage(self, varUsage, sType="", obj=None, loc=None): return
# # --------------------------------------------------------------------------
# def ToList(self, stylesheet, l):
# Label.ToList(self, stylesheet, l)
# l.append(stylesheet.GetIndentation(self))
# # --------------------------------------------------------------------------
# def __str__(self): return self.__repr__()
# # --------------------------------------------------------------------------
# def __repr__(self):
# stylesheet = DefaultStylesheet()
# return "%s%s"%(Label.__repr__(self),
# "".join(stylesheet.ToString(self)))
. Output only the next line. | class Exit(BasicStatement): |
Here is a snippet: <|code_start|>
- Training ans segmentation on separate files:
Specify <input-text> and --train-file <training-file>. Both texts must be in
phonologized form. The PUDDLE model is trained offline on <training-file>,
before the segmentation of <input-text>. In this mode --nfolds and --njobs
options are not valid.
"""
class Puddle:
"""Train and segmenttext with a PUDDLE modelling
Implementation of a PUDDLE model with `train()` and `segment()` methods.
Parameters
----------
window : int, optional
Number of phonemes to be taken into account for boundary constraint.
Default to 2.
by_frequency : bool, optional
When True choose the word candidates by filterring them by frequency.
Default to False.
log : logging.Logger, optional
The logger instance where to send messages.
"""
<|code_end|>
. Write the next line using the current file imports:
import codecs
import collections
import os
import joblib
from wordseg import utils, folding
and context from other files:
# Path: wordseg/utils.py
# def str2type(t):
# def type2str(t):
# def strip(string):
# def null_logger():
# def get_logger(name=None, level=logging.WARNING):
# def __init__(self, elements):
# def __iter__(self):
# def __next__(self):
# def __init__(self, function):
# def __call__(self):
# def exit(msg):
# def get_binary(binary):
# def get_config_files(algorithm, extension=None):
# def __init__(self, short_name=None, name=None, type=None,
# default=None, help=''):
# def add_to_parser(self, parser):
# def parsed_name(self):
# def get_parser(description=None, separator=Separator(), train_file=False):
# def prepare_main(name=None,
# description=None,
# separator=Separator(phone=None, syllable=None, word=None),
# add_arguments=None,
# train_file=False):
# class CountingIterator:
# class CatchExceptions:
# class Argument:
#
# Path: wordseg/folding.py
# def _permute(l):
# def _flatten(l):
# def _cumsum(l):
# def boundaries(text, nfolds):
# def fold(text, nfolds, fold_boundaries=None):
# def unfold(folds, index):
, which may include functions, classes, or code. Output only the next line. | def __init__(self, window=2, by_frequency=False, log=utils.null_logger()): |
Next line prediction: <|code_start|> When True choose the word candidates by filterring them by frequency.
Default to False.
nfolds : int, optional
The number of folds to segment the `text` on. This option is ignored if
a `train_text` is provided.
njobs : int, optional
The number of subprocesses to run in parallel. The folds are
independant of each others and can be computed in parallel. Requesting
a number of jobs greater then `nfolds` have no effect. This option is
ignored if a `train_text` is provided.
log : logging.Logger, optional
The logger instance where to send messages.
Returns
-------
generator
The utterances from `text` with estimated words boundaries.
See also
--------
wordseg.folding.fold
"""
# force the text to be a list of utterances
text = list(text)
if not train_text:
log.info('not train data provided, will train model on test data')
log.debug('building %s folds', nfolds)
<|code_end|>
. Use current file imports:
(import codecs
import collections
import os
import joblib
from wordseg import utils, folding)
and context including class names, function names, or small code snippets from other files:
# Path: wordseg/utils.py
# def str2type(t):
# def type2str(t):
# def strip(string):
# def null_logger():
# def get_logger(name=None, level=logging.WARNING):
# def __init__(self, elements):
# def __iter__(self):
# def __next__(self):
# def __init__(self, function):
# def __call__(self):
# def exit(msg):
# def get_binary(binary):
# def get_config_files(algorithm, extension=None):
# def __init__(self, short_name=None, name=None, type=None,
# default=None, help=''):
# def add_to_parser(self, parser):
# def parsed_name(self):
# def get_parser(description=None, separator=Separator(), train_file=False):
# def prepare_main(name=None,
# description=None,
# separator=Separator(phone=None, syllable=None, word=None),
# add_arguments=None,
# train_file=False):
# class CountingIterator:
# class CatchExceptions:
# class Argument:
#
# Path: wordseg/folding.py
# def _permute(l):
# def _flatten(l):
# def _cumsum(l):
# def boundaries(text, nfolds):
# def fold(text, nfolds, fold_boundaries=None):
# def unfold(folds, index):
. Output only the next line. | folded_texts, fold_index = folding.fold(text, nfolds) |
Next line prediction: <|code_start|>"""Test of the wordseg.algos.baseline module"""
@pytest.mark.parametrize('p', (1.01, -1, 'a', True, 1))
def test_proba_bad(p):
with pytest.raises(ValueError):
<|code_end|>
. Use current file imports:
(import pytest
from wordseg.algos.baseline import segment)
and context including class names, function names, or small code snippets from other files:
# Path: wordseg/algos/baseline.py
# def segment(text, probability=0.5, log=utils.null_logger()):
# """Random word segmentation given a boundary probability
#
# Given a probability :math:`p`, the probability :math:`P(t_i)` to
# add a word boundary after each token :math:`t_i` is:
#
# .. math::
#
# P(t_i) = P(X < p), X \\sim \\mathcal{U}(0, 1).
#
# Parameters
# ----------
# text : sequence
# The input utterances to segment, tokens are
# assumed to be space separated.
# probability: float, optional
# The probability to append a word boundary after each token.
# log : logging.Logger
# Where to send log messages
#
# Yields
# ------
# segmented_text : generator
# The randomly segmented utterances.
#
# Raises
# ------
# ValueError
# if the probability is not a float in [0, 1].
#
# """
# # make sure the probability is valid
# if not isinstance(probability, float):
# raise ValueError('probability must be a float')
# if probability < 0 or probability > 1:
# raise ValueError(
# 'probability must be in [0, 1], it is {}'.format(probability))
#
# log.info('P(word boundary) = %s', probability)
# for utt in text:
# yield ''.join(
# token + ' ' if random.random() < probability else token
# for token in utt.strip().split(' '))
. Output only the next line. | list(segment('a b c', probability=p)) |
Predict the next line for this snippet: <|code_start|> for bigram, freq in bigrams.items()})
elif dependency == 'btp':
tps = collections.defaultdict(lambda: 0, {
bigram: float(freq) / unigrams[bigram[1]]
for bigram, freq in bigrams.items()})
else: # dependency == 'mi'
tps = collections.defaultdict(lambda: 0, {
bigram: math.log(float(freq) / (
unigrams[bigram[0]] * unigrams[bigram[1]]), 2)
for bigram, freq in bigrams.items()})
return tps
# -----------------------------------------------------------------------------
# Segmentation
# -----------------------------------------------------------------------------
def _segment(units, tps, threshold):
# segment the input given the transition probalities
cwords = (_threshold_relative(units, tps) if threshold == 'relative'
else _threshold_absolute(units, tps))
segtext = ' '.join(''.join(c) for c in cwords)
return [utt.strip() for utt in re.sub(' +', ' ', segtext).split('UB')]
# -----------------------------------------------------------------------------
# Segment function
# -----------------------------------------------------------------------------
def segment(text, train_text=None, threshold='relative', dependency='ftp',
<|code_end|>
with the help of current file imports:
import codecs
import collections
import math
import os
import re
from wordseg import utils
and context from other files:
# Path: wordseg/utils.py
# def str2type(t):
# def type2str(t):
# def strip(string):
# def null_logger():
# def get_logger(name=None, level=logging.WARNING):
# def __init__(self, elements):
# def __iter__(self):
# def __next__(self):
# def __init__(self, function):
# def __call__(self):
# def exit(msg):
# def get_binary(binary):
# def get_config_files(algorithm, extension=None):
# def __init__(self, short_name=None, name=None, type=None,
# default=None, help=''):
# def add_to_parser(self, parser):
# def parsed_name(self):
# def get_parser(description=None, separator=Separator(), train_file=False):
# def prepare_main(name=None,
# description=None,
# separator=Separator(phone=None, syllable=None, word=None),
# add_arguments=None,
# train_file=False):
# class CountingIterator:
# class CatchExceptions:
# class Argument:
, which may contain function names, class names, or code. Output only the next line. | log=utils.null_logger()): |
Here is a snippet: <|code_start|> original Gibbs sampler (*flip sampler*) as well as a sentence-based
Gibbs sampler that uses dynamic programming (*tree sampler*) and a
similar dynamic programming algorithm that chooses the best
segmentation of each utterance rather than a sample. The latter
two algorithms can be run either in batch mode or in online mode.
If in online mode, they can also be set to "forget" parts of the
previously analysis. This is described in more detail below.
3. Functionality for using separate training and testing files. If
you provide an evaluation file, the program will first run through
its full training procedure (i.e., using whichever algorithm for
however many iterations, kneeling, etc.). After that, it will
freeze the lexicon in whatever state it is in and then make a
single pass through the evaluation data, segmenting each sentence
according to the probabilities computed from the frozen lexicon.
No new words/counts will be added to the lexicon during evaluation.
Evaluation can be set to either sample segmentations or choose the
maximum probability segmentation for each utterance. Scores will
be printed out at the end of the complete run based on either the
evaluation data (if provided) or the training data (if not).
"""
# # a list of dpseg options we don't want to expose in wordseg-dpseg
# ['--help', '--data-file', '--data-start-index', '--data-num-sents',
# '--eval-start-index', '--eval-num-sents', '--output-file']
DPSEG_ARGUMENTS = [
<|code_end|>
. Write the next line using the current file imports:
import joblib
import logging
import os
import re
import shlex
import six
import subprocess
import tempfile
import threading
from wordseg import utils, folding
and context from other files:
# Path: wordseg/utils.py
# def str2type(t):
# def type2str(t):
# def strip(string):
# def null_logger():
# def get_logger(name=None, level=logging.WARNING):
# def __init__(self, elements):
# def __iter__(self):
# def __next__(self):
# def __init__(self, function):
# def __call__(self):
# def exit(msg):
# def get_binary(binary):
# def get_config_files(algorithm, extension=None):
# def __init__(self, short_name=None, name=None, type=None,
# default=None, help=''):
# def add_to_parser(self, parser):
# def parsed_name(self):
# def get_parser(description=None, separator=Separator(), train_file=False):
# def prepare_main(name=None,
# description=None,
# separator=Separator(phone=None, syllable=None, word=None),
# add_arguments=None,
# train_file=False):
# class CountingIterator:
# class CatchExceptions:
# class Argument:
#
# Path: wordseg/folding.py
# def _permute(l):
# def _flatten(l):
# def _cumsum(l):
# def boundaries(text, nfolds):
# def fold(text, nfolds, fold_boundaries=None):
# def unfold(folds, index):
, which may include functions, classes, or code. Output only the next line. | utils.Argument( |
Next line prediction: <|code_start|> if process.returncode:
raise RuntimeError(
'failed with error code {}'.format(process.returncode))
tmp_output.seek(0)
return tmp_output.read().decode('utf8').split('\n')
def segment(text, nfolds=5, njobs=1,
args='--ngram 1 --a1 0 --b1 1',
log=utils.null_logger(),
binary=utils.get_binary('dpseg')):
"""Run the 'dpseg' binary on `nfolds` folds"""
# force the text to be a list of utterances
text = list(text)
# set of unique units (syllables or phones) present in the text
units = set(unit for utt in text for unit in utt.split())
log.info('%s units found in %s utterances', len(units), len(text))
# create a unicode equivalent for each unit and convert the text
# to that unicode version
log.debug('converting input to unicode')
unicode_gen = UnicodeGenerator()
unicode_mapping = {unit: unicode_gen() for unit in units}
unicode_text = [''.join(unicode_mapping[unit] for unit in utt.split())
for utt in text]
log.debug('building %s folds', nfolds)
fold_boundaries = _dpseg_bugfix(
<|code_end|>
. Use current file imports:
(import joblib
import logging
import os
import re
import shlex
import six
import subprocess
import tempfile
import threading
from wordseg import utils, folding)
and context including class names, function names, or small code snippets from other files:
# Path: wordseg/utils.py
# def str2type(t):
# def type2str(t):
# def strip(string):
# def null_logger():
# def get_logger(name=None, level=logging.WARNING):
# def __init__(self, elements):
# def __iter__(self):
# def __next__(self):
# def __init__(self, function):
# def __call__(self):
# def exit(msg):
# def get_binary(binary):
# def get_config_files(algorithm, extension=None):
# def __init__(self, short_name=None, name=None, type=None,
# default=None, help=''):
# def add_to_parser(self, parser):
# def parsed_name(self):
# def get_parser(description=None, separator=Separator(), train_file=False):
# def prepare_main(name=None,
# description=None,
# separator=Separator(phone=None, syllable=None, word=None),
# add_arguments=None,
# train_file=False):
# class CountingIterator:
# class CatchExceptions:
# class Argument:
#
# Path: wordseg/folding.py
# def _permute(l):
# def _flatten(l):
# def _cumsum(l):
# def boundaries(text, nfolds):
# def fold(text, nfolds, fold_boundaries=None):
# def unfold(folds, index):
. Output only the next line. | unicode_text, folding.boundaries(unicode_text, nfolds), log) |
Given snippet: <|code_start|>#!/usr/bin/python
# -*- coding: utf-8 -*-
class CategoryManager(base_manager.BaseManager):
""" Handle category related actions.
Member:
db -- The database connection.
hints -- List of hints which occurred during action handling (list hint).
"""
def __init__(self, db):
self.db = db
self.hints = []
def action(self, language):
""" Handle action for given class name. Returns found entities. """
_ = translator.Translator.instance(language)
# Handle actions.
action = self.get_form('action') or 'show'
if action == 'new':
name = self.get_form('name')
if self.__name_ok(name, language):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from action import base_manager
from entity import category
from helper import hint
from helper import translator
and context:
# Path: action/base_manager.py
# class BaseManager:
# COOKIE_PATH = '/'
# def delete_cookie(self, name):
# def get_cookie(self, name):
# def get_form(self, name, strip_value=True):
# def set_cookie(self, name, value, httponly=True, expires=None):
#
# Path: entity/category.py
# class Category:
# def __init__(self, id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: helper/hint.py
# class Hint:
# def __init__(self, text):
#
# Path: helper/translator.py
# class TranslatorNotInitializedError(Exception):
# class Translator:
# def current_language(default_language):
# def init(language, path):
# def instance(language):
which might include code, classes, or functions. Output only the next line. | cat = category.Category(name=name) |
Predict the next line for this snippet: <|code_start|>#!/usr/bin/python
# -*- coding: utf-8 -*-
class CategoryManager(base_manager.BaseManager):
""" Handle category related actions.
Member:
db -- The database connection.
hints -- List of hints which occurred during action handling (list hint).
"""
def __init__(self, db):
self.db = db
self.hints = []
def action(self, language):
""" Handle action for given class name. Returns found entities. """
_ = translator.Translator.instance(language)
# Handle actions.
action = self.get_form('action') or 'show'
if action == 'new':
name = self.get_form('name')
if self.__name_ok(name, language):
cat = category.Category(name=name)
cat.save(self.db)
hint_text = _('New category "{}" has been created.').format(name)
<|code_end|>
with the help of current file imports:
from action import base_manager
from entity import category
from helper import hint
from helper import translator
and context from other files:
# Path: action/base_manager.py
# class BaseManager:
# COOKIE_PATH = '/'
# def delete_cookie(self, name):
# def get_cookie(self, name):
# def get_form(self, name, strip_value=True):
# def set_cookie(self, name, value, httponly=True, expires=None):
#
# Path: entity/category.py
# class Category:
# def __init__(self, id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: helper/hint.py
# class Hint:
# def __init__(self, text):
#
# Path: helper/translator.py
# class TranslatorNotInitializedError(Exception):
# class Translator:
# def current_language(default_language):
# def init(language, path):
# def instance(language):
, which may contain function names, class names, or code. Output only the next line. | self.hints.append(hint.Hint(hint_text)) |
Continue the code snippet: <|code_start|>#!/usr/bin/python
# -*- coding: utf-8 -*-
class CategoryManager(base_manager.BaseManager):
""" Handle category related actions.
Member:
db -- The database connection.
hints -- List of hints which occurred during action handling (list hint).
"""
def __init__(self, db):
self.db = db
self.hints = []
def action(self, language):
""" Handle action for given class name. Returns found entities. """
<|code_end|>
. Use current file imports:
from action import base_manager
from entity import category
from helper import hint
from helper import translator
and context (classes, functions, or code) from other files:
# Path: action/base_manager.py
# class BaseManager:
# COOKIE_PATH = '/'
# def delete_cookie(self, name):
# def get_cookie(self, name):
# def get_form(self, name, strip_value=True):
# def set_cookie(self, name, value, httponly=True, expires=None):
#
# Path: entity/category.py
# class Category:
# def __init__(self, id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: helper/hint.py
# class Hint:
# def __init__(self, text):
#
# Path: helper/translator.py
# class TranslatorNotInitializedError(Exception):
# class Translator:
# def current_language(default_language):
# def init(language, path):
# def instance(language):
. Output only the next line. | _ = translator.Translator.instance(language) |
Based on the snippet: <|code_start|> # Version 12 -> 13
current = 12
# Finished
db.close()
def __create_db(self):
""" Create database file if not existing. """
if not os.path.exists(self.db_file):
shutil.copy(self.home+self.EMPTY_DB_FILE, self.db_file)
def __create_tags(self, db, tags):
""" Create initial set of German and English tags. """
for tag_names in tags:
first = True
parent_id = None
for tag_name in tag_names:
tag = tag_entity.Tag(name=tag_name, synonym_of=parent_id)
try:
tag.save(db)
except sqlite3.IntegrityError:
print('{} in [{}]'.format(tag_name, ', '.join(tag_names)))
sys.exit(80085)
if first:
parent_id = tag.id
first = False
db.commit()
def __is_version(self, db, version):
""" Checks version in configuration table. """
<|code_end|>
, predict the immediate next line with the help of imports:
from entity import configuration as config_entity
from entity import tag as tag_entity
from migration import tags as tag_lists
import os
import shutil
import sqlite3
import sys
and context (classes, functions, sometimes code) from other files:
# Path: entity/configuration.py
# class Configuration:
# def __init__(self, id=None, name='', value=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/tag.py
# class Tag:
# def __init__(self, id=None, name='', synonym_of=None, synonyms=[]):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def find_synonyms(self, db):
# def from_row(db, row, find_synonyms=True):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: migration/tags.py
. Output only the next line. | config = config_entity.Configuration.find_name(db, self.CONFIG_VERSION) |
Given the following code snippet before the placeholder: <|code_start|> current = 10
if self.__is_version(db, current):
self.__create_tags(db, tag_lists.tags_008)
current += 1
self.__update_version(db, current)
# Version 11 -> 12
current = 11
if self.__is_version(db, current):
self.__create_tags(db, tag_lists.tags_009)
current += 1
self.__update_version(db, current)
# Version 12 -> 13
current = 12
# Finished
db.close()
def __create_db(self):
""" Create database file if not existing. """
if not os.path.exists(self.db_file):
shutil.copy(self.home+self.EMPTY_DB_FILE, self.db_file)
def __create_tags(self, db, tags):
""" Create initial set of German and English tags. """
for tag_names in tags:
first = True
parent_id = None
for tag_name in tag_names:
<|code_end|>
, predict the next line using imports from the current file:
from entity import configuration as config_entity
from entity import tag as tag_entity
from migration import tags as tag_lists
import os
import shutil
import sqlite3
import sys
and context including class names, function names, and sometimes code from other files:
# Path: entity/configuration.py
# class Configuration:
# def __init__(self, id=None, name='', value=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/tag.py
# class Tag:
# def __init__(self, id=None, name='', synonym_of=None, synonyms=[]):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def find_synonyms(self, db):
# def from_row(db, row, find_synonyms=True):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: migration/tags.py
. Output only the next line. | tag = tag_entity.Tag(name=tag_name, synonym_of=parent_id) |
Continue the code snippet: <|code_start|>
class MigrationManager:
""" Checks current version and migrates if necessary.
Constants:
CONFIG_VERSION -- The version name in configuration table (string).
EMPTY_DB_FILE -- Name of empty database file (string).
Member:
home -- The home directory (string).
db_file -- Path to sqlite database file.
"""
CONFIG_VERSION = 'version'
EMPTY_DB_FILE = 'empty-db.sqlite'
def __init__(self, home, db_file):
self.home = home
self.db_file = home+db_file
def migrate(self):
""" Executes checks and migrates if necessary. Sub functions should
always commit changes in the database. """
# Version 1
self.__create_db()
db = sqlite3.connect(self.db_file)
# Version 1 -> 2
current = 1
if self.__is_version(db, current):
<|code_end|>
. Use current file imports:
from entity import configuration as config_entity
from entity import tag as tag_entity
from migration import tags as tag_lists
import os
import shutil
import sqlite3
import sys
and context (classes, functions, or code) from other files:
# Path: entity/configuration.py
# class Configuration:
# def __init__(self, id=None, name='', value=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/tag.py
# class Tag:
# def __init__(self, id=None, name='', synonym_of=None, synonyms=[]):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def find_synonyms(self, db):
# def from_row(db, row, find_synonyms=True):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: migration/tags.py
. Output only the next line. | self.__create_tags(db, tag_lists.tags_001) |
Predict the next line for this snippet: <|code_start|> query = 'SELECT description, id, info, ingredients, rating, ' \
'serving_size, title, user_id ' \
'FROM recipes ' \
'WHERE id = ?'
params = [id]
return Recipe.__generic_find(db, query, params)
@staticmethod
def find_random(db, num):
""" Find random entities in database. Returns list of found
entities ordered by name ascending."""
query = 'SELECT description, id, info, ingredients, ' \
'rating, serving_size, title, user_id ' \
'FROM recipes ' \
'ORDER BY RANDOM() ' \
'LIMIT ?'
params = [num]
cursor = db.cursor()
cursor.execute(query, params)
result = []
for row in cursor.fetchall():
result.append(Recipe.from_row(db, row))
return result
@staticmethod
def from_row(db, row):
""" Create entity from given row. """
recipe = Recipe(description=row[0], id=row[1], info=row[2],
ingredients=row[3], rating=row[4], serving_size=row[5],
title=row[6])
<|code_end|>
with the help of current file imports:
from entity import category as category_entity
from entity import image as image_entity
from entity import synonym as synonym_entity
from entity import tag as tag_entity
from entity import url as url_entity
from entity import user as user_entity
import os
and context from other files:
# Path: entity/category.py
# class Category:
# def __init__(self, id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/image.py
# class Image:
# def __init__(self, id=None, recipe_id=None, path=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/synonym.py
# class Synonym:
# def __init__(self, id=None, recipe_id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/tag.py
# class Tag:
# def __init__(self, id=None, name='', synonym_of=None, synonyms=[]):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def find_synonyms(self, db):
# def from_row(db, row, find_synonyms=True):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/url.py
# class Url:
# def __init__(self, id=None, recipe_id=None, name='', url=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/user.py
# class User:
# def __init__(self, id=None, name=None, pw_hash=None, salt=None, session=None):
# def __str__(self):
# def count_all(db):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def from_row(db, row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
, which may contain function names, class names, or code. Output only the next line. | recipe.categories = category_entity.Category.find_recipe(db, recipe) |
Here is a snippet: <|code_start|> 'serving_size, title, user_id ' \
'FROM recipes ' \
'WHERE id = ?'
params = [id]
return Recipe.__generic_find(db, query, params)
@staticmethod
def find_random(db, num):
""" Find random entities in database. Returns list of found
entities ordered by name ascending."""
query = 'SELECT description, id, info, ingredients, ' \
'rating, serving_size, title, user_id ' \
'FROM recipes ' \
'ORDER BY RANDOM() ' \
'LIMIT ?'
params = [num]
cursor = db.cursor()
cursor.execute(query, params)
result = []
for row in cursor.fetchall():
result.append(Recipe.from_row(db, row))
return result
@staticmethod
def from_row(db, row):
""" Create entity from given row. """
recipe = Recipe(description=row[0], id=row[1], info=row[2],
ingredients=row[3], rating=row[4], serving_size=row[5],
title=row[6])
recipe.categories = category_entity.Category.find_recipe(db, recipe)
<|code_end|>
. Write the next line using the current file imports:
from entity import category as category_entity
from entity import image as image_entity
from entity import synonym as synonym_entity
from entity import tag as tag_entity
from entity import url as url_entity
from entity import user as user_entity
import os
and context from other files:
# Path: entity/category.py
# class Category:
# def __init__(self, id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/image.py
# class Image:
# def __init__(self, id=None, recipe_id=None, path=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/synonym.py
# class Synonym:
# def __init__(self, id=None, recipe_id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/tag.py
# class Tag:
# def __init__(self, id=None, name='', synonym_of=None, synonyms=[]):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def find_synonyms(self, db):
# def from_row(db, row, find_synonyms=True):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/url.py
# class Url:
# def __init__(self, id=None, recipe_id=None, name='', url=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/user.py
# class User:
# def __init__(self, id=None, name=None, pw_hash=None, salt=None, session=None):
# def __str__(self):
# def count_all(db):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def from_row(db, row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
, which may include functions, classes, or code. Output only the next line. | recipe.images = image_entity.Image.find_recipe(db, recipe) |
Predict the next line after this snippet: <|code_start|> 'FROM recipes ' \
'WHERE id = ?'
params = [id]
return Recipe.__generic_find(db, query, params)
@staticmethod
def find_random(db, num):
""" Find random entities in database. Returns list of found
entities ordered by name ascending."""
query = 'SELECT description, id, info, ingredients, ' \
'rating, serving_size, title, user_id ' \
'FROM recipes ' \
'ORDER BY RANDOM() ' \
'LIMIT ?'
params = [num]
cursor = db.cursor()
cursor.execute(query, params)
result = []
for row in cursor.fetchall():
result.append(Recipe.from_row(db, row))
return result
@staticmethod
def from_row(db, row):
""" Create entity from given row. """
recipe = Recipe(description=row[0], id=row[1], info=row[2],
ingredients=row[3], rating=row[4], serving_size=row[5],
title=row[6])
recipe.categories = category_entity.Category.find_recipe(db, recipe)
recipe.images = image_entity.Image.find_recipe(db, recipe)
<|code_end|>
using the current file's imports:
from entity import category as category_entity
from entity import image as image_entity
from entity import synonym as synonym_entity
from entity import tag as tag_entity
from entity import url as url_entity
from entity import user as user_entity
import os
and any relevant context from other files:
# Path: entity/category.py
# class Category:
# def __init__(self, id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/image.py
# class Image:
# def __init__(self, id=None, recipe_id=None, path=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/synonym.py
# class Synonym:
# def __init__(self, id=None, recipe_id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/tag.py
# class Tag:
# def __init__(self, id=None, name='', synonym_of=None, synonyms=[]):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def find_synonyms(self, db):
# def from_row(db, row, find_synonyms=True):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/url.py
# class Url:
# def __init__(self, id=None, recipe_id=None, name='', url=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/user.py
# class User:
# def __init__(self, id=None, name=None, pw_hash=None, salt=None, session=None):
# def __str__(self):
# def count_all(db):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def from_row(db, row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
. Output only the next line. | recipe.synonyms = synonym_entity.Synonym.find_recipe(db, recipe) |
Using the snippet: <|code_start|> 'WHERE id = ?'
params = [id]
return Recipe.__generic_find(db, query, params)
@staticmethod
def find_random(db, num):
""" Find random entities in database. Returns list of found
entities ordered by name ascending."""
query = 'SELECT description, id, info, ingredients, ' \
'rating, serving_size, title, user_id ' \
'FROM recipes ' \
'ORDER BY RANDOM() ' \
'LIMIT ?'
params = [num]
cursor = db.cursor()
cursor.execute(query, params)
result = []
for row in cursor.fetchall():
result.append(Recipe.from_row(db, row))
return result
@staticmethod
def from_row(db, row):
""" Create entity from given row. """
recipe = Recipe(description=row[0], id=row[1], info=row[2],
ingredients=row[3], rating=row[4], serving_size=row[5],
title=row[6])
recipe.categories = category_entity.Category.find_recipe(db, recipe)
recipe.images = image_entity.Image.find_recipe(db, recipe)
recipe.synonyms = synonym_entity.Synonym.find_recipe(db, recipe)
<|code_end|>
, determine the next line of code. You have imports:
from entity import category as category_entity
from entity import image as image_entity
from entity import synonym as synonym_entity
from entity import tag as tag_entity
from entity import url as url_entity
from entity import user as user_entity
import os
and context (class names, function names, or code) available:
# Path: entity/category.py
# class Category:
# def __init__(self, id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/image.py
# class Image:
# def __init__(self, id=None, recipe_id=None, path=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/synonym.py
# class Synonym:
# def __init__(self, id=None, recipe_id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/tag.py
# class Tag:
# def __init__(self, id=None, name='', synonym_of=None, synonyms=[]):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def find_synonyms(self, db):
# def from_row(db, row, find_synonyms=True):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/url.py
# class Url:
# def __init__(self, id=None, recipe_id=None, name='', url=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/user.py
# class User:
# def __init__(self, id=None, name=None, pw_hash=None, salt=None, session=None):
# def __str__(self):
# def count_all(db):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def from_row(db, row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
. Output only the next line. | recipe.tags = tag_entity.Tag.find_recipe(db, recipe) |
Predict the next line for this snippet: <|code_start|> params = [id]
return Recipe.__generic_find(db, query, params)
@staticmethod
def find_random(db, num):
""" Find random entities in database. Returns list of found
entities ordered by name ascending."""
query = 'SELECT description, id, info, ingredients, ' \
'rating, serving_size, title, user_id ' \
'FROM recipes ' \
'ORDER BY RANDOM() ' \
'LIMIT ?'
params = [num]
cursor = db.cursor()
cursor.execute(query, params)
result = []
for row in cursor.fetchall():
result.append(Recipe.from_row(db, row))
return result
@staticmethod
def from_row(db, row):
""" Create entity from given row. """
recipe = Recipe(description=row[0], id=row[1], info=row[2],
ingredients=row[3], rating=row[4], serving_size=row[5],
title=row[6])
recipe.categories = category_entity.Category.find_recipe(db, recipe)
recipe.images = image_entity.Image.find_recipe(db, recipe)
recipe.synonyms = synonym_entity.Synonym.find_recipe(db, recipe)
recipe.tags = tag_entity.Tag.find_recipe(db, recipe)
<|code_end|>
with the help of current file imports:
from entity import category as category_entity
from entity import image as image_entity
from entity import synonym as synonym_entity
from entity import tag as tag_entity
from entity import url as url_entity
from entity import user as user_entity
import os
and context from other files:
# Path: entity/category.py
# class Category:
# def __init__(self, id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/image.py
# class Image:
# def __init__(self, id=None, recipe_id=None, path=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/synonym.py
# class Synonym:
# def __init__(self, id=None, recipe_id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/tag.py
# class Tag:
# def __init__(self, id=None, name='', synonym_of=None, synonyms=[]):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def find_synonyms(self, db):
# def from_row(db, row, find_synonyms=True):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/url.py
# class Url:
# def __init__(self, id=None, recipe_id=None, name='', url=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/user.py
# class User:
# def __init__(self, id=None, name=None, pw_hash=None, salt=None, session=None):
# def __str__(self):
# def count_all(db):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def from_row(db, row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
, which may contain function names, class names, or code. Output only the next line. | recipe.urls = url_entity.Url.find_recipe(db, recipe) |
Predict the next line after this snippet: <|code_start|>
@staticmethod
def find_random(db, num):
""" Find random entities in database. Returns list of found
entities ordered by name ascending."""
query = 'SELECT description, id, info, ingredients, ' \
'rating, serving_size, title, user_id ' \
'FROM recipes ' \
'ORDER BY RANDOM() ' \
'LIMIT ?'
params = [num]
cursor = db.cursor()
cursor.execute(query, params)
result = []
for row in cursor.fetchall():
result.append(Recipe.from_row(db, row))
return result
@staticmethod
def from_row(db, row):
""" Create entity from given row. """
recipe = Recipe(description=row[0], id=row[1], info=row[2],
ingredients=row[3], rating=row[4], serving_size=row[5],
title=row[6])
recipe.categories = category_entity.Category.find_recipe(db, recipe)
recipe.images = image_entity.Image.find_recipe(db, recipe)
recipe.synonyms = synonym_entity.Synonym.find_recipe(db, recipe)
recipe.tags = tag_entity.Tag.find_recipe(db, recipe)
recipe.urls = url_entity.Url.find_recipe(db, recipe)
if row[7] is not None:
<|code_end|>
using the current file's imports:
from entity import category as category_entity
from entity import image as image_entity
from entity import synonym as synonym_entity
from entity import tag as tag_entity
from entity import url as url_entity
from entity import user as user_entity
import os
and any relevant context from other files:
# Path: entity/category.py
# class Category:
# def __init__(self, id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/image.py
# class Image:
# def __init__(self, id=None, recipe_id=None, path=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/synonym.py
# class Synonym:
# def __init__(self, id=None, recipe_id=None, name=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/tag.py
# class Tag:
# def __init__(self, id=None, name='', synonym_of=None, synonyms=[]):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def find_synonyms(self, db):
# def from_row(db, row, find_synonyms=True):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/url.py
# class Url:
# def __init__(self, id=None, recipe_id=None, name='', url=''):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def from_row(row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: entity/user.py
# class User:
# def __init__(self, id=None, name=None, pw_hash=None, salt=None, session=None):
# def __str__(self):
# def count_all(db):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def from_row(db, row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
. Output only the next line. | recipe.author = user_entity.User.find_pk(db, row[7]) |
Given the code snippet: <|code_start|>#!/usr/bin/python
# -*- coding: utf-8 -*-
class ExportManager(base_manager.BaseManager):
""" Handles export actions.
Member:
db -- The database connection.
"""
def __init__(self, db):
self.db = db
def action(self, static_path, image_path, id, recipe_json):
""" Exports recipe with given id. Returns download stream. """
<|code_end|>
, generate the next line using the imports in this file:
import bottle
import io
import json
import zipfile
from action import base_manager
from entity import recipe as recipe_entity
from helper import url as url_helper
and context (functions, classes, or occasionally code) from other files:
# Path: action/base_manager.py
# class BaseManager:
# COOKIE_PATH = '/'
# def delete_cookie(self, name):
# def get_cookie(self, name):
# def get_form(self, name, strip_value=True):
# def set_cookie(self, name, value, httponly=True, expires=None):
#
# Path: entity/recipe.py
# class Recipe:
# def __init__(self, categories=[], description='', id=None, info='',
# ingredients='', rating=None, serving_size='', title='',
# tags=[], urls=[], synonyms=[], images=[], author=None):
# def __str__(self):
# def count_all(db):
# def delete(self, db):
# def find_all(db):
# def find_category(db, category):
# def find_pk(db, id):
# def find_random(db, num):
# def from_row(db, row):
# def is_new(self):
# def title_exists(db, title):
# def save(self, db):
# def __delete_images(self, db, force=False):
# def __delete_recipe_has_category(self, db):
# def __delete_recipe_has_tag(self, db):
# def __delete_synonyms(self, db):
# def __delete_urls(self, db):
# def __generic_find(db, query, params):
#
# Path: helper/url.py
# class Url:
# def from_category(category, absolute=None):
# def from_css(css_file, absolute=None):
# def from_img(img_file, absolute=None):
# def from_js(js_file, absolute=None):
# def from_path(path_parts, absolute=None, filter_chars=False):
# def from_recipe(recipe, absolute=None):
# def search(search_text, absolute=None):
# def slugify(text):
. Output only the next line. | recipe = recipe_entity.Recipe.find_pk(self.db, id) |
Next line prediction: <|code_start|> # Convert recipe to json compatible object.
images = [image.path.replace(image_path, '')
for image in recipe.images]
urls = [{'name': url.name, 'url': url.url} for url in recipe.urls]
synonyms = [synonym.name for synonym in recipe.synonyms]
json_obj = {
'description': recipe.description,
'info': recipe.info,
'ingredients': recipe.ingredients,
'serving_size': recipe.serving_size,
'title': recipe.title,
'urls': urls,
'synonyms': synonyms,
'images': images
}
# Create json.
json_str = json.dumps(json_obj)
# Create zip.
with io.BytesIO() as zip_bytes:
with zipfile.ZipFile(zip_bytes, mode='w') as zip:
zip.writestr(recipe_json, json_str)
for image in recipe.images:
index = image.path.rfind('/')
file_name = image.path[index:]
zip.write(static_path+'/'+image.path, file_name)
result = zip_bytes.getvalue()
# Stream to browser.
<|code_end|>
. Use current file imports:
(import bottle
import io
import json
import zipfile
from action import base_manager
from entity import recipe as recipe_entity
from helper import url as url_helper)
and context including class names, function names, or small code snippets from other files:
# Path: action/base_manager.py
# class BaseManager:
# COOKIE_PATH = '/'
# def delete_cookie(self, name):
# def get_cookie(self, name):
# def get_form(self, name, strip_value=True):
# def set_cookie(self, name, value, httponly=True, expires=None):
#
# Path: entity/recipe.py
# class Recipe:
# def __init__(self, categories=[], description='', id=None, info='',
# ingredients='', rating=None, serving_size='', title='',
# tags=[], urls=[], synonyms=[], images=[], author=None):
# def __str__(self):
# def count_all(db):
# def delete(self, db):
# def find_all(db):
# def find_category(db, category):
# def find_pk(db, id):
# def find_random(db, num):
# def from_row(db, row):
# def is_new(self):
# def title_exists(db, title):
# def save(self, db):
# def __delete_images(self, db, force=False):
# def __delete_recipe_has_category(self, db):
# def __delete_recipe_has_tag(self, db):
# def __delete_synonyms(self, db):
# def __delete_urls(self, db):
# def __generic_find(db, query, params):
#
# Path: helper/url.py
# class Url:
# def from_category(category, absolute=None):
# def from_css(css_file, absolute=None):
# def from_img(img_file, absolute=None):
# def from_js(js_file, absolute=None):
# def from_path(path_parts, absolute=None, filter_chars=False):
# def from_recipe(recipe, absolute=None):
# def search(search_text, absolute=None):
# def slugify(text):
. Output only the next line. | name = url_helper.Url.slugify(recipe.title) |
Given the following code snippet before the placeholder: <|code_start|>#!/usr/bin/python
# -*- coding: utf-8 -*-
class TagManager(base_manager.BaseManager):
""" Handle tag related actions.
Member:
db -- The database connection.
hints -- List of hints which occurred during action handling (list hint).
"""
def __init__(self, db):
self.db = db
self.hints = []
def action(self, language):
""" Handle action for given class name. Returns found entities. """
_ = translator.Translator.instance(language)
# Handle actions.
action = self.get_form('action') or 'show'
if action == 'new':
name = self.get_form('name')
if self.__name_ok(name, language):
<|code_end|>
, predict the next line using imports from the current file:
from action import base_manager
from entity import tag as tag_entity
from helper import hint
from helper import translator
and context including class names, function names, and sometimes code from other files:
# Path: action/base_manager.py
# class BaseManager:
# COOKIE_PATH = '/'
# def delete_cookie(self, name):
# def get_cookie(self, name):
# def get_form(self, name, strip_value=True):
# def set_cookie(self, name, value, httponly=True, expires=None):
#
# Path: entity/tag.py
# class Tag:
# def __init__(self, id=None, name='', synonym_of=None, synonyms=[]):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def find_synonyms(self, db):
# def from_row(db, row, find_synonyms=True):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: helper/hint.py
# class Hint:
# def __init__(self, text):
#
# Path: helper/translator.py
# class TranslatorNotInitializedError(Exception):
# class Translator:
# def current_language(default_language):
# def init(language, path):
# def instance(language):
. Output only the next line. | tag = tag_entity.Tag(name=name) |
Given snippet: <|code_start|>#!/usr/bin/python
# -*- coding: utf-8 -*-
class TagManager(base_manager.BaseManager):
""" Handle tag related actions.
Member:
db -- The database connection.
hints -- List of hints which occurred during action handling (list hint).
"""
def __init__(self, db):
self.db = db
self.hints = []
def action(self, language):
""" Handle action for given class name. Returns found entities. """
_ = translator.Translator.instance(language)
# Handle actions.
action = self.get_form('action') or 'show'
if action == 'new':
name = self.get_form('name')
if self.__name_ok(name, language):
tag = tag_entity.Tag(name=name)
tag.save(self.db)
hint_text = _('New tag "{}" has been created.').format(name)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from action import base_manager
from entity import tag as tag_entity
from helper import hint
from helper import translator
and context:
# Path: action/base_manager.py
# class BaseManager:
# COOKIE_PATH = '/'
# def delete_cookie(self, name):
# def get_cookie(self, name):
# def get_form(self, name, strip_value=True):
# def set_cookie(self, name, value, httponly=True, expires=None):
#
# Path: entity/tag.py
# class Tag:
# def __init__(self, id=None, name='', synonym_of=None, synonyms=[]):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def find_synonyms(self, db):
# def from_row(db, row, find_synonyms=True):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: helper/hint.py
# class Hint:
# def __init__(self, text):
#
# Path: helper/translator.py
# class TranslatorNotInitializedError(Exception):
# class Translator:
# def current_language(default_language):
# def init(language, path):
# def instance(language):
which might include code, classes, or functions. Output only the next line. | self.hints.append(hint.Hint(hint_text)) |
Using the snippet: <|code_start|>#!/usr/bin/python
# -*- coding: utf-8 -*-
class TagManager(base_manager.BaseManager):
""" Handle tag related actions.
Member:
db -- The database connection.
hints -- List of hints which occurred during action handling (list hint).
"""
def __init__(self, db):
self.db = db
self.hints = []
def action(self, language):
""" Handle action for given class name. Returns found entities. """
<|code_end|>
, determine the next line of code. You have imports:
from action import base_manager
from entity import tag as tag_entity
from helper import hint
from helper import translator
and context (class names, function names, or code) available:
# Path: action/base_manager.py
# class BaseManager:
# COOKIE_PATH = '/'
# def delete_cookie(self, name):
# def get_cookie(self, name):
# def get_form(self, name, strip_value=True):
# def set_cookie(self, name, value, httponly=True, expires=None):
#
# Path: entity/tag.py
# class Tag:
# def __init__(self, id=None, name='', synonym_of=None, synonyms=[]):
# def __str__(self):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def find_recipe(db, recipe):
# def find_synonyms(self, db):
# def from_row(db, row, find_synonyms=True):
# def is_new(self):
# def name_exists(db, name):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: helper/hint.py
# class Hint:
# def __init__(self, text):
#
# Path: helper/translator.py
# class TranslatorNotInitializedError(Exception):
# class Translator:
# def current_language(default_language):
# def init(language, path):
# def instance(language):
. Output only the next line. | _ = translator.Translator.instance(language) |
Given snippet: <|code_start|>#!/usr/bin/python
# -*- coding: utf-8 -*-
class Searcher:
""" Searcher class.
Constants:
DEFAULT_FIELD -- Name of the default field to search (string).
Member:
_indexer -- The indexer (indexer).
"""
DEFAULT_FIELD = 'titletags'
def __init__(self, indexer):
self._indexer = indexer
def search(self, db, query_text):
""" Search this query. Returns found recipes. """
parser = qparser.QueryParser(self.DEFAULT_FIELD, self._indexer.scheme())
query = parser.parse(query_text)
recipes = []
with self._indexer.searcher() as searcher:
results = searcher.search(query, limit=None)
if results:
for hit in results:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from entity import recipe as recipe_entity
from whoosh import qparser
and context:
# Path: entity/recipe.py
# class Recipe:
# def __init__(self, categories=[], description='', id=None, info='',
# ingredients='', rating=None, serving_size='', title='',
# tags=[], urls=[], synonyms=[], images=[], author=None):
# def __str__(self):
# def count_all(db):
# def delete(self, db):
# def find_all(db):
# def find_category(db, category):
# def find_pk(db, id):
# def find_random(db, num):
# def from_row(db, row):
# def is_new(self):
# def title_exists(db, title):
# def save(self, db):
# def __delete_images(self, db, force=False):
# def __delete_recipe_has_category(self, db):
# def __delete_recipe_has_tag(self, db):
# def __delete_synonyms(self, db):
# def __delete_urls(self, db):
# def __generic_find(db, query, params):
which might include code, classes, or functions. Output only the next line. | recipe = recipe_entity.Recipe.find_pk(db, hit['id']) |
Predict the next line after this snippet: <|code_start|> Member:
db -- The database connection.
hints -- List of hints which occurred during action handling (list hint).
_current_user -- Cache for current user (user).
"""
SESSION_COOKIE = 'session'
USER_NAME_COOKIE = 'user'
def __init__(self, db):
self.db = db
self.hints = []
self._current_user = None
def action(self, language, pw_hash_iterations, admin_user):
""" Handle actions. Returns users or redirects. """
# Validate user and initialize admin user if necessary.
self.validate_login(pw_hash_iterations, admin_user)
is_admin = (self.current_user().name == admin_user)
if is_admin:
users = self.__action_admin(language, pw_hash_iterations)
else:
users = self.__action_user(language, pw_hash_iterations)
return users
def current_user(self):
""" Returns the current user or None. """
if not self._current_user:
user_name = self.get_cookie(self.USER_NAME_COOKIE)
if user_name:
<|code_end|>
using the current file's imports:
import datetime
import hashlib
import random
import uuid
from action import base_manager
from bottle import redirect
from entity import user as user_entity
from helper import hint
from helper import translator
from helper import url
and any relevant context from other files:
# Path: action/base_manager.py
# class BaseManager:
# COOKIE_PATH = '/'
# def delete_cookie(self, name):
# def get_cookie(self, name):
# def get_form(self, name, strip_value=True):
# def set_cookie(self, name, value, httponly=True, expires=None):
#
# Path: entity/user.py
# class User:
# def __init__(self, id=None, name=None, pw_hash=None, salt=None, session=None):
# def __str__(self):
# def count_all(db):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def from_row(db, row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: helper/hint.py
# class Hint:
# def __init__(self, text):
#
# Path: helper/translator.py
# class TranslatorNotInitializedError(Exception):
# class Translator:
# def current_language(default_language):
# def init(language, path):
# def instance(language):
#
# Path: helper/url.py
# class Url:
# def from_category(category, absolute=None):
# def from_css(css_file, absolute=None):
# def from_img(img_file, absolute=None):
# def from_js(js_file, absolute=None):
# def from_path(path_parts, absolute=None, filter_chars=False):
# def from_recipe(recipe, absolute=None):
# def search(search_text, absolute=None):
# def slugify(text):
. Output only the next line. | self._current_user = user_entity.User.find_name(self.db, user_name) |
Based on the snippet: <|code_start|> self._current_user = None
def action(self, language, pw_hash_iterations, admin_user):
""" Handle actions. Returns users or redirects. """
# Validate user and initialize admin user if necessary.
self.validate_login(pw_hash_iterations, admin_user)
is_admin = (self.current_user().name == admin_user)
if is_admin:
users = self.__action_admin(language, pw_hash_iterations)
else:
users = self.__action_user(language, pw_hash_iterations)
return users
def current_user(self):
""" Returns the current user or None. """
if not self._current_user:
user_name = self.get_cookie(self.USER_NAME_COOKIE)
if user_name:
self._current_user = user_entity.User.find_name(self.db, user_name)
return self._current_user
def login(self, language, pw_hash_iterations, admin_user):
""" Handle login. Returns hints or redirects. """
_ = translator.Translator.instance(language)
if self.get_form('action') == 'login':
user_name = self.get_form('name')
password = self.get_form('password', False)
if not user_name or not password:
hint_text = _('Please provide your user name and password.')
<|code_end|>
, predict the immediate next line with the help of imports:
import datetime
import hashlib
import random
import uuid
from action import base_manager
from bottle import redirect
from entity import user as user_entity
from helper import hint
from helper import translator
from helper import url
and context (classes, functions, sometimes code) from other files:
# Path: action/base_manager.py
# class BaseManager:
# COOKIE_PATH = '/'
# def delete_cookie(self, name):
# def get_cookie(self, name):
# def get_form(self, name, strip_value=True):
# def set_cookie(self, name, value, httponly=True, expires=None):
#
# Path: entity/user.py
# class User:
# def __init__(self, id=None, name=None, pw_hash=None, salt=None, session=None):
# def __str__(self):
# def count_all(db):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def from_row(db, row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: helper/hint.py
# class Hint:
# def __init__(self, text):
#
# Path: helper/translator.py
# class TranslatorNotInitializedError(Exception):
# class Translator:
# def current_language(default_language):
# def init(language, path):
# def instance(language):
#
# Path: helper/url.py
# class Url:
# def from_category(category, absolute=None):
# def from_css(css_file, absolute=None):
# def from_img(img_file, absolute=None):
# def from_js(js_file, absolute=None):
# def from_path(path_parts, absolute=None, filter_chars=False):
# def from_recipe(recipe, absolute=None):
# def search(search_text, absolute=None):
# def slugify(text):
. Output only the next line. | self.hints.append(hint.Hint(hint_text)) |
Continue the code snippet: <|code_start|>
SESSION_COOKIE = 'session'
USER_NAME_COOKIE = 'user'
def __init__(self, db):
self.db = db
self.hints = []
self._current_user = None
def action(self, language, pw_hash_iterations, admin_user):
""" Handle actions. Returns users or redirects. """
# Validate user and initialize admin user if necessary.
self.validate_login(pw_hash_iterations, admin_user)
is_admin = (self.current_user().name == admin_user)
if is_admin:
users = self.__action_admin(language, pw_hash_iterations)
else:
users = self.__action_user(language, pw_hash_iterations)
return users
def current_user(self):
""" Returns the current user or None. """
if not self._current_user:
user_name = self.get_cookie(self.USER_NAME_COOKIE)
if user_name:
self._current_user = user_entity.User.find_name(self.db, user_name)
return self._current_user
def login(self, language, pw_hash_iterations, admin_user):
""" Handle login. Returns hints or redirects. """
<|code_end|>
. Use current file imports:
import datetime
import hashlib
import random
import uuid
from action import base_manager
from bottle import redirect
from entity import user as user_entity
from helper import hint
from helper import translator
from helper import url
and context (classes, functions, or code) from other files:
# Path: action/base_manager.py
# class BaseManager:
# COOKIE_PATH = '/'
# def delete_cookie(self, name):
# def get_cookie(self, name):
# def get_form(self, name, strip_value=True):
# def set_cookie(self, name, value, httponly=True, expires=None):
#
# Path: entity/user.py
# class User:
# def __init__(self, id=None, name=None, pw_hash=None, salt=None, session=None):
# def __str__(self):
# def count_all(db):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def from_row(db, row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: helper/hint.py
# class Hint:
# def __init__(self, text):
#
# Path: helper/translator.py
# class TranslatorNotInitializedError(Exception):
# class Translator:
# def current_language(default_language):
# def init(language, path):
# def instance(language):
#
# Path: helper/url.py
# class Url:
# def from_category(category, absolute=None):
# def from_css(css_file, absolute=None):
# def from_img(img_file, absolute=None):
# def from_js(js_file, absolute=None):
# def from_path(path_parts, absolute=None, filter_chars=False):
# def from_recipe(recipe, absolute=None):
# def search(search_text, absolute=None):
# def slugify(text):
. Output only the next line. | _ = translator.Translator.instance(language) |
Given the code snippet: <|code_start|> is_admin = (self.current_user().name == admin_user)
if is_admin:
users = self.__action_admin(language, pw_hash_iterations)
else:
users = self.__action_user(language, pw_hash_iterations)
return users
def current_user(self):
""" Returns the current user or None. """
if not self._current_user:
user_name = self.get_cookie(self.USER_NAME_COOKIE)
if user_name:
self._current_user = user_entity.User.find_name(self.db, user_name)
return self._current_user
def login(self, language, pw_hash_iterations, admin_user):
""" Handle login. Returns hints or redirects. """
_ = translator.Translator.instance(language)
if self.get_form('action') == 'login':
user_name = self.get_form('name')
password = self.get_form('password', False)
if not user_name or not password:
hint_text = _('Please provide your user name and password.')
self.hints.append(hint.Hint(hint_text))
return self.hints
user = user_entity.User.find_name(self.db, user_name)
hint_text = _('Given user name or password is wrong. Please '
'try again.')
<|code_end|>
, generate the next line using the imports in this file:
import datetime
import hashlib
import random
import uuid
from action import base_manager
from bottle import redirect
from entity import user as user_entity
from helper import hint
from helper import translator
from helper import url
and context (functions, classes, or occasionally code) from other files:
# Path: action/base_manager.py
# class BaseManager:
# COOKIE_PATH = '/'
# def delete_cookie(self, name):
# def get_cookie(self, name):
# def get_form(self, name, strip_value=True):
# def set_cookie(self, name, value, httponly=True, expires=None):
#
# Path: entity/user.py
# class User:
# def __init__(self, id=None, name=None, pw_hash=None, salt=None, session=None):
# def __str__(self):
# def count_all(db):
# def delete(self, db):
# def find_all(db):
# def find_name(db, name):
# def find_pk(db, id):
# def from_row(db, row):
# def is_new(self):
# def save(self, db):
# def __generic_find(db, query, params):
#
# Path: helper/hint.py
# class Hint:
# def __init__(self, text):
#
# Path: helper/translator.py
# class TranslatorNotInitializedError(Exception):
# class Translator:
# def current_language(default_language):
# def init(language, path):
# def instance(language):
#
# Path: helper/url.py
# class Url:
# def from_category(category, absolute=None):
# def from_css(css_file, absolute=None):
# def from_img(img_file, absolute=None):
# def from_js(js_file, absolute=None):
# def from_path(path_parts, absolute=None, filter_chars=False):
# def from_recipe(recipe, absolute=None):
# def search(search_text, absolute=None):
# def slugify(text):
. Output only the next line. | redirect_url = url.Url.from_path(['']) |
Here is a snippet: <|code_start|># accordance with Section 6 of the License, the provision of commercial
# support services in conjunction with a version of OpenCenter which includes
# Rackspace trademarks and logos is prohibited. OpenCenter source code and
# details are available at: # https://github.com/rcbops/opencenter or upon
# written request.
#
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0 and a copy, including this
# notice, is available in the LICENSE file accompanying this software.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the # specific language governing permissions and limitations
# under the License.
#
##############################################################################
#
class TestModuleManager(testtools.TestCase):
def fake_load_file(self, path):
self.files_loaded += 1
def test_load_directory_empty(self):
with utils.temporary_directory() as path:
self.files_loaded = 0
<|code_end|>
. Write the next line using the current file imports:
import fixtures
import os
import testtools
import unittest
from opencenteragent.modules import manager
from opencenteragent import utils
and context from other files:
# Path: opencenteragent/modules/manager.py
# LOG = logging.getLogger('opencenter.manager')
# class Manager(object):
# def __init__(self, path, config={}):
# def _load_directory(self, path):
# def _load_file(self, path):
# def register_action(self, plugin, action, method,
# constraints=[],
# consequences=[],
# args={}):
# def load(self, path):
# def stop(self):
#
# Path: opencenteragent/utils.py
# def detailed_exception():
# def temporary_file():
# def temporary_directory():
, which may include functions, classes, or code. Output only the next line. | m = manager.Manager(path) |
Given the following code snippet before the placeholder: <|code_start|># OpenCenter is licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License. This
# version of OpenCenter includes Rackspace trademarks and logos, and in
# accordance with Section 6 of the License, the provision of commercial
# support services in conjunction with a version of OpenCenter which includes
# Rackspace trademarks and logos is prohibited. OpenCenter source code and
# details are available at: # https://github.com/rcbops/opencenter or upon
# written request.
#
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0 and a copy, including this
# notice, is available in the LICENSE file accompanying this software.
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the # specific language governing permissions and limitations
# under the License.
#
##############################################################################
#
class TestModuleManager(testtools.TestCase):
def fake_load_file(self, path):
self.files_loaded += 1
def test_load_directory_empty(self):
<|code_end|>
, predict the next line using imports from the current file:
import fixtures
import os
import testtools
import unittest
from opencenteragent.modules import manager
from opencenteragent import utils
and context including class names, function names, and sometimes code from other files:
# Path: opencenteragent/modules/manager.py
# LOG = logging.getLogger('opencenter.manager')
# class Manager(object):
# def __init__(self, path, config={}):
# def _load_directory(self, path):
# def _load_file(self, path):
# def register_action(self, plugin, action, method,
# constraints=[],
# consequences=[],
# args={}):
# def load(self, path):
# def stop(self):
#
# Path: opencenteragent/utils.py
# def detailed_exception():
# def temporary_file():
# def temporary_directory():
. Output only the next line. | with utils.temporary_directory() as path: |
Continue the code snippet: <|code_start|># Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the # specific language governing permissions and limitations
# under the License.
#
##############################################################################
#
# Suppress WARNING logs
LOG = logging.getLogger('output')
LOG.setLevel(logging.ERROR)
class TestOpenCenterUtils(unittest.TestCase):
def test_detailed_exception(self):
class FakeExceptionForTest(Exception):
pass
def bar():
raise FakeExceptionForTest('testing 123')
def foo():
bar()
try:
foo()
except FakeExceptionForTest:
<|code_end|>
. Use current file imports:
import logging
import os
import unittest
from opencenteragent import utils
and context (classes, functions, or code) from other files:
# Path: opencenteragent/utils.py
# def detailed_exception():
# def temporary_file():
# def temporary_directory():
. Output only the next line. | trace = utils.detailed_exception() |
Given snippet: <|code_start|>
class FakeSocket(object):
def __init__(self, protocol, transport):
self.sent = []
def connect(self, ip_port):
pass
def shutdown(self, kind):
pass
def close(self):
pass
def send(self, data):
self.sent.append(data)
return len(data)
class FakeSocketSendFails(FakeSocket):
def send(self, data):
raise Exception('send failed')
class TestModuleOutputManager(testtools.TestCase):
def test_init(self):
with utils.temporary_directory() as path:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import fixtures
import os
import socket
import testtools
import unittest
from opencenteragent.modules import output_manager
from opencenteragent import utils
and context:
# Path: opencenteragent/modules/output_manager.py
# LOG = logging.getLogger('opencenter.output')
# def _ok(code=0, message='success', data={}):
# def _fail(code=1, message='unknown failure', data={}):
# def _xfer_to_eof(fd_in, sock_out):
# def __init__(self, path, config={}):
# def register_action(self, plugin, shortpath, action, method,
# constraints=[], consequences=[], args={},
# timeout=30):
# def actions(self):
# def dispatch(self, input_data):
# def handle_logfile(self, input_data, sock=None):
# def handle_modules(self, input_data):
# class OutputManager(manager.Manager):
#
# Path: opencenteragent/utils.py
# def detailed_exception():
# def temporary_file():
# def temporary_directory():
which might include code, classes, or functions. Output only the next line. | om = output_manager.OutputManager(path) |
Given the code snippet: <|code_start|>#
class FakeSocket(object):
def __init__(self, protocol, transport):
self.sent = []
def connect(self, ip_port):
pass
def shutdown(self, kind):
pass
def close(self):
pass
def send(self, data):
self.sent.append(data)
return len(data)
class FakeSocketSendFails(FakeSocket):
def send(self, data):
raise Exception('send failed')
class TestModuleOutputManager(testtools.TestCase):
def test_init(self):
<|code_end|>
, generate the next line using the imports in this file:
import fixtures
import os
import socket
import testtools
import unittest
from opencenteragent.modules import output_manager
from opencenteragent import utils
and context (functions, classes, or occasionally code) from other files:
# Path: opencenteragent/modules/output_manager.py
# LOG = logging.getLogger('opencenter.output')
# def _ok(code=0, message='success', data={}):
# def _fail(code=1, message='unknown failure', data={}):
# def _xfer_to_eof(fd_in, sock_out):
# def __init__(self, path, config={}):
# def register_action(self, plugin, shortpath, action, method,
# constraints=[], consequences=[], args={},
# timeout=30):
# def actions(self):
# def dispatch(self, input_data):
# def handle_logfile(self, input_data, sock=None):
# def handle_modules(self, input_data):
# class OutputManager(manager.Manager):
#
# Path: opencenteragent/utils.py
# def detailed_exception():
# def temporary_file():
# def temporary_directory():
. Output only the next line. | with utils.temporary_directory() as path: |
Here is a snippet: <|code_start|> ns['result_str'] = 'fail'
ns['result_code'] = 254
ns['result_data'] = {}
ns['sm_description'] = adventure_dsl
LOG.debug('About to run the following dsl: %s' % adventure_dsl)
node_list = {}
ns['input_data']['fails'] = []
for node in initial_state['nodes']:
node_list[int(node)] = 'ok'
attr_obj = ep.attrs.new()
attr_obj.node_id = node
attr_obj.key = 'last_task'
attr_obj.value = 'ok'
attr_obj.save()
try:
exec '(result_data, state_data) = ' \
'tasks.sm_eval(sm_description, input_data)' in ns, ns
except Exception as e:
for node in node_list.keys():
attr_obj = ep.attrs.new()
attr_obj.node_id = node
attr_obj.key = 'last_task'
attr_obj.value = 'failed'
attr_obj.save()
<|code_end|>
. Write the next line using the current file imports:
import base64
import json
import logging
import os
import random
import time
from opencenteragent.utils import detailed_exception
from opencenterclient.client import OpenCenterEndpoint
from state import StateMachine, StateMachineState
from primitives import OrchestratorTasks
and context from other files:
# Path: opencenteragent/utils.py
# def detailed_exception():
# exc_type, exc_value, exc_traceback = sys.exc_info()
# full_traceback = repr(
# traceback.format_exception(
# exc_type, exc_value, exc_traceback))
#
# return full_traceback
, which may include functions, classes, or code. Output only the next line. | return _retval(1, result_data=detailed_exception()) |
Continue the code snippet: <|code_start|> plan['states'][state] = state_value
input_state['rollback_plan'][node_id] = plan
self.logger.debug('new rollback plan for node %s: %s' % (node_id,
plan))
return input_state
def backend_wrapper(self, state_data, prim_name, fn, api, *args, **kwargs):
"""
this runs the passed backend primitive function on all the nodes
in the input state node list. Failed nodes are dropped into the
fail bucket to be rolled back.
Right now, this runs all the backend functions in series.
Probably it should be doing this in parallel.
"""
nodelist_length = len(state_data['nodes'])
result_data = {}
# we're serializing on this. when we shift to multi-target
# adventures in the ui, we probably want to do this in parallel,
# _particularly_ in the case of run_task
#
for node in state_data['nodes']:
try:
task_result = fn(state_data, api, node, *args, **kwargs)
except Exception as e:
task_result = {'result_code': 1,
'result_str': '%s: %s' % (prim_name, str(e)),
<|code_end|>
. Use current file imports:
import time
import logging
import opencenter.backends
from opencenterclient.client import OpenCenterEndpoint
from opencenteragent.utils import detailed_exception
from state import StateMachine, StateMachineState
from opencenter.db import api as db_api
and context (classes, functions, or code) from other files:
# Path: opencenteragent/utils.py
# def detailed_exception():
# exc_type, exc_value, exc_traceback = sys.exc_info()
# full_traceback = repr(
# traceback.format_exception(
# exc_type, exc_value, exc_traceback))
#
# return full_traceback
. Output only the next line. | 'result_data': detailed_exception()} |
Here is a snippet: <|code_start|> self._set_mixing = set_mixing
def get_parameters(self, map0, map1):
"""Get the required parameters to initialise ContactDifference"""
failed = map0._check_compatibility(map1, err=None)
return self._fix_parameters(map0, map1, failed)
def _fix_parameters(self, map0, map1, failed):
# First make the default output
output = {'topology': map0.topology,
'query': map0.query,
'haystack': map0.haystack,
'cutoff': map0.cutoff,
'n_neighbors_ignored': map0.n_neighbors_ignored}
for fail in failed:
if fail in {'query', 'haystack'}:
map0_set = set(getattr(map0, fail))
map1_set = set(getattr(map1, fail))
fixed = getattr(map0_set, self._set_mixing)(map1_set)
elif fail in {'cutoff', 'n_neighbors_ignored'}:
# We just set them to None
fixed = None
elif fail == 'topology':
# This requires quite a bit of logic
fixed = self._check_topology(map0, map1)
output[fail] = fixed
return tuple(output.values())
def _check_topology(self, map0, map1):
<|code_end|>
. Write the next line using the current file imports:
from .topology import check_topologies
and context from other files:
# Path: contact_map/topology.py
# def check_topologies(map0, map1, override_topology):
# """Check if the topologies of two contact maps are ok or can be fixed"""
# # Grab the two topologies
# top0 = map0.topology
# top1 = map1.topology
#
# # Figure out the overlapping atoms
# all_atoms0 = set(map0._all_atoms)
# all_atoms1 = set(map1._all_atoms)
#
# # Figure out overlapping residues
# all_residues0 = set(map0._all_residues)
# all_residues1 = set(map1._all_residues)
#
# # This is intersect (for difference)
# overlap_atoms = all_atoms0.intersection(all_atoms1)
# overlap_residues = all_residues0.intersection(all_residues1)
# top0, top1, topology = _get_default_topologies(top0, top1,
# override_topology)
#
# if override_topology:
# override_topology = topology
#
# all_atoms_ok = check_atoms_ok(top0, top1, overlap_atoms)
# all_res_ok = check_residues_ok(top0, top1, overlap_residues,
# override_topology)
# if not all_res_ok and not all_atoms_ok:
# topology = md.Topology()
#
# return all_atoms_ok, all_res_ok, topology
, which may include functions, classes, or code. Output only the next line. | all_atoms_ok, all_res_ok, topology = check_topologies( |
Continue the code snippet: <|code_start|>
# matplotlib is technically optional, but required for plotting
try:
except ImportError:
HAS_MATPLOTLIB = False
else:
HAS_MATPLOTLIB = True
try:
except ImportError:
HAS_NETWORKX = False
else:
HAS_NETWORKX = True
# pandas 0.25 not available on py27; can drop this when we drop py27
_PD_VERSION = tuple(int(x) for x in pd.__version__.split('.')[:2])
def _colorbar(with_colorbar, cmap_f, norm, min_val, ax=None):
if with_colorbar is False:
return None
elif with_colorbar is True:
cbmin = np.floor(min_val) # [-1.0..0.0] => -1; [0.0..1.0] => 0
cbmax = 1.0
<|code_end|>
. Use current file imports:
import collections
import scipy
import numpy as np
import pandas as pd
import warnings
import matplotlib
import matplotlib.pyplot as plt
import networkx as nx
from .plot_utils import ranged_colorbar, make_x_y_ranges, is_cmap_diverging
from pandas._libs.sparse import BlockIndex, IntIndex, SparseIndex
and context (classes, functions, or code) from other files:
# Path: contact_map/plot_utils.py
# def ranged_colorbar(cmap, norm, cbmin, cbmax, ax=None):
# """Create a colorbar with given endpoints.
#
# Parameters
# ----------
# cmap : str or matplotlib.colors.Colormap
# the base colormap to use
# norm : matplotlib.colors.Normalize
# the normalization (range of values) used in the image
# cbmin : float
# minimum value for the colorbar
# cbmax : float
# maximum value for the colorbar
# ax : matplotlib.Axes
# the axes to take space from to plot the colorbar
#
# Returns
# -------
# matplotlib.colorbar.Colorbar
# a colorbar restricted to the range given by cbmin, cbmax
# """
# # see https://stackoverflow.com/questions/24746231
# if isinstance(cmap, str):
# cmap_f = plt.get_cmap(cmap)
# else:
# cmap_f = cmap
#
# if ax is None:
# fig = plt
# else:
# fig = ax.figure
#
# cbmin_normed = float(cbmin - norm.vmin) / (norm.vmax - norm.vmin)
# cbmax_normed = float(cbmax - norm.vmin) / (norm.vmax - norm.vmin)
# n_colors = int(round((cbmax_normed - cbmin_normed) * cmap_f.N))
# colors = cmap_f(np.linspace(cbmin_normed, cbmax_normed, n_colors))
# new_cmap = LinearSegmentedColormap.from_list(name="Partial Map",
# colors=colors)
# new_norm = matplotlib.colors.Normalize(vmin=cbmin, vmax=cbmax)
# sm = plt.cm.ScalarMappable(cmap=new_cmap, norm=new_norm)
# sm._A = []
# cb = fig.colorbar(sm, ax=ax, fraction=0.046, pad=0.04)
# return cb
#
# def make_x_y_ranges(n_x, n_y, counter):
# """Return ContactPlotRange for both x and y"""
# n_x, n_y = _sanitize_n_x_n_y(n_x, n_y, counter)
# n_x = _ContactPlotRange(n_x)
# n_y = _ContactPlotRange(n_y)
# return n_x, n_y
#
# def is_cmap_diverging(cmap):
# if cmap in _DIVERGING:
# return True
# elif cmap in _SEQUENTIAL:
# return False
# else:
# warnings.warn("Unknown colormap: Treating as sequential.")
# return False
. Output only the next line. | cb = ranged_colorbar(cmap_f, norm, cbmin, cbmax, ax=ax) |
Based on the snippet: <|code_start|>
In general, instances of this class shouldn't be created by a user using
``__init__``; instead, they will be returned by other methods. So users
will often need to use this object for analysis.
Parameters
----------
counter : :class:`collections.Counter`
the counter describing the count of how often the contact occurred;
key is a frozenset of a pair of numbers (identifying the
atoms/residues); value is the raw count of the number of times it
occurred
object_f : callable
method to obtain the object associated with the number used in
``counter``; typically :meth:`mdtraj.Topology.residue` or
:meth:`mdtraj.Topology.atom`.
n_x : int, tuple(start, end), optional
range of objects in the x direction (used in plotting)
Default tries to plot the least amount of symetric points.
n_y : int, tuple(start, end), optional
range of objects in the y direction (used in plotting)
Default tries to show the least amount of symetric points.
max_size : int, optional
maximum size of the count
(used to determine the shape of output matrices and dataframes)
"""
def __init__(self, counter, object_f, n_x=None, n_y=None, max_size=None):
self._counter = counter
self._object_f = object_f
self.total_range = _get_total_counter_range(counter)
<|code_end|>
, predict the immediate next line with the help of imports:
import collections
import scipy
import numpy as np
import pandas as pd
import warnings
import matplotlib
import matplotlib.pyplot as plt
import networkx as nx
from .plot_utils import ranged_colorbar, make_x_y_ranges, is_cmap_diverging
from pandas._libs.sparse import BlockIndex, IntIndex, SparseIndex
and context (classes, functions, sometimes code) from other files:
# Path: contact_map/plot_utils.py
# def ranged_colorbar(cmap, norm, cbmin, cbmax, ax=None):
# """Create a colorbar with given endpoints.
#
# Parameters
# ----------
# cmap : str or matplotlib.colors.Colormap
# the base colormap to use
# norm : matplotlib.colors.Normalize
# the normalization (range of values) used in the image
# cbmin : float
# minimum value for the colorbar
# cbmax : float
# maximum value for the colorbar
# ax : matplotlib.Axes
# the axes to take space from to plot the colorbar
#
# Returns
# -------
# matplotlib.colorbar.Colorbar
# a colorbar restricted to the range given by cbmin, cbmax
# """
# # see https://stackoverflow.com/questions/24746231
# if isinstance(cmap, str):
# cmap_f = plt.get_cmap(cmap)
# else:
# cmap_f = cmap
#
# if ax is None:
# fig = plt
# else:
# fig = ax.figure
#
# cbmin_normed = float(cbmin - norm.vmin) / (norm.vmax - norm.vmin)
# cbmax_normed = float(cbmax - norm.vmin) / (norm.vmax - norm.vmin)
# n_colors = int(round((cbmax_normed - cbmin_normed) * cmap_f.N))
# colors = cmap_f(np.linspace(cbmin_normed, cbmax_normed, n_colors))
# new_cmap = LinearSegmentedColormap.from_list(name="Partial Map",
# colors=colors)
# new_norm = matplotlib.colors.Normalize(vmin=cbmin, vmax=cbmax)
# sm = plt.cm.ScalarMappable(cmap=new_cmap, norm=new_norm)
# sm._A = []
# cb = fig.colorbar(sm, ax=ax, fraction=0.046, pad=0.04)
# return cb
#
# def make_x_y_ranges(n_x, n_y, counter):
# """Return ContactPlotRange for both x and y"""
# n_x, n_y = _sanitize_n_x_n_y(n_x, n_y, counter)
# n_x = _ContactPlotRange(n_x)
# n_y = _ContactPlotRange(n_y)
# return n_x, n_y
#
# def is_cmap_diverging(cmap):
# if cmap in _DIVERGING:
# return True
# elif cmap in _SEQUENTIAL:
# return False
# else:
# warnings.warn("Unknown colormap: Treating as sequential.")
# return False
. Output only the next line. | self.n_x, self.n_y = make_x_y_ranges(n_x, n_y, counter) |
Based on the snippet: <|code_start|> fig, ax = plt.subplots(**kwargs)
# Check the number of pixels of the figure
self._check_number_of_pixels(fig)
self.plot_axes(ax=ax, cmap=cmap, diverging_cmap=diverging_cmap,
with_colorbar=with_colorbar)
return (fig, ax)
def plot_axes(self, ax, cmap='seismic', diverging_cmap=None,
with_colorbar=True):
"""
Plot contact matrix on a matplotlib.axes
Parameters
----------
ax : matplotlib.axes
axes to plot the contact matrix on
cmap : str
color map name, default 'seismic'
diverging_cmap : bool
If True, color map interpolation is from -1.0 to 1.0; allowing
diverging color maps to be used for contact maps and contact
differences. If false, the range is from 0 to 1.0. Default value
of None selects a value based on the value of cmap, treating as
False for unknown color maps.
with_colorbar : bool
If a colorbar is added to the axes
"""
if diverging_cmap is None:
<|code_end|>
, predict the immediate next line with the help of imports:
import collections
import scipy
import numpy as np
import pandas as pd
import warnings
import matplotlib
import matplotlib.pyplot as plt
import networkx as nx
from .plot_utils import ranged_colorbar, make_x_y_ranges, is_cmap_diverging
from pandas._libs.sparse import BlockIndex, IntIndex, SparseIndex
and context (classes, functions, sometimes code) from other files:
# Path: contact_map/plot_utils.py
# def ranged_colorbar(cmap, norm, cbmin, cbmax, ax=None):
# """Create a colorbar with given endpoints.
#
# Parameters
# ----------
# cmap : str or matplotlib.colors.Colormap
# the base colormap to use
# norm : matplotlib.colors.Normalize
# the normalization (range of values) used in the image
# cbmin : float
# minimum value for the colorbar
# cbmax : float
# maximum value for the colorbar
# ax : matplotlib.Axes
# the axes to take space from to plot the colorbar
#
# Returns
# -------
# matplotlib.colorbar.Colorbar
# a colorbar restricted to the range given by cbmin, cbmax
# """
# # see https://stackoverflow.com/questions/24746231
# if isinstance(cmap, str):
# cmap_f = plt.get_cmap(cmap)
# else:
# cmap_f = cmap
#
# if ax is None:
# fig = plt
# else:
# fig = ax.figure
#
# cbmin_normed = float(cbmin - norm.vmin) / (norm.vmax - norm.vmin)
# cbmax_normed = float(cbmax - norm.vmin) / (norm.vmax - norm.vmin)
# n_colors = int(round((cbmax_normed - cbmin_normed) * cmap_f.N))
# colors = cmap_f(np.linspace(cbmin_normed, cbmax_normed, n_colors))
# new_cmap = LinearSegmentedColormap.from_list(name="Partial Map",
# colors=colors)
# new_norm = matplotlib.colors.Normalize(vmin=cbmin, vmax=cbmax)
# sm = plt.cm.ScalarMappable(cmap=new_cmap, norm=new_norm)
# sm._A = []
# cb = fig.colorbar(sm, ax=ax, fraction=0.046, pad=0.04)
# return cb
#
# def make_x_y_ranges(n_x, n_y, counter):
# """Return ContactPlotRange for both x and y"""
# n_x, n_y = _sanitize_n_x_n_y(n_x, n_y, counter)
# n_x = _ContactPlotRange(n_x)
# n_y = _ContactPlotRange(n_y)
# return n_x, n_y
#
# def is_cmap_diverging(cmap):
# if cmap in _DIVERGING:
# return True
# elif cmap in _SEQUENTIAL:
# return False
# else:
# warnings.warn("Unknown colormap: Treating as sequential.")
# return False
. Output only the next line. | diverging_cmap = is_cmap_diverging(cmap) |
Predict the next line for this snippet: <|code_start|> 'red': [[0.0, 0.0, 0.0],
[0.5, 1.0, 1.0],
[1.0, 1.0, 1.0]],
'green': [[0.0, 0.0, 0.0],
[0.25, 0.0, 0.0],
[0.75, 1.0, 1.0],
[1.0, 1.0, 1.0]],
'blue': [[0.0, 0.0, 0.0],
[0.5, 0.0, 0.0],
[1.0, 1.0, 1.0]]},
N=256
)
elif cmap == 'custom':
# no matplotlib; can't do custom
pytest.skip()
color_map, expected = {
'seismic': ('seismic', True),
'Blues': ('Blues', False),
'custom': (custom, False),
}[cmap]
if cmap == 'custom':
with pytest.warns(UserWarning, match="Unknown colormap"):
assert is_cmap_diverging(color_map) == expected
else:
assert is_cmap_diverging(color_map) == expected
class TestContactRange(object):
def setup(self):
<|code_end|>
with the help of current file imports:
from .utils import *
from contact_map.plot_utils import *
from contact_map.plot_utils import _ContactPlotRange
from matplotlib.colors import LinearSegmentedColormap
and context from other files:
# Path: contact_map/plot_utils.py
# class _ContactPlotRange(object):
# """Object that deals with functions that are needed for plot ranges
#
# Parameters
# ----------
# n : int, tuple(start, end)
# range of objects in the given direction (used in plotting)
# """
# def __init__(self, n):
# self.n = n
# self.min, self.max = _int_or_range_to_tuple(n)
#
# @property
# def range_length(self):
# return self.max - self.min
#
# def __eq__(self, other):
# if isinstance(other, (int, tuple)):
# return self.n == other
# elif isinstance(other, self.__class__):
# return self.__dict__ == other.__dict__
# else:
# return False
#
# def __ne__(self, other):
# return not self.__eq__(other)
, which may contain function names, class names, or code. Output only the next line. | self.cr = _ContactPlotRange(5) |
Given the code snippet: <|code_start|>
class Graphx:
"""Main class of the graphx engine"""
def __init__(self):
#glutInit(sys.argv)
self.width, self.height = 1280, 800
pygame.init()
self.screen = pygame.display.set_mode((self.width, self.height), OPENGL | DOUBLEBUF)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(65.0, self.width/float(self.height), 0.01, 1000.0)
glMatrixMode(GL_MODELVIEW)
glEnable(GL_DEPTH_TEST)
self.camera = Camera((0.0, 100, 0), (0.0, 0, 0))
#Base
<|code_end|>
, generate the next line using the imports in this file:
import pygame
import OpenGL.GL as gl
import numpy as np
from pygame.locals import *
from OpenGL.GL import shaders
from OpenGL.arrays import vbo
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *
from Camera import Camera
from Conf import Conf
from IHM import IHM
and context (functions, classes, or occasionally code) from other files:
# Path: Conf.py
# class Conf:
# """Configuration file"""
# LAUNCH_TIME = time.time()
#
# class TURTLE:
# """ Configuration of the turtle """
# INIT_POS = (0, 0, 0) # initial position
# INIT_HEADING = (0, 1, 0) # initial heading
# INIT_COLOR = (0.5, 0.25, 0.0) # initial color
# # INIT_COLOR = (0.5, 0.25, 0) # initial color
# APPEND_STEP = 2
#
# class GRAPHX:
# BASE_COLOR = (0.2, 0.2, 0.2)
# CAMERA_UPDATE_PERIOD = 1
# CAMERA_ROTATION_VELOC = 0.1
#
# class LSYSTEM:
# AUTORUN_STEP = 5
#
# DEBUG = {
# 'lsystem': 0,
# #'turtle': 1
# }
#
# HELP = \
# """Usage: ./3dlsystem.py [fractal_name] [fractal_step:int] ['debug']
# where fractal_name is can be:
# 'tree1': A first try for drawing a 3D tree
# 'tree2': A second 3D tree, much betted, with nice colors
# 'tree2D': A tree, 2D version
# 'tree3': A third 3D tree
# 'tree3psy': The same tree as the previous one, buffed with LSD
# 'tree4': Another 2D tree
# 'tree5': A very fractalic-looking 3D tree
# 'tree6': Another type of 3D tree with random factor
# 'hilbert': The std hilbert curve
# 'koch': The std koch curve
# 'koch3D': a koch curve in 3D, like a diamond
# 'dragon': the well known dragon curve (2D)
# 'tedragon' the tedragon curve (2D)
# 'levyc': The Levy Curve
# 'sierpinsky': the sierpinsky carpet (some LSD added)
# 'sierpinsky2': another version of the sierpinksy carpet
# (zoom to see the difference)
# and fractal_step is the precision of the fractal.
# It's not advised to give much more than 6 or 7 for the safety of your
# computer...
# For each fractal, a default step number has been set wich an average
# interessant value. You can specify a negative number to decrease the
# default step number.
# You can add the mention 'debug' to enable a step by step generation.
#
# Here are the available controls in the display window:
# - Left/Right key: control camera rotation speed
# - Up/Down key or mouse wheel: zoom in/out
# - z/q/s/d/a/e : rotate the fractal
# - space : look at the last drawd point of the fractal
# - enter : reinitialize the view
# - In debug mode:
# - n: go to next step
# - r: enable autorun: this will automatically run 5 steps by frame
# - +/-: control autorun speed. Do not increase autorun speed to much
# to keep an acceptable framerate.
# """
# FOREST_HELP = \
# """Usage: ./forest.py [size=S] [fractal=F] [random=R] [debug[=True|False]]
# Where the parameters can be precised in any order, and means:
# - S: int >= 1 is the size of the forest.
# The fractal number will be set to S squared.
# Default value is 10
# - F: int is a modificator of the precision of
# the fractals that will be generated.
# Any positive or negative number can be specified,
# but values higher than 2 or 3 are not advised.
# Default value is -2.
# - R: float > 0 is the random factor for the placement of the
# fractal trees.
# By default, it is computed according to the size of
# the grid
# - debug allow to enter debug mode
#
# Here are the available controls in the display window:
# - Left/Right key: control camera rotation speed
# - Up/Down key or mouse wheel: zoom in/out
# - z/q/s/d/a/e : rotate the fractal
# - space : look at the last drawd point of the fractal
# - enter : reinitialize the view
# - In debug mode:
# - n: go to next step
# - r: enable autorun: this will automatically run 5 steps by frame
# - +/-: control autorun speed. Do not increase autorun speed to much
# to keep an acceptable framerate.
# """
. Output only the next line. | vertices = np.array([[100.0, -10.0, 100.0, Conf.GRAPHX.BASE_COLOR[0],Conf.GRAPHX.BASE_COLOR[1],Conf.GRAPHX.BASE_COLOR[2]], \ |
Given the code snippet: <|code_start|> print "Error: no argument found for inst `"+char+"' in: ", self.LSCode[dbg:dbg+10]
return;
# if we are executing a parametized rule:
# replace each variable by its value in the params array
for param in self.LSParams:
if param in arg:
arg = arg.replace(param, str(float(self.LSParams[param])))
res = eval(arg) # evaluate expression
#print self.LSVars[char].__name__ + "(" + str(res) + ")"
if char in self.LSVars:
self.LSVars[char](res) # call corresponding function, giving the parameter
else:
#print "Step: ", pos[0], ": ",
#print self.LSVars[char].__name__ + "(" + str(self.LSParams[char]) + ")"
if char in self.LSVars:
self.LSVars[char](self.LSParams[char]) # call corresponding function, giving the parameter
pos[0] += 1 # increase look ahead
""" Events handling """
def event(self, e):
if e.type == pygame.KEYDOWN and self.currentMaxStep < self.LSCodeLen:
if e.unicode == 'n':
self.inc_max_step()
if e.unicode == 'r':
self.autorun = not self.autorun
if e.unicode == '+':
<|code_end|>
, generate the next line using the imports in this file:
import math
import pygame
from turtle.Turtle import *
from Conf import Conf
from OpenGL.GL import shaders
from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GL.ARB.framebuffer_object import *
from OpenGL.GL.EXT.framebuffer_object import *
from OpenGL.GL.ARB.vertex_buffer_object import *
from OpenGL.GL.ARB.geometry_shader4 import *
from OpenGL.GL.EXT.geometry_shader4 import *
and context (functions, classes, or occasionally code) from other files:
# Path: Conf.py
# class Conf:
# """Configuration file"""
# LAUNCH_TIME = time.time()
#
# class TURTLE:
# """ Configuration of the turtle """
# INIT_POS = (0, 0, 0) # initial position
# INIT_HEADING = (0, 1, 0) # initial heading
# INIT_COLOR = (0.5, 0.25, 0.0) # initial color
# # INIT_COLOR = (0.5, 0.25, 0) # initial color
# APPEND_STEP = 2
#
# class GRAPHX:
# BASE_COLOR = (0.2, 0.2, 0.2)
# CAMERA_UPDATE_PERIOD = 1
# CAMERA_ROTATION_VELOC = 0.1
#
# class LSYSTEM:
# AUTORUN_STEP = 5
#
# DEBUG = {
# 'lsystem': 0,
# #'turtle': 1
# }
#
# HELP = \
# """Usage: ./3dlsystem.py [fractal_name] [fractal_step:int] ['debug']
# where fractal_name is can be:
# 'tree1': A first try for drawing a 3D tree
# 'tree2': A second 3D tree, much betted, with nice colors
# 'tree2D': A tree, 2D version
# 'tree3': A third 3D tree
# 'tree3psy': The same tree as the previous one, buffed with LSD
# 'tree4': Another 2D tree
# 'tree5': A very fractalic-looking 3D tree
# 'tree6': Another type of 3D tree with random factor
# 'hilbert': The std hilbert curve
# 'koch': The std koch curve
# 'koch3D': a koch curve in 3D, like a diamond
# 'dragon': the well known dragon curve (2D)
# 'tedragon' the tedragon curve (2D)
# 'levyc': The Levy Curve
# 'sierpinsky': the sierpinsky carpet (some LSD added)
# 'sierpinsky2': another version of the sierpinksy carpet
# (zoom to see the difference)
# and fractal_step is the precision of the fractal.
# It's not advised to give much more than 6 or 7 for the safety of your
# computer...
# For each fractal, a default step number has been set wich an average
# interessant value. You can specify a negative number to decrease the
# default step number.
# You can add the mention 'debug' to enable a step by step generation.
#
# Here are the available controls in the display window:
# - Left/Right key: control camera rotation speed
# - Up/Down key or mouse wheel: zoom in/out
# - z/q/s/d/a/e : rotate the fractal
# - space : look at the last drawd point of the fractal
# - enter : reinitialize the view
# - In debug mode:
# - n: go to next step
# - r: enable autorun: this will automatically run 5 steps by frame
# - +/-: control autorun speed. Do not increase autorun speed to much
# to keep an acceptable framerate.
# """
# FOREST_HELP = \
# """Usage: ./forest.py [size=S] [fractal=F] [random=R] [debug[=True|False]]
# Where the parameters can be precised in any order, and means:
# - S: int >= 1 is the size of the forest.
# The fractal number will be set to S squared.
# Default value is 10
# - F: int is a modificator of the precision of
# the fractals that will be generated.
# Any positive or negative number can be specified,
# but values higher than 2 or 3 are not advised.
# Default value is -2.
# - R: float > 0 is the random factor for the placement of the
# fractal trees.
# By default, it is computed according to the size of
# the grid
# - debug allow to enter debug mode
#
# Here are the available controls in the display window:
# - Left/Right key: control camera rotation speed
# - Up/Down key or mouse wheel: zoom in/out
# - z/q/s/d/a/e : rotate the fractal
# - space : look at the last drawd point of the fractal
# - enter : reinitialize the view
# - In debug mode:
# - n: go to next step
# - r: enable autorun: this will automatically run 5 steps by frame
# - +/-: control autorun speed. Do not increase autorun speed to much
# to keep an acceptable framerate.
# """
. Output only the next line. | Conf.LSYSTEM.AUTORUN_STEP *= 10 |
Given snippet: <|code_start|> if not 'help' in sys.argv:
self.gx = Graphx()
[self.fractal, steps] = self.parse_input()
self.fractal.setSteps(steps)
self.quit = False
self.follow_building = False
# The function called whenever a key is pressed
# it propagates the events to the fractal and the graphx
def event(self, e):
if e.type == pygame.QUIT:
self.quit = True
elif e.type == pygame.KEYDOWN:
if e.key == pygame.K_ESCAPE:
self.quit = True
elif e.key == pygame.K_SPACE:
self.follow_building = not self.follow_building;
self.gx.event(e)
if self.fractal is not None:
self.fractal.event(e)
# handle command line argument
def parse_input(self):
lsys = None
lsstep = 0
for arg in sys.argv:
if arg == 'help':
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import sys
import math
import time
import pygame
import pygame.locals
from OpenGL.GLUT import *
from OpenGL.GL import *
from graphx.Graphx import *
from turtle.Turtle import *
from lsystem import *
from Conf import Conf
from func import *
and context:
# Path: Conf.py
# class Conf:
# """Configuration file"""
# LAUNCH_TIME = time.time()
#
# class TURTLE:
# """ Configuration of the turtle """
# INIT_POS = (0, 0, 0) # initial position
# INIT_HEADING = (0, 1, 0) # initial heading
# INIT_COLOR = (0.5, 0.25, 0.0) # initial color
# # INIT_COLOR = (0.5, 0.25, 0) # initial color
# APPEND_STEP = 2
#
# class GRAPHX:
# BASE_COLOR = (0.2, 0.2, 0.2)
# CAMERA_UPDATE_PERIOD = 1
# CAMERA_ROTATION_VELOC = 0.1
#
# class LSYSTEM:
# AUTORUN_STEP = 5
#
# DEBUG = {
# 'lsystem': 0,
# #'turtle': 1
# }
#
# HELP = \
# """Usage: ./3dlsystem.py [fractal_name] [fractal_step:int] ['debug']
# where fractal_name is can be:
# 'tree1': A first try for drawing a 3D tree
# 'tree2': A second 3D tree, much betted, with nice colors
# 'tree2D': A tree, 2D version
# 'tree3': A third 3D tree
# 'tree3psy': The same tree as the previous one, buffed with LSD
# 'tree4': Another 2D tree
# 'tree5': A very fractalic-looking 3D tree
# 'tree6': Another type of 3D tree with random factor
# 'hilbert': The std hilbert curve
# 'koch': The std koch curve
# 'koch3D': a koch curve in 3D, like a diamond
# 'dragon': the well known dragon curve (2D)
# 'tedragon' the tedragon curve (2D)
# 'levyc': The Levy Curve
# 'sierpinsky': the sierpinsky carpet (some LSD added)
# 'sierpinsky2': another version of the sierpinksy carpet
# (zoom to see the difference)
# and fractal_step is the precision of the fractal.
# It's not advised to give much more than 6 or 7 for the safety of your
# computer...
# For each fractal, a default step number has been set wich an average
# interessant value. You can specify a negative number to decrease the
# default step number.
# You can add the mention 'debug' to enable a step by step generation.
#
# Here are the available controls in the display window:
# - Left/Right key: control camera rotation speed
# - Up/Down key or mouse wheel: zoom in/out
# - z/q/s/d/a/e : rotate the fractal
# - space : look at the last drawd point of the fractal
# - enter : reinitialize the view
# - In debug mode:
# - n: go to next step
# - r: enable autorun: this will automatically run 5 steps by frame
# - +/-: control autorun speed. Do not increase autorun speed to much
# to keep an acceptable framerate.
# """
# FOREST_HELP = \
# """Usage: ./forest.py [size=S] [fractal=F] [random=R] [debug[=True|False]]
# Where the parameters can be precised in any order, and means:
# - S: int >= 1 is the size of the forest.
# The fractal number will be set to S squared.
# Default value is 10
# - F: int is a modificator of the precision of
# the fractals that will be generated.
# Any positive or negative number can be specified,
# but values higher than 2 or 3 are not advised.
# Default value is -2.
# - R: float > 0 is the random factor for the placement of the
# fractal trees.
# By default, it is computed according to the size of
# the grid
# - debug allow to enter debug mode
#
# Here are the available controls in the display window:
# - Left/Right key: control camera rotation speed
# - Up/Down key or mouse wheel: zoom in/out
# - z/q/s/d/a/e : rotate the fractal
# - space : look at the last drawd point of the fractal
# - enter : reinitialize the view
# - In debug mode:
# - n: go to next step
# - r: enable autorun: this will automatically run 5 steps by frame
# - +/-: control autorun speed. Do not increase autorun speed to much
# to keep an acceptable framerate.
# """
which might include code, classes, or functions. Output only the next line. | print Conf.HELP |
Predict the next line for this snippet: <|code_start|>
class Turtle:
"""This class is the turtle that will draw the fractals"""
class State:
"""This class represent a state of the turtle, for push and pop"""
def __init__(self, pos, heading, color):
self.pos = Vector().set(pos)
self.heading = Vector().set(heading)
self.color = Vector().set(color)
def __init__(self, pos=None):
if pos is None:
<|code_end|>
with the help of current file imports:
from Vector import *
from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.arrays import vbo
from Conf import Conf
import pdb
import math
import colorsys
import random
import numpy as np
import time
and context from other files:
# Path: Conf.py
# class Conf:
# """Configuration file"""
# LAUNCH_TIME = time.time()
#
# class TURTLE:
# """ Configuration of the turtle """
# INIT_POS = (0, 0, 0) # initial position
# INIT_HEADING = (0, 1, 0) # initial heading
# INIT_COLOR = (0.5, 0.25, 0.0) # initial color
# # INIT_COLOR = (0.5, 0.25, 0) # initial color
# APPEND_STEP = 2
#
# class GRAPHX:
# BASE_COLOR = (0.2, 0.2, 0.2)
# CAMERA_UPDATE_PERIOD = 1
# CAMERA_ROTATION_VELOC = 0.1
#
# class LSYSTEM:
# AUTORUN_STEP = 5
#
# DEBUG = {
# 'lsystem': 0,
# #'turtle': 1
# }
#
# HELP = \
# """Usage: ./3dlsystem.py [fractal_name] [fractal_step:int] ['debug']
# where fractal_name is can be:
# 'tree1': A first try for drawing a 3D tree
# 'tree2': A second 3D tree, much betted, with nice colors
# 'tree2D': A tree, 2D version
# 'tree3': A third 3D tree
# 'tree3psy': The same tree as the previous one, buffed with LSD
# 'tree4': Another 2D tree
# 'tree5': A very fractalic-looking 3D tree
# 'tree6': Another type of 3D tree with random factor
# 'hilbert': The std hilbert curve
# 'koch': The std koch curve
# 'koch3D': a koch curve in 3D, like a diamond
# 'dragon': the well known dragon curve (2D)
# 'tedragon' the tedragon curve (2D)
# 'levyc': The Levy Curve
# 'sierpinsky': the sierpinsky carpet (some LSD added)
# 'sierpinsky2': another version of the sierpinksy carpet
# (zoom to see the difference)
# and fractal_step is the precision of the fractal.
# It's not advised to give much more than 6 or 7 for the safety of your
# computer...
# For each fractal, a default step number has been set wich an average
# interessant value. You can specify a negative number to decrease the
# default step number.
# You can add the mention 'debug' to enable a step by step generation.
#
# Here are the available controls in the display window:
# - Left/Right key: control camera rotation speed
# - Up/Down key or mouse wheel: zoom in/out
# - z/q/s/d/a/e : rotate the fractal
# - space : look at the last drawd point of the fractal
# - enter : reinitialize the view
# - In debug mode:
# - n: go to next step
# - r: enable autorun: this will automatically run 5 steps by frame
# - +/-: control autorun speed. Do not increase autorun speed to much
# to keep an acceptable framerate.
# """
# FOREST_HELP = \
# """Usage: ./forest.py [size=S] [fractal=F] [random=R] [debug[=True|False]]
# Where the parameters can be precised in any order, and means:
# - S: int >= 1 is the size of the forest.
# The fractal number will be set to S squared.
# Default value is 10
# - F: int is a modificator of the precision of
# the fractals that will be generated.
# Any positive or negative number can be specified,
# but values higher than 2 or 3 are not advised.
# Default value is -2.
# - R: float > 0 is the random factor for the placement of the
# fractal trees.
# By default, it is computed according to the size of
# the grid
# - debug allow to enter debug mode
#
# Here are the available controls in the display window:
# - Left/Right key: control camera rotation speed
# - Up/Down key or mouse wheel: zoom in/out
# - z/q/s/d/a/e : rotate the fractal
# - space : look at the last drawd point of the fractal
# - enter : reinitialize the view
# - In debug mode:
# - n: go to next step
# - r: enable autorun: this will automatically run 5 steps by frame
# - +/-: control autorun speed. Do not increase autorun speed to much
# to keep an acceptable framerate.
# """
, which may contain function names, class names, or code. Output only the next line. | self.pos = Vector(Conf.TURTLE.INIT_POS) |
Here is a snippet: <|code_start|> self.autorun = not self.autorun
def runTurtleRun(self, stepbystep=False):
# gestion de l'autorun : si 'vrai', chaque appel lance automatiquement la tortue une etape plus loin
if self.autorun:
self.inc_max_step()
# lancement de la tortue
self.turtle.begin()
if stepbystep:
k = -1
for char in self.LSCode:
k += 1
if char in self.LSVars and k < self.currentMaxStep:
self.LSVars[char](self.LSParams[char])
else:
for char in self.LSCode:
if char in self.LSVars:
self.LSVars[char](self.LSParams[char])
self.turtle.end()
def generate_rec(self, iterations):
if iterations == 0:
return
newcode = ''.join(map(self.get_rule, self.LSCode))
self.LSCode = newcode
print "============= Generation [" + str(self.LSSteps - iterations) + "], size=" + str(len(newcode)) + ": "
<|code_end|>
. Write the next line using the current file imports:
import math
import pygame
from turtle.Turtle import *
from Conf import Conf
and context from other files:
# Path: Conf.py
# class Conf:
# """Configuration file"""
# LAUNCH_TIME = time.time()
#
# class TURTLE:
# """ Configuration of the turtle """
# INIT_POS = (0, 0, 0) # initial position
# INIT_HEADING = (0, 1, 0) # initial heading
# INIT_COLOR = (0.5, 0.25, 0.0) # initial color
# # INIT_COLOR = (0.5, 0.25, 0) # initial color
# APPEND_STEP = 2
#
# class GRAPHX:
# BASE_COLOR = (0.2, 0.2, 0.2)
# CAMERA_UPDATE_PERIOD = 1
# CAMERA_ROTATION_VELOC = 0.1
#
# class LSYSTEM:
# AUTORUN_STEP = 5
#
# DEBUG = {
# 'lsystem': 0,
# #'turtle': 1
# }
#
# HELP = \
# """Usage: ./3dlsystem.py [fractal_name] [fractal_step:int] ['debug']
# where fractal_name is can be:
# 'tree1': A first try for drawing a 3D tree
# 'tree2': A second 3D tree, much betted, with nice colors
# 'tree2D': A tree, 2D version
# 'tree3': A third 3D tree
# 'tree3psy': The same tree as the previous one, buffed with LSD
# 'tree4': Another 2D tree
# 'tree5': A very fractalic-looking 3D tree
# 'tree6': Another type of 3D tree with random factor
# 'hilbert': The std hilbert curve
# 'koch': The std koch curve
# 'koch3D': a koch curve in 3D, like a diamond
# 'dragon': the well known dragon curve (2D)
# 'tedragon' the tedragon curve (2D)
# 'levyc': The Levy Curve
# 'sierpinsky': the sierpinsky carpet (some LSD added)
# 'sierpinsky2': another version of the sierpinksy carpet
# (zoom to see the difference)
# and fractal_step is the precision of the fractal.
# It's not advised to give much more than 6 or 7 for the safety of your
# computer...
# For each fractal, a default step number has been set wich an average
# interessant value. You can specify a negative number to decrease the
# default step number.
# You can add the mention 'debug' to enable a step by step generation.
#
# Here are the available controls in the display window:
# - Left/Right key: control camera rotation speed
# - Up/Down key or mouse wheel: zoom in/out
# - z/q/s/d/a/e : rotate the fractal
# - space : look at the last drawd point of the fractal
# - enter : reinitialize the view
# - In debug mode:
# - n: go to next step
# - r: enable autorun: this will automatically run 5 steps by frame
# - +/-: control autorun speed. Do not increase autorun speed to much
# to keep an acceptable framerate.
# """
# FOREST_HELP = \
# """Usage: ./forest.py [size=S] [fractal=F] [random=R] [debug[=True|False]]
# Where the parameters can be precised in any order, and means:
# - S: int >= 1 is the size of the forest.
# The fractal number will be set to S squared.
# Default value is 10
# - F: int is a modificator of the precision of
# the fractals that will be generated.
# Any positive or negative number can be specified,
# but values higher than 2 or 3 are not advised.
# Default value is -2.
# - R: float > 0 is the random factor for the placement of the
# fractal trees.
# By default, it is computed according to the size of
# the grid
# - debug allow to enter debug mode
#
# Here are the available controls in the display window:
# - Left/Right key: control camera rotation speed
# - Up/Down key or mouse wheel: zoom in/out
# - z/q/s/d/a/e : rotate the fractal
# - space : look at the last drawd point of the fractal
# - enter : reinitialize the view
# - In debug mode:
# - n: go to next step
# - r: enable autorun: this will automatically run 5 steps by frame
# - +/-: control autorun speed. Do not increase autorun speed to much
# to keep an acceptable framerate.
# """
, which may include functions, classes, or code. Output only the next line. | if 'lsystem' in Conf.DEBUG and Conf.DEBUG['lsystem'] >= 1: |
Using the snippet: <|code_start|>]
class Main:
"""Entry point"""
def __init__(self):
print "===== 3D L-system FOREST creator - call 'help' for usage information ==="
if not 'help' in sys.argv:
self.gx = Graphx()
self.quit = False
self.fractals = []
self.turtles = []
self.grid_prec = None
self.fractal_prec = None
self.grid_random = None
self.debug = False
self.parse_input()
self.init_grid(self.grid_prec, self.grid_random)
def parse_input(self):
for arg in sys.argv:
if ".py" in arg:
continue
if arg == "help":
<|code_end|>
, determine the next line of code. You have imports:
import sys
import math
import time
import random
import pygame
import pygame.locals
from OpenGL.GLUT import *
from OpenGL.GL import *
from graphx.Graphx import *
from turtle.Turtle import *
from lsystem import *
from Conf import Conf
from func import *
and context (class names, function names, or code) available:
# Path: Conf.py
# class Conf:
# """Configuration file"""
# LAUNCH_TIME = time.time()
#
# class TURTLE:
# """ Configuration of the turtle """
# INIT_POS = (0, 0, 0) # initial position
# INIT_HEADING = (0, 1, 0) # initial heading
# INIT_COLOR = (0.5, 0.25, 0.0) # initial color
# # INIT_COLOR = (0.5, 0.25, 0) # initial color
# APPEND_STEP = 2
#
# class GRAPHX:
# BASE_COLOR = (0.2, 0.2, 0.2)
# CAMERA_UPDATE_PERIOD = 1
# CAMERA_ROTATION_VELOC = 0.1
#
# class LSYSTEM:
# AUTORUN_STEP = 5
#
# DEBUG = {
# 'lsystem': 0,
# #'turtle': 1
# }
#
# HELP = \
# """Usage: ./3dlsystem.py [fractal_name] [fractal_step:int] ['debug']
# where fractal_name is can be:
# 'tree1': A first try for drawing a 3D tree
# 'tree2': A second 3D tree, much betted, with nice colors
# 'tree2D': A tree, 2D version
# 'tree3': A third 3D tree
# 'tree3psy': The same tree as the previous one, buffed with LSD
# 'tree4': Another 2D tree
# 'tree5': A very fractalic-looking 3D tree
# 'tree6': Another type of 3D tree with random factor
# 'hilbert': The std hilbert curve
# 'koch': The std koch curve
# 'koch3D': a koch curve in 3D, like a diamond
# 'dragon': the well known dragon curve (2D)
# 'tedragon' the tedragon curve (2D)
# 'levyc': The Levy Curve
# 'sierpinsky': the sierpinsky carpet (some LSD added)
# 'sierpinsky2': another version of the sierpinksy carpet
# (zoom to see the difference)
# and fractal_step is the precision of the fractal.
# It's not advised to give much more than 6 or 7 for the safety of your
# computer...
# For each fractal, a default step number has been set wich an average
# interessant value. You can specify a negative number to decrease the
# default step number.
# You can add the mention 'debug' to enable a step by step generation.
#
# Here are the available controls in the display window:
# - Left/Right key: control camera rotation speed
# - Up/Down key or mouse wheel: zoom in/out
# - z/q/s/d/a/e : rotate the fractal
# - space : look at the last drawd point of the fractal
# - enter : reinitialize the view
# - In debug mode:
# - n: go to next step
# - r: enable autorun: this will automatically run 5 steps by frame
# - +/-: control autorun speed. Do not increase autorun speed to much
# to keep an acceptable framerate.
# """
# FOREST_HELP = \
# """Usage: ./forest.py [size=S] [fractal=F] [random=R] [debug[=True|False]]
# Where the parameters can be precised in any order, and means:
# - S: int >= 1 is the size of the forest.
# The fractal number will be set to S squared.
# Default value is 10
# - F: int is a modificator of the precision of
# the fractals that will be generated.
# Any positive or negative number can be specified,
# but values higher than 2 or 3 are not advised.
# Default value is -2.
# - R: float > 0 is the random factor for the placement of the
# fractal trees.
# By default, it is computed according to the size of
# the grid
# - debug allow to enter debug mode
#
# Here are the available controls in the display window:
# - Left/Right key: control camera rotation speed
# - Up/Down key or mouse wheel: zoom in/out
# - z/q/s/d/a/e : rotate the fractal
# - space : look at the last drawd point of the fractal
# - enter : reinitialize the view
# - In debug mode:
# - n: go to next step
# - r: enable autorun: this will automatically run 5 steps by frame
# - +/-: control autorun speed. Do not increase autorun speed to much
# to keep an acceptable framerate.
# """
. Output only the next line. | print Conf.FOREST_HELP |
Predict the next line for this snippet: <|code_start|>
class Camera:
"""Represent the camera"""
def __init__(self, pos, look):
self.pos = Vector((pos[0], pos[1], pos[2]))
self.lookat = Vector((look[0], look[1], look[2]))
self.angleY = 0
self.angleX = 0
self.angleZ = 0
self.distance = 100
gluLookAt(0.0, 0.0, 0.0,
look[0], look[1], look[2],
0.0, 1.0, 0.0)
self.lookat = (0.0, 0.0, 0.0, time.time())
pygame.key.set_repeat(500, 10)
def update(self):
<|code_end|>
with the help of current file imports:
import math
import time
import pygame
from OpenGL.GL import *
from OpenGL.GLU import *
from Conf import Conf
from Vector import *
and context from other files:
# Path: Conf.py
# class Conf:
# """Configuration file"""
# LAUNCH_TIME = time.time()
#
# class TURTLE:
# """ Configuration of the turtle """
# INIT_POS = (0, 0, 0) # initial position
# INIT_HEADING = (0, 1, 0) # initial heading
# INIT_COLOR = (0.5, 0.25, 0.0) # initial color
# # INIT_COLOR = (0.5, 0.25, 0) # initial color
# APPEND_STEP = 2
#
# class GRAPHX:
# BASE_COLOR = (0.2, 0.2, 0.2)
# CAMERA_UPDATE_PERIOD = 1
# CAMERA_ROTATION_VELOC = 0.1
#
# class LSYSTEM:
# AUTORUN_STEP = 5
#
# DEBUG = {
# 'lsystem': 0,
# #'turtle': 1
# }
#
# HELP = \
# """Usage: ./3dlsystem.py [fractal_name] [fractal_step:int] ['debug']
# where fractal_name is can be:
# 'tree1': A first try for drawing a 3D tree
# 'tree2': A second 3D tree, much betted, with nice colors
# 'tree2D': A tree, 2D version
# 'tree3': A third 3D tree
# 'tree3psy': The same tree as the previous one, buffed with LSD
# 'tree4': Another 2D tree
# 'tree5': A very fractalic-looking 3D tree
# 'tree6': Another type of 3D tree with random factor
# 'hilbert': The std hilbert curve
# 'koch': The std koch curve
# 'koch3D': a koch curve in 3D, like a diamond
# 'dragon': the well known dragon curve (2D)
# 'tedragon' the tedragon curve (2D)
# 'levyc': The Levy Curve
# 'sierpinsky': the sierpinsky carpet (some LSD added)
# 'sierpinsky2': another version of the sierpinksy carpet
# (zoom to see the difference)
# and fractal_step is the precision of the fractal.
# It's not advised to give much more than 6 or 7 for the safety of your
# computer...
# For each fractal, a default step number has been set wich an average
# interessant value. You can specify a negative number to decrease the
# default step number.
# You can add the mention 'debug' to enable a step by step generation.
#
# Here are the available controls in the display window:
# - Left/Right key: control camera rotation speed
# - Up/Down key or mouse wheel: zoom in/out
# - z/q/s/d/a/e : rotate the fractal
# - space : look at the last drawd point of the fractal
# - enter : reinitialize the view
# - In debug mode:
# - n: go to next step
# - r: enable autorun: this will automatically run 5 steps by frame
# - +/-: control autorun speed. Do not increase autorun speed to much
# to keep an acceptable framerate.
# """
# FOREST_HELP = \
# """Usage: ./forest.py [size=S] [fractal=F] [random=R] [debug[=True|False]]
# Where the parameters can be precised in any order, and means:
# - S: int >= 1 is the size of the forest.
# The fractal number will be set to S squared.
# Default value is 10
# - F: int is a modificator of the precision of
# the fractals that will be generated.
# Any positive or negative number can be specified,
# but values higher than 2 or 3 are not advised.
# Default value is -2.
# - R: float > 0 is the random factor for the placement of the
# fractal trees.
# By default, it is computed according to the size of
# the grid
# - debug allow to enter debug mode
#
# Here are the available controls in the display window:
# - Left/Right key: control camera rotation speed
# - Up/Down key or mouse wheel: zoom in/out
# - z/q/s/d/a/e : rotate the fractal
# - space : look at the last drawd point of the fractal
# - enter : reinitialize the view
# - In debug mode:
# - n: go to next step
# - r: enable autorun: this will automatically run 5 steps by frame
# - +/-: control autorun speed. Do not increase autorun speed to much
# to keep an acceptable framerate.
# """
, which may contain function names, class names, or code. Output only the next line. | self.angleY -= Conf.GRAPHX.CAMERA_ROTATION_VELOC |
Continue the code snippet: <|code_start|>""" test/imputation/ts/test_moving_window.py """
#pylint:disable=missing-docstring, redefined-outer-name
@pytest.mark.parametrize(
'pos1,pos2,expected',
[
(2, 0, 11.5),
(2, 2, 12),
(2, -1, 12.5)]
)
def test_defaults_impute(pos1, pos2, expected, mw_data):
mw_data[pos1, pos2] = np.nan
imputed = impy.moving_window(mw_data)
<|code_end|>
. Use current file imports:
import pytest
import numpy as np
import impyute as impy
from impyute.ops.testing import return_na_check
and context (classes, functions, or code) from other files:
# Path: impyute/ops/testing.py
# def return_na_check(data):
# """Helper function for tests to check if the data returned is a
# numpy array and that the imputed data has no NaN's.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# None
#
# """
# assert isinstance(data, np.ndarray)
# assert not np.isnan(data).any()
. Output only the next line. | return_na_check(imputed) |
Using the snippet: <|code_start|>
@wrapper.wrappers
@wrapper.checks
def em(data, eps=0.1):
""" Imputes given data using expectation maximization.
E-step: Calculates the expected complete data log likelihood ratio.
M-step: Finds the parameters that maximize the log likelihood of the
complete data.
Parameters
----------
data: numpy.nd.array
Data to impute.
eps: float
The amount of minimum change between iterations to break, if relative change < eps, converge.
relative change = abs(current - previous) / previous
inplace: boolean
If True, operate on the numpy array reference
Returns
-------
numpy.nd.array
Imputed data.
"""
<|code_end|>
, determine the next line of code. You have imports:
import numpy as np
from impyute.ops import matrix
from impyute.ops import wrapper
and context (class names, function names, or code) available:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
#
# Path: impyute/ops/wrapper.py
# @wraps(fn)
# def wrapper(*args, **kwargs):
# postprocess_fn = None
# ## convert tuple to list so args can be modified
# args = list(args)
# ## Either make a copy or use a pointer to the original
# if kwargs.get('inplace'):
# args[0] = args[0]
# else:
# args[0] = args[0].copy()
#
# ## If input data is a dataframe then cast the input to an np.array
# ## and set an indicator flag before continuing
# pd_DataFrame = get_pandas_df()
# if pd_DataFrame and isinstance(args[0], pd_DataFrame):
# postprocess_fn = pd_DataFrame
# args[0] = args[0].values
#
# ## function invokation
# results = u.execute_fn_with_args_and_or_kwargs(fn, args, kwargs)
#
# ## cast the output back to a DataFrame.
# if postprocess_fn is not None:
# results = postprocess_fn(results)
#
# return results
. Output only the next line. | nan_xy = matrix.nan_indices(data) |
Next line prediction: <|code_start|>
SHAPE = (5, 5)
def test_complete_case_(test_data):
data = test_data(SHAPE)
<|code_end|>
. Use current file imports:
(import numpy as np
from impyute.deletion import complete_case
from impyute.ops.testing import return_na_check)
and context including class names, function names, or small code snippets from other files:
# Path: impyute/deletion/complete_case.py
# @wrapper.wrappers
# @wrapper.checks
# def complete_case(data):
# """ Return only data rows with all columns
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# numpy.ndarray
# Imputed data.
#
# """
# return data[~np.isnan(data).any(axis=1)]
#
# Path: impyute/ops/testing.py
# def return_na_check(data):
# """Helper function for tests to check if the data returned is a
# numpy array and that the imputed data has no NaN's.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# None
#
# """
# assert isinstance(data, np.ndarray)
# assert not np.isnan(data).any()
. Output only the next line. | imputed = complete_case(data) |
Predict the next line for this snippet: <|code_start|>
SHAPE = (5, 5)
def test_complete_case_(test_data):
data = test_data(SHAPE)
imputed = complete_case(data)
<|code_end|>
with the help of current file imports:
import numpy as np
from impyute.deletion import complete_case
from impyute.ops.testing import return_na_check
and context from other files:
# Path: impyute/deletion/complete_case.py
# @wrapper.wrappers
# @wrapper.checks
# def complete_case(data):
# """ Return only data rows with all columns
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# numpy.ndarray
# Imputed data.
#
# """
# return data[~np.isnan(data).any(axis=1)]
#
# Path: impyute/ops/testing.py
# def return_na_check(data):
# """Helper function for tests to check if the data returned is a
# numpy array and that the imputed data has no NaN's.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# None
#
# """
# assert isinstance(data, np.ndarray)
# assert not np.isnan(data).any()
, which may contain function names, class names, or code. Output only the next line. | return_na_check(imputed) |
Using the snippet: <|code_start|>"""test_random_imputation.py"""
SHAPE = (3, 3)
def test_random_(test_data):
data = test_data(SHAPE)
imputed = impy.random(data)
<|code_end|>
, determine the next line of code. You have imports:
import impyute as impy
from impyute.ops.testing import return_na_check
and context (class names, function names, or code) available:
# Path: impyute/ops/testing.py
# def return_na_check(data):
# """Helper function for tests to check if the data returned is a
# numpy array and that the imputed data has no NaN's.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# None
#
# """
# assert isinstance(data, np.ndarray)
# assert not np.isnan(data).any()
. Output only the next line. | return_na_check(imputed) |
Continue the code snippet: <|code_start|> Whether to return a copy or run on the passed-in array
Returns
-------
numpy.ndarray
Imputed data.
"""
if errors == "ignore":
raise Exception("`errors` value `ignore` not implemented yet. Sorry!")
if not inplace:
data = data.copy()
if nindex is None: # If using equal window side lengths
assert wsize % 2 == 1, "The parameter `wsize` should not be even "\
"if the value `nindex` is not set since it defaults to the midpoint "\
"and an even `wsize` makes the midpoint ambiguous"
wside_left = wsize // 2
wside_right = wsize // 2
else: # If using custom window side lengths
assert nindex < wsize, "The null index must be smaller than the window size"
if nindex == -1:
wside_left = wsize - 1
wside_right = 0
else:
wside_left = nindex
wside_right = wsize - nindex - 1
while True:
<|code_end|>
. Use current file imports:
import numpy as np
from impyute.ops import matrix
from impyute.ops import wrapper
and context (classes, functions, or code) from other files:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
#
# Path: impyute/ops/wrapper.py
# @wraps(fn)
# def wrapper(*args, **kwargs):
# postprocess_fn = None
# ## convert tuple to list so args can be modified
# args = list(args)
# ## Either make a copy or use a pointer to the original
# if kwargs.get('inplace'):
# args[0] = args[0]
# else:
# args[0] = args[0].copy()
#
# ## If input data is a dataframe then cast the input to an np.array
# ## and set an indicator flag before continuing
# pd_DataFrame = get_pandas_df()
# if pd_DataFrame and isinstance(args[0], pd_DataFrame):
# postprocess_fn = pd_DataFrame
# args[0] = args[0].values
#
# ## function invokation
# results = u.execute_fn_with_args_and_or_kwargs(fn, args, kwargs)
#
# ## cast the output back to a DataFrame.
# if postprocess_fn is not None:
# results = postprocess_fn(results)
#
# return results
. Output only the next line. | nan_xy = matrix.nan_indices(data) |
Predict the next line for this snippet: <|code_start|>""" Shared functions to load/generate data """
def randu(bound=(0, 10), shape=(5, 5), missingness="mcar", thr=0.2, dtype="int"):
""" Return randomly generated dataset of numbers with uniformly
distributed values between bound[0] and bound[1]
Parameters
----------
bound:tuple (start,stop)
Determines the range of values in the matrix. Index 0 for start
value and index 1 for stop value. Start is inclusive, stop is
exclusive.
shape:tuple(optional)
Size of the randomly generated data
missingness: ('mcar', 'mar', 'mnar')
Type of missingness you want in your dataset
thr: float between [0,1]
Percentage of missing data in generated data
dtype: ('int','float')
Type of data
Returns
-------
numpy.ndarray
"""
if dtype == "int":
data = np.random.randint(bound[0], bound[1], size=shape).astype(float)
elif dtype == "float":
data = np.random.uniform(bound[0], bound[1], size=shape)
<|code_end|>
with the help of current file imports:
import itertools
import math
import random
import string
import numpy as np
from impyute.dataset.corrupt import Corruptor
from impyute.ops import error
from sklearn.datasets import fetch_mldata
and context from other files:
# Path: impyute/dataset/corrupt.py
# class Corruptor:
# """ Adds missing values to a complete dataset.
#
# Attributes
# ----------
# data: np.ndarray
# Matrix of values with no NaN's that you want to add NaN's to.
# thr: float (optional)
# The percentage of null values you want in your dataset, a number
# between 0 and 1.
#
# Methods
# -------
# mcar()
# Overwrite values with MCAR placed NaN's.
# mar()
# Overwrite values with MAR placed NaN's.
# mnar()
# Overwrite values with MNAR placed NaN's.
#
# """
# def __init__(self, data, thr=0.2, dtype=np.float):
# self.dtype = data.dtype
# self.shape = np.shape(data)
# self.data = data.astype(dtype)
# self.thr = thr
#
# def mcar(self):
# """ Overwrites values with MCAR placed NaN's """
# data_1d = self.data.flatten()
# n_total = len(data_1d)
# nan_x = np.random.choice(range(n_total),
# size=int(self.thr*n_total),
# replace=False)
# for x_i in nan_x:
# data_1d[x_i] = np.nan
# output = data_1d.reshape(self.shape)
# return output
#
# def mar(self):
# """ Overwrites values with MAR placed NaN's """
# pass
#
# def mnar(self):
# """ Overwrites values with MNAR placed NaN's """
# pass
#
# def complete(self):
# """ Do nothing to the data """
# output = self.data
# return output
#
# Path: impyute/ops/error.py
# class BadInputError(Exception):
# class BadOutputError(Exception):
, which may contain function names, class names, or code. Output only the next line. | corruptor = Corruptor(data, thr=thr) |
Predict the next line after this snippet: <|code_start|> """
mean, sigma = theta
data = np.random.normal(mean, sigma, size=shape)
if dtype == "int":
data = np.round(data)
elif dtype == "float":
pass
corruptor = Corruptor(data, thr=thr)
raw_data = getattr(corruptor, missingness)()
return raw_data
def randc(nlevels=5, shape=(5, 5), missingness="mcar", thr=0.2):
""" Return randomly generated dataset with uniformly distributed categorical data (alphabetic character)
Parameters
----------
nlevels: int
Specify the number of different categories in the dataset
shape: tuple(optional)
Size of the randomly generated data
missingness: string in ('mcar', 'mar', 'mnar')
Type of missingness you want in your dataset
thr: float between [0,1]
Percentage of missing data in generated data
Returns
-------
numpy.ndarray
"""
if shape[0]*shape[1] < nlevels:
<|code_end|>
using the current file's imports:
import itertools
import math
import random
import string
import numpy as np
from impyute.dataset.corrupt import Corruptor
from impyute.ops import error
from sklearn.datasets import fetch_mldata
and any relevant context from other files:
# Path: impyute/dataset/corrupt.py
# class Corruptor:
# """ Adds missing values to a complete dataset.
#
# Attributes
# ----------
# data: np.ndarray
# Matrix of values with no NaN's that you want to add NaN's to.
# thr: float (optional)
# The percentage of null values you want in your dataset, a number
# between 0 and 1.
#
# Methods
# -------
# mcar()
# Overwrite values with MCAR placed NaN's.
# mar()
# Overwrite values with MAR placed NaN's.
# mnar()
# Overwrite values with MNAR placed NaN's.
#
# """
# def __init__(self, data, thr=0.2, dtype=np.float):
# self.dtype = data.dtype
# self.shape = np.shape(data)
# self.data = data.astype(dtype)
# self.thr = thr
#
# def mcar(self):
# """ Overwrites values with MCAR placed NaN's """
# data_1d = self.data.flatten()
# n_total = len(data_1d)
# nan_x = np.random.choice(range(n_total),
# size=int(self.thr*n_total),
# replace=False)
# for x_i in nan_x:
# data_1d[x_i] = np.nan
# output = data_1d.reshape(self.shape)
# return output
#
# def mar(self):
# """ Overwrites values with MAR placed NaN's """
# pass
#
# def mnar(self):
# """ Overwrites values with MNAR placed NaN's """
# pass
#
# def complete(self):
# """ Do nothing to the data """
# output = self.data
# return output
#
# Path: impyute/ops/error.py
# class BadInputError(Exception):
# class BadOutputError(Exception):
. Output only the next line. | raise error.BadInputError("nlevel exceeds the size of desired dataset. Please decrease the nlevel or increase the shape") |
Next line prediction: <|code_start|> The data you want to get a description from
verbose: boolean(optional)
Decides whether the description is short or long form
Returns
-------
dict
missingness: list
Confidence interval of data being MCAR, MAR or MNAR - in that order
nan_xy: list of tuples
Indices of all null points
nan_n: list
Total number of null values for each column
pmissing_n: float
Percentage of missing values in dataset
nan_rows: list
Indices of all rows that are completely null
nan_cols: list
Indices of all columns that are completely null
mean_rows: list
Mean value of each row
mean_cols: list
Mean value of each column
std_dev: list
std dev for each row/column
min_max: list
Finds the minimum and maximum for each row
"""
# missingness = [0.33, 0.33, 0.33] # find_missingness(data)
<|code_end|>
. Use current file imports:
(from impyute.ops import matrix)
and context including class names, function names, or small code snippets from other files:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
. Output only the next line. | nan_xy = matrix.nan_indices(data) |
Continue the code snippet: <|code_start|>""" impyute.contrib.count_missing.py """
def count_missing(data):
""" Calculate the total percentage of missing values and also the
percentage in each column.
Parameters
----------
data: np.array
Data to impute.
Returns
-------
dict
Percentage of missing values in total and in each column.
"""
size = len(data.flatten())
<|code_end|>
. Use current file imports:
import numpy as np
from impyute.ops import matrix
and context (classes, functions, or code) from other files:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
. Output only the next line. | nan_xy = matrix.nan_indices(data) |
Using the snippet: <|code_start|>
@wrapper.wrappers
@wrapper.checks
def random(data):
""" Fill missing values in with a randomly selected value from the same
column.
Parameters
----------
data: numpy.ndarray
Data to impute.
Returns
-------
numpy.ndarray
Imputed data.
"""
<|code_end|>
, determine the next line of code. You have imports:
import numpy as np
from impyute.ops import matrix
from impyute.ops import wrapper
and context (class names, function names, or code) available:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
#
# Path: impyute/ops/wrapper.py
# @wraps(fn)
# def wrapper(*args, **kwargs):
# postprocess_fn = None
# ## convert tuple to list so args can be modified
# args = list(args)
# ## Either make a copy or use a pointer to the original
# if kwargs.get('inplace'):
# args[0] = args[0]
# else:
# args[0] = args[0].copy()
#
# ## If input data is a dataframe then cast the input to an np.array
# ## and set an indicator flag before continuing
# pd_DataFrame = get_pandas_df()
# if pd_DataFrame and isinstance(args[0], pd_DataFrame):
# postprocess_fn = pd_DataFrame
# args[0] = args[0].values
#
# ## function invokation
# results = u.execute_fn_with_args_and_or_kwargs(fn, args, kwargs)
#
# ## cast the output back to a DataFrame.
# if postprocess_fn is not None:
# results = postprocess_fn(results)
#
# return results
. Output only the next line. | nan_xy = matrix.nan_indices(data) |
Given the following code snippet before the placeholder: <|code_start|>
def _add_one(x):
""" """
return x + 1
def _square(x):
return x * x
def test_thread():
assert 10 == util.thread(3, _square, _add_one)
assert 100 == util.thread(3, _square, _add_one, _square) #4
assert 82 == util.thread(3, _square, _square, _add_one) #4
assert 10 == util.thread(3, lambda x: x*x, lambda x: x+1)
assert 100 == util.thread(3, lambda x: x*x, lambda x: x+1, lambda x: x*x)
assert 82 == util.thread(3, lambda x: x*x, lambda x: x*x, lambda x: x+1)
def test_identity():
arr = np.array([[1., 2., 3.]])
actual = arr
expected = util.identity(arr)
<|code_end|>
, predict the next line using imports from the current file:
import numpy as np
from impyute.ops import matrix
from impyute.ops import util
and context including class names, function names, and sometimes code from other files:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
#
# Path: impyute/ops/util.py
# def thread(arg, *fns):
# def identity(x):
# def constantly(x):
# def func(*args, **kwargs):
# def complement(fn):
# def wrapper(*args, **kwargs):
# def execute_fn_with_args_and_or_kwargs(fn, args, kwargs):
. Output only the next line. | assert matrix.every_nd(bool, expected == actual) |
Based on the snippet: <|code_start|>
def _add_one(x):
""" """
return x + 1
def _square(x):
return x * x
def test_thread():
<|code_end|>
, predict the immediate next line with the help of imports:
import numpy as np
from impyute.ops import matrix
from impyute.ops import util
and context (classes, functions, sometimes code) from other files:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
#
# Path: impyute/ops/util.py
# def thread(arg, *fns):
# def identity(x):
# def constantly(x):
# def func(*args, **kwargs):
# def complement(fn):
# def wrapper(*args, **kwargs):
# def execute_fn_with_args_and_or_kwargs(fn, args, kwargs):
. Output only the next line. | assert 10 == util.thread(3, _square, _add_one) |
Continue the code snippet: <|code_start|>
@wrapper.wrappers
def wrappers_mul(arr):
"""Some function that performs an inplace operation on the input. Accepts kwargs"""
arr *= 25
return arr
def test_wrappers_inplace_false():
"""Input should be unchanged if inplace set to false"""
A = np.ones((5, 5))
A_copy = A.copy()
wrappers_mul(A, inplace=False)
assert A[0, 0] == A_copy[0, 0]
def test_wrappers_inplace_true():
"""Input may be changed if inplace set to true and operation is inplace"""
A = np.ones((5, 5))
A_copy = A.copy()
wrappers_mul(A, inplace=True)
assert A[0, 0] != A_copy[0, 0]
def test_wrappers_pandas_input():
""" Input: DataFrame, Output: DataFrame """
# Skip this test if you don't have pandas
pytest.importorskip('pandas')
# Create a DataFrame with a NaN
A = np.arange(25).reshape((5, 5)).astype(np.float)
A[0, 0] = np.nan
A = pd.DataFrame(A)
# Assert that the output is a DataFrame
<|code_end|>
. Use current file imports:
import pytest
import numpy as np
import pandas as pd
from impyute.imputation.cs import mean
from impyute.ops import error
from impyute.ops import wrapper
and context (classes, functions, or code) from other files:
# Path: impyute/imputation/cs/central_tendency.py
# @wrapper.wrappers
# @wrapper.checks
# def mean(data):
# """ Substitute missing values with the mean of that column.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# numpy.ndarray
# Imputed data.
#
# """
# nan_xy = matrix.nan_indices(data)
# for x_i, y_i in nan_xy:
# row_wo_nan = data[:, [y_i]][~np.isnan(data[:, [y_i]])]
# new_value = np.mean(row_wo_nan)
# data[x_i][y_i] = new_value
# return data
#
# Path: impyute/ops/error.py
# class BadInputError(Exception):
# class BadOutputError(Exception):
#
# Path: impyute/ops/wrapper.py
# @wraps(fn)
# def wrapper(*args, **kwargs):
# postprocess_fn = None
# ## convert tuple to list so args can be modified
# args = list(args)
# ## Either make a copy or use a pointer to the original
# if kwargs.get('inplace'):
# args[0] = args[0]
# else:
# args[0] = args[0].copy()
#
# ## If input data is a dataframe then cast the input to an np.array
# ## and set an indicator flag before continuing
# pd_DataFrame = get_pandas_df()
# if pd_DataFrame and isinstance(args[0], pd_DataFrame):
# postprocess_fn = pd_DataFrame
# args[0] = args[0].values
#
# ## function invokation
# results = u.execute_fn_with_args_and_or_kwargs(fn, args, kwargs)
#
# ## cast the output back to a DataFrame.
# if postprocess_fn is not None:
# results = postprocess_fn(results)
#
# return results
. Output only the next line. | assert isinstance(mean(A), pd.DataFrame) |
Predict the next line after this snippet: <|code_start|> """Input may be changed if inplace set to true and operation is inplace"""
A = np.ones((5, 5))
A_copy = A.copy()
wrappers_mul(A, inplace=True)
assert A[0, 0] != A_copy[0, 0]
def test_wrappers_pandas_input():
""" Input: DataFrame, Output: DataFrame """
# Skip this test if you don't have pandas
pytest.importorskip('pandas')
# Create a DataFrame with a NaN
A = np.arange(25).reshape((5, 5)).astype(np.float)
A[0, 0] = np.nan
A = pd.DataFrame(A)
# Assert that the output is a DataFrame
assert isinstance(mean(A), pd.DataFrame)
@wrapper.checks
def some_fn(data):
"""Dummy fn that has form of np.array -> np.array"""
return data
def test_correct_input():
""" Test that an array that should satisfy all checks, no BadInputError should be raised"""
# Integer np.ndarray (check: `_is_ndarray`, `_shape_2d`, `_nan_exists`)
arr = np.array([[np.nan, 2], [3, 4]])
# Cast integer array to float (check: `_dtype_float`)
arr.dtype = np.float
try:
some_fn(arr)
<|code_end|>
using the current file's imports:
import pytest
import numpy as np
import pandas as pd
from impyute.imputation.cs import mean
from impyute.ops import error
from impyute.ops import wrapper
and any relevant context from other files:
# Path: impyute/imputation/cs/central_tendency.py
# @wrapper.wrappers
# @wrapper.checks
# def mean(data):
# """ Substitute missing values with the mean of that column.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# numpy.ndarray
# Imputed data.
#
# """
# nan_xy = matrix.nan_indices(data)
# for x_i, y_i in nan_xy:
# row_wo_nan = data[:, [y_i]][~np.isnan(data[:, [y_i]])]
# new_value = np.mean(row_wo_nan)
# data[x_i][y_i] = new_value
# return data
#
# Path: impyute/ops/error.py
# class BadInputError(Exception):
# class BadOutputError(Exception):
#
# Path: impyute/ops/wrapper.py
# @wraps(fn)
# def wrapper(*args, **kwargs):
# postprocess_fn = None
# ## convert tuple to list so args can be modified
# args = list(args)
# ## Either make a copy or use a pointer to the original
# if kwargs.get('inplace'):
# args[0] = args[0]
# else:
# args[0] = args[0].copy()
#
# ## If input data is a dataframe then cast the input to an np.array
# ## and set an indicator flag before continuing
# pd_DataFrame = get_pandas_df()
# if pd_DataFrame and isinstance(args[0], pd_DataFrame):
# postprocess_fn = pd_DataFrame
# args[0] = args[0].values
#
# ## function invokation
# results = u.execute_fn_with_args_and_or_kwargs(fn, args, kwargs)
#
# ## cast the output back to a DataFrame.
# if postprocess_fn is not None:
# results = postprocess_fn(results)
#
# return results
. Output only the next line. | except error.BadInputError: |
Predict the next line for this snippet: <|code_start|>
# pylint:disable=redefined-builtin
try:
raise ModuleNotFoundError
except NameError:
class ModuleNotFoundError(Exception):
"placeholder required for python2.7"
pass
except ModuleNotFoundError:
pass
<|code_end|>
with the help of current file imports:
import pytest
import numpy as np
import pandas as pd
from impyute.imputation.cs import mean
from impyute.ops import error
from impyute.ops import wrapper
and context from other files:
# Path: impyute/imputation/cs/central_tendency.py
# @wrapper.wrappers
# @wrapper.checks
# def mean(data):
# """ Substitute missing values with the mean of that column.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# numpy.ndarray
# Imputed data.
#
# """
# nan_xy = matrix.nan_indices(data)
# for x_i, y_i in nan_xy:
# row_wo_nan = data[:, [y_i]][~np.isnan(data[:, [y_i]])]
# new_value = np.mean(row_wo_nan)
# data[x_i][y_i] = new_value
# return data
#
# Path: impyute/ops/error.py
# class BadInputError(Exception):
# class BadOutputError(Exception):
#
# Path: impyute/ops/wrapper.py
# @wraps(fn)
# def wrapper(*args, **kwargs):
# postprocess_fn = None
# ## convert tuple to list so args can be modified
# args = list(args)
# ## Either make a copy or use a pointer to the original
# if kwargs.get('inplace'):
# args[0] = args[0]
# else:
# args[0] = args[0].copy()
#
# ## If input data is a dataframe then cast the input to an np.array
# ## and set an indicator flag before continuing
# pd_DataFrame = get_pandas_df()
# if pd_DataFrame and isinstance(args[0], pd_DataFrame):
# postprocess_fn = pd_DataFrame
# args[0] = args[0].values
#
# ## function invokation
# results = u.execute_fn_with_args_and_or_kwargs(fn, args, kwargs)
#
# ## cast the output back to a DataFrame.
# if postprocess_fn is not None:
# results = postprocess_fn(results)
#
# return results
, which may contain function names, class names, or code. Output only the next line. | @wrapper.wrappers |
Predict the next line for this snippet: <|code_start|> >>> data[0][2] = np.nan
>>> data
array([[ 0., 1., nan, 3., 4.],
[ 5., 6., 7., 8., 9.],
[10., 11., 12., 13., 14.],
[15., 16., 17., 18., 19.],
[20., 21., 22., 23., 24.]])
>> fast_knn(data, k=1) # Weighted average (by distance) of nearest 1 neighbour
array([[ 0., 1., 7., 3., 4.],
[ 5., 6., 7., 8., 9.],
[10., 11., 12., 13., 14.],
[15., 16., 17., 18., 19.],
[20., 21., 22., 23., 24.]])
>> fast_knn(data, k=2) # Weighted average of nearest 2 neighbours
array([[ 0. , 1. , 10.08608891, 3. , 4. ],
[ 5. , 6. , 7. , 8. , 9. ],
[10. , 11. , 12. , 13. , 14. ],
[15. , 16. , 17. , 18. , 19. ],
[20. , 21. , 22. , 23. , 24. ]])
>> fast_knn(data, k=3)
array([[ 0. , 1. , 13.40249283, 3. , 4. ],
[ 5. , 6. , 7. , 8. , 9. ],
[10. , 11. , 12. , 13. , 14. ],
[15. , 16. , 17. , 18. , 19. ],
[20. , 21. , 22. , 23. , 24. ]])
>> fast_knn(data, k=5) # There are at most only 4 neighbours. Raises error
...
IndexError: index 5 is out of bounds for axis 0 with size 5
"""
<|code_end|>
with the help of current file imports:
import numpy as np
from scipy.spatial import KDTree
from impyute.ops import matrix
from impyute.ops import wrapper
from impyute.ops import inverse_distance_weighting as idw
from . import mean
and context from other files:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
#
# Path: impyute/ops/wrapper.py
# @wraps(fn)
# def wrapper(*args, **kwargs):
# postprocess_fn = None
# ## convert tuple to list so args can be modified
# args = list(args)
# ## Either make a copy or use a pointer to the original
# if kwargs.get('inplace'):
# args[0] = args[0]
# else:
# args[0] = args[0].copy()
#
# ## If input data is a dataframe then cast the input to an np.array
# ## and set an indicator flag before continuing
# pd_DataFrame = get_pandas_df()
# if pd_DataFrame and isinstance(args[0], pd_DataFrame):
# postprocess_fn = pd_DataFrame
# args[0] = args[0].values
#
# ## function invokation
# results = u.execute_fn_with_args_and_or_kwargs(fn, args, kwargs)
#
# ## cast the output back to a DataFrame.
# if postprocess_fn is not None:
# results = postprocess_fn(results)
#
# return results
#
# Path: impyute/ops/inverse_distance_weighting.py
# def shepards(distances, power=2):
# def to_percentage(vec):
#
# Path: impyute/imputation/cs/central_tendency.py
# @wrapper.wrappers
# @wrapper.checks
# def mean(data):
# """ Substitute missing values with the mean of that column.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# numpy.ndarray
# Imputed data.
#
# """
# nan_xy = matrix.nan_indices(data)
# for x_i, y_i in nan_xy:
# row_wo_nan = data[:, [y_i]][~np.isnan(data[:, [y_i]])]
# new_value = np.mean(row_wo_nan)
# data[x_i][y_i] = new_value
# return data
, which may contain function names, class names, or code. Output only the next line. | nan_xy = matrix.nan_indices(data) |
Given snippet: <|code_start|>
# pylint: disable=too-many-arguments
@wrapper.wrappers
@wrapper.checks
def fast_knn(data, k=3, eps=0, p=2, distance_upper_bound=np.inf, leafsize=10,
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import numpy as np
from scipy.spatial import KDTree
from impyute.ops import matrix
from impyute.ops import wrapper
from impyute.ops import inverse_distance_weighting as idw
from . import mean
and context:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
#
# Path: impyute/ops/wrapper.py
# @wraps(fn)
# def wrapper(*args, **kwargs):
# postprocess_fn = None
# ## convert tuple to list so args can be modified
# args = list(args)
# ## Either make a copy or use a pointer to the original
# if kwargs.get('inplace'):
# args[0] = args[0]
# else:
# args[0] = args[0].copy()
#
# ## If input data is a dataframe then cast the input to an np.array
# ## and set an indicator flag before continuing
# pd_DataFrame = get_pandas_df()
# if pd_DataFrame and isinstance(args[0], pd_DataFrame):
# postprocess_fn = pd_DataFrame
# args[0] = args[0].values
#
# ## function invokation
# results = u.execute_fn_with_args_and_or_kwargs(fn, args, kwargs)
#
# ## cast the output back to a DataFrame.
# if postprocess_fn is not None:
# results = postprocess_fn(results)
#
# return results
#
# Path: impyute/ops/inverse_distance_weighting.py
# def shepards(distances, power=2):
# def to_percentage(vec):
#
# Path: impyute/imputation/cs/central_tendency.py
# @wrapper.wrappers
# @wrapper.checks
# def mean(data):
# """ Substitute missing values with the mean of that column.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# numpy.ndarray
# Imputed data.
#
# """
# nan_xy = matrix.nan_indices(data)
# for x_i, y_i in nan_xy:
# row_wo_nan = data[:, [y_i]][~np.isnan(data[:, [y_i]])]
# new_value = np.mean(row_wo_nan)
# data[x_i][y_i] = new_value
# return data
which might include code, classes, or functions. Output only the next line. | idw_fn=idw.shepards, init_impute_fn=mean): |
Predict the next line for this snippet: <|code_start|>
# pylint: disable=too-many-arguments
@wrapper.wrappers
@wrapper.checks
def fast_knn(data, k=3, eps=0, p=2, distance_upper_bound=np.inf, leafsize=10,
<|code_end|>
with the help of current file imports:
import numpy as np
from scipy.spatial import KDTree
from impyute.ops import matrix
from impyute.ops import wrapper
from impyute.ops import inverse_distance_weighting as idw
from . import mean
and context from other files:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
#
# Path: impyute/ops/wrapper.py
# @wraps(fn)
# def wrapper(*args, **kwargs):
# postprocess_fn = None
# ## convert tuple to list so args can be modified
# args = list(args)
# ## Either make a copy or use a pointer to the original
# if kwargs.get('inplace'):
# args[0] = args[0]
# else:
# args[0] = args[0].copy()
#
# ## If input data is a dataframe then cast the input to an np.array
# ## and set an indicator flag before continuing
# pd_DataFrame = get_pandas_df()
# if pd_DataFrame and isinstance(args[0], pd_DataFrame):
# postprocess_fn = pd_DataFrame
# args[0] = args[0].values
#
# ## function invokation
# results = u.execute_fn_with_args_and_or_kwargs(fn, args, kwargs)
#
# ## cast the output back to a DataFrame.
# if postprocess_fn is not None:
# results = postprocess_fn(results)
#
# return results
#
# Path: impyute/ops/inverse_distance_weighting.py
# def shepards(distances, power=2):
# def to_percentage(vec):
#
# Path: impyute/imputation/cs/central_tendency.py
# @wrapper.wrappers
# @wrapper.checks
# def mean(data):
# """ Substitute missing values with the mean of that column.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# numpy.ndarray
# Imputed data.
#
# """
# nan_xy = matrix.nan_indices(data)
# for x_i, y_i in nan_xy:
# row_wo_nan = data[:, [y_i]][~np.isnan(data[:, [y_i]])]
# new_value = np.mean(row_wo_nan)
# data[x_i][y_i] = new_value
# return data
, which may contain function names, class names, or code. Output only the next line. | idw_fn=idw.shepards, init_impute_fn=mean): |
Given snippet: <|code_start|>
pytest.skip("takes ~30 sec each test", allow_module_level=True)
data = mnist()["X"]
def test_return_type():
""" Check return type, should return an np.ndarray"""
assert isinstance(data, np.ndarray)
def test_missing_values_present():
""" Check that the dataset is corrupted (missing values present)"""
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import numpy as np
import pytest
from impyute.dataset import mnist
from impyute.ops import matrix
and context:
# Path: impyute/dataset/base.py
# def mnist(missingness="mcar", thr=0.2):
# """ Loads corrupted MNIST
#
# Parameters
# ----------
# missingness: ('mcar', 'mar', 'mnar')
# Type of missigness you want in your dataset
# th: float between [0,1]
# Percentage of missing data in generated data
#
# Returns
# -------
# numpy.ndarray
# """
# from sklearn.datasets import fetch_mldata
# dataset = fetch_mldata('MNIST original')
# corruptor = Corruptor(dataset.data, thr=thr)
# data = getattr(corruptor, missingness)()
# return {"X": data, "Y": dataset.target}
#
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
which might include code, classes, or functions. Output only the next line. | assert matrix.nan_indices(data).size != 0 |
Continue the code snippet: <|code_start|>"""test_fast_knn.py"""
# pylint:disable=invalid-name
SHAPE = (5, 5)
def test_return_type(knn_test_data):
imputed = impy.fast_knn(knn_test_data)
<|code_end|>
. Use current file imports:
import functools
import numpy as np
import impyute as impy
from impyute.ops.testing import return_na_check
and context (classes, functions, or code) from other files:
# Path: impyute/ops/testing.py
# def return_na_check(data):
# """Helper function for tests to check if the data returned is a
# numpy array and that the imputed data has no NaN's.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# None
#
# """
# assert isinstance(data, np.ndarray)
# assert not np.isnan(data).any()
. Output only the next line. | return_na_check(imputed) |
Next line prediction: <|code_start|>def locf(data, axis=0):
""" Last Observation Carried Forward
For each set of missing indices, use the value of one row before(same
column). In the case that the missing value is the first row, look one
row ahead instead. If this next row is also NaN, look to the next row.
Repeat until you find a row in this column that's not NaN. All the rows
before will be filled with this value.
Parameters
----------
data: numpy.ndarray
Data to impute.
axis: boolean (optional)
0 if time series is in row format (Ex. data[0][:] is 1st data point).
1 if time series is in col format (Ex. data[:][0] is 1st data point).
Returns
-------
numpy.ndarray
Imputed data.
"""
if axis == 0:
data = np.transpose(data)
elif axis == 1:
pass
else:
raise error.BadInputError("Error: Axis value is invalid, please use either 0 (row format) or 1 (column format)")
<|code_end|>
. Use current file imports:
(import numpy as np
from impyute.ops import matrix
from impyute.ops import wrapper
from impyute.ops import error)
and context including class names, function names, or small code snippets from other files:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
#
# Path: impyute/ops/wrapper.py
# @wraps(fn)
# def wrapper(*args, **kwargs):
# postprocess_fn = None
# ## convert tuple to list so args can be modified
# args = list(args)
# ## Either make a copy or use a pointer to the original
# if kwargs.get('inplace'):
# args[0] = args[0]
# else:
# args[0] = args[0].copy()
#
# ## If input data is a dataframe then cast the input to an np.array
# ## and set an indicator flag before continuing
# pd_DataFrame = get_pandas_df()
# if pd_DataFrame and isinstance(args[0], pd_DataFrame):
# postprocess_fn = pd_DataFrame
# args[0] = args[0].values
#
# ## function invokation
# results = u.execute_fn_with_args_and_or_kwargs(fn, args, kwargs)
#
# ## cast the output back to a DataFrame.
# if postprocess_fn is not None:
# results = postprocess_fn(results)
#
# return results
#
# Path: impyute/ops/error.py
# class BadInputError(Exception):
# class BadOutputError(Exception):
. Output only the next line. | nan_xy = matrix.nan_indices(data) |
Given the code snippet: <|code_start|>@wrapper.wrappers
@wrapper.checks
def locf(data, axis=0):
""" Last Observation Carried Forward
For each set of missing indices, use the value of one row before(same
column). In the case that the missing value is the first row, look one
row ahead instead. If this next row is also NaN, look to the next row.
Repeat until you find a row in this column that's not NaN. All the rows
before will be filled with this value.
Parameters
----------
data: numpy.ndarray
Data to impute.
axis: boolean (optional)
0 if time series is in row format (Ex. data[0][:] is 1st data point).
1 if time series is in col format (Ex. data[:][0] is 1st data point).
Returns
-------
numpy.ndarray
Imputed data.
"""
if axis == 0:
data = np.transpose(data)
elif axis == 1:
pass
else:
<|code_end|>
, generate the next line using the imports in this file:
import numpy as np
from impyute.ops import matrix
from impyute.ops import wrapper
from impyute.ops import error
and context (functions, classes, or occasionally code) from other files:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
#
# Path: impyute/ops/wrapper.py
# @wraps(fn)
# def wrapper(*args, **kwargs):
# postprocess_fn = None
# ## convert tuple to list so args can be modified
# args = list(args)
# ## Either make a copy or use a pointer to the original
# if kwargs.get('inplace'):
# args[0] = args[0]
# else:
# args[0] = args[0].copy()
#
# ## If input data is a dataframe then cast the input to an np.array
# ## and set an indicator flag before continuing
# pd_DataFrame = get_pandas_df()
# if pd_DataFrame and isinstance(args[0], pd_DataFrame):
# postprocess_fn = pd_DataFrame
# args[0] = args[0].values
#
# ## function invokation
# results = u.execute_fn_with_args_and_or_kwargs(fn, args, kwargs)
#
# ## cast the output back to a DataFrame.
# if postprocess_fn is not None:
# results = postprocess_fn(results)
#
# return results
#
# Path: impyute/ops/error.py
# class BadInputError(Exception):
# class BadOutputError(Exception):
. Output only the next line. | raise error.BadInputError("Error: Axis value is invalid, please use either 0 (row format) or 1 (column format)") |
Using the snippet: <|code_start|>"""test_locf.py"""
SHAPE = (5, 5)
def test_locf_(test_data):
data = test_data(SHAPE)
imputed = impy.locf(data)
<|code_end|>
, determine the next line of code. You have imports:
import numpy as np
import impyute as impy
from impyute.ops.testing import return_na_check
from impyute.ops import error
and context (class names, function names, or code) available:
# Path: impyute/ops/testing.py
# def return_na_check(data):
# """Helper function for tests to check if the data returned is a
# numpy array and that the imputed data has no NaN's.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# None
#
# """
# assert isinstance(data, np.ndarray)
# assert not np.isnan(data).any()
#
# Path: impyute/ops/error.py
# class BadInputError(Exception):
# class BadOutputError(Exception):
. Output only the next line. | return_na_check(imputed) |
Given the code snippet: <|code_start|> imputed = impy.locf(data)
return_na_check(imputed)
def test_na_at_i_start(test_data):
data = test_data(SHAPE)
actual = impy.locf(data, axis=1)
data[0, 0] = data[1, 0]
assert np.array_equal(actual, data)
def test_na_at_i(test_data):
data = test_data(SHAPE, 3, 3)
actual = impy.locf(data, axis=1)
data[3, 3] = data[2, 3]
assert np.array_equal(actual, data)
def test_na_at_i_end(test_data):
data = test_data(SHAPE)
last_i = np.shape(data)[0] - 1
data = test_data(SHAPE, last_i, 3)
actual = impy.locf(data, axis=1)
data[last_i, 3] = data[last_i - 1, 3]
assert np.array_equal(actual, data)
def test_out_of_bounds(test_data):
"""Check out of bounds error, should throw BadInputError for any axis outside [0,1]"""
data = test_data(SHAPE)
<|code_end|>
, generate the next line using the imports in this file:
import numpy as np
import impyute as impy
from impyute.ops.testing import return_na_check
from impyute.ops import error
and context (functions, classes, or occasionally code) from other files:
# Path: impyute/ops/testing.py
# def return_na_check(data):
# """Helper function for tests to check if the data returned is a
# numpy array and that the imputed data has no NaN's.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# None
#
# """
# assert isinstance(data, np.ndarray)
# assert not np.isnan(data).any()
#
# Path: impyute/ops/error.py
# class BadInputError(Exception):
# class BadOutputError(Exception):
. Output only the next line. | with np.testing.assert_raises(error.BadInputError): |
Continue the code snippet: <|code_start|>"""test_em.py"""
SHAPE = (5, 5)
def test_em_(test_data):
data = test_data(SHAPE)
imputed = impy.em(data)
<|code_end|>
. Use current file imports:
import impyute as impy
from impyute.ops.testing import return_na_check
and context (classes, functions, or code) from other files:
# Path: impyute/ops/testing.py
# def return_na_check(data):
# """Helper function for tests to check if the data returned is a
# numpy array and that the imputed data has no NaN's.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# None
#
# """
# assert isinstance(data, np.ndarray)
# assert not np.isnan(data).any()
. Output only the next line. | return_na_check(imputed) |
Using the snippet: <|code_start|>
@wrapper.wrappers
@wrapper.checks
def mean(data):
""" Substitute missing values with the mean of that column.
Parameters
----------
data: numpy.ndarray
Data to impute.
Returns
-------
numpy.ndarray
Imputed data.
"""
<|code_end|>
, determine the next line of code. You have imports:
import numpy as np
from impyute.ops import matrix
from impyute.ops import wrapper
and context (class names, function names, or code) available:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
#
# Path: impyute/ops/wrapper.py
# @wraps(fn)
# def wrapper(*args, **kwargs):
# postprocess_fn = None
# ## convert tuple to list so args can be modified
# args = list(args)
# ## Either make a copy or use a pointer to the original
# if kwargs.get('inplace'):
# args[0] = args[0]
# else:
# args[0] = args[0].copy()
#
# ## If input data is a dataframe then cast the input to an np.array
# ## and set an indicator flag before continuing
# pd_DataFrame = get_pandas_df()
# if pd_DataFrame and isinstance(args[0], pd_DataFrame):
# postprocess_fn = pd_DataFrame
# args[0] = args[0].values
#
# ## function invokation
# results = u.execute_fn_with_args_and_or_kwargs(fn, args, kwargs)
#
# ## cast the output back to a DataFrame.
# if postprocess_fn is not None:
# results = postprocess_fn(results)
#
# return results
. Output only the next line. | nan_xy = matrix.nan_indices(data) |
Next line prediction: <|code_start|># pylint: disable=too-many-locals
@wrapper.wrappers
@wrapper.checks
def buck_iterative(data):
""" Iterative variant of buck's method
- Variable to regress on is chosen at random.
- EM type infinite regression loop stops after change in prediction from
previous prediction < 10% for all columns with missing values
A Method of Estimation of Missing Values in Multivariate Data Suitable for
use with an Electronic Computer S. F. Buck Journal of the Royal Statistical
Society. Series B (Methodological) Vol. 22, No. 2 (1960), pp. 302-306
Parameters
----------
data: numpy.ndarray
Data to impute.
Returns
-------
numpy.ndarray
Imputed data.
"""
<|code_end|>
. Use current file imports:
(import numpy as np
from sklearn.linear_model import LinearRegression
from impyute.ops import matrix
from impyute.ops import wrapper)
and context including class names, function names, or small code snippets from other files:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
#
# Path: impyute/ops/wrapper.py
# @wraps(fn)
# def wrapper(*args, **kwargs):
# postprocess_fn = None
# ## convert tuple to list so args can be modified
# args = list(args)
# ## Either make a copy or use a pointer to the original
# if kwargs.get('inplace'):
# args[0] = args[0]
# else:
# args[0] = args[0].copy()
#
# ## If input data is a dataframe then cast the input to an np.array
# ## and set an indicator flag before continuing
# pd_DataFrame = get_pandas_df()
# if pd_DataFrame and isinstance(args[0], pd_DataFrame):
# postprocess_fn = pd_DataFrame
# args[0] = args[0].values
#
# ## function invokation
# results = u.execute_fn_with_args_and_or_kwargs(fn, args, kwargs)
#
# ## cast the output back to a DataFrame.
# if postprocess_fn is not None:
# results = postprocess_fn(results)
#
# return results
. Output only the next line. | nan_xy = matrix.nan_indices(data) |
Predict the next line for this snippet: <|code_start|>"""test_averagings.py"""
SHAPE = (5, 5)
def test_mean(test_data):
data = test_data(SHAPE)
imputed = impy.mean(data)
<|code_end|>
with the help of current file imports:
import impyute as impy
from impyute.ops.testing import return_na_check
and context from other files:
# Path: impyute/ops/testing.py
# def return_na_check(data):
# """Helper function for tests to check if the data returned is a
# numpy array and that the imputed data has no NaN's.
#
# Parameters
# ----------
# data: numpy.ndarray
# Data to impute.
#
# Returns
# -------
# None
#
# """
# assert isinstance(data, np.ndarray)
# assert not np.isnan(data).any()
, which may contain function names, class names, or code. Output only the next line. | return_na_check(imputed) |
Continue the code snippet: <|code_start|>
def _is_gt_5(x):
return x > 5
def test_map_nd_2d():
arr = np.arange(10).reshape([5, 2])
expected = np.array([
[False, False],
[False, False],
[False, False],
[True, True],
[True, True],
])
<|code_end|>
. Use current file imports:
import numpy as np
from impyute.ops import matrix
and context (classes, functions, or code) from other files:
# Path: impyute/ops/matrix.py
# def nan_indices(data):
# def map_nd(fn, arr):
# def every_nd(fn, arr):
. Output only the next line. | actual = matrix.map_nd(_is_gt_5, arr) |
Predict the next line after this snippet: <|code_start|>
def func(*args):
pass
def PublishKernels(context):
<|code_end|>
using the current file's imports:
from pyvx import vx
and any relevant context from other files:
# Path: pyvx/vx.py
# def _get_attribute(func, ref, attribute, c_type, python_type):
# def _set_attribute(func, ref, attribute, value, c_type):
# def _enum2ctype(data_type):
# def _callback(ctype, callback, parent, error):
# def ReleaseContext(context):
# def QueryContext(context, attribute, c_type, python_type=None):
# def SetContextAttribute(context, attribute, value, c_type=None):
# def ReleaseImage(image):
# def QueryImage(image, attribute, c_type, python_type=None):
# def SetImageAttribute(image, attribute, value, c_type=None):
# def CreateUniformImage(context, width, height, color, value, c_type):
# def CreateImageFromHandle(context, color, addrs, ptrs, import_type):
# def AccessImagePatch(image, rect, plane_index, addr, ptr, usage):
# def CommitImagePatch(image, rect, plane_index, addr, ptr):
# def FormatImagePatchAddress1d(ptr, index, addr):
# def FormatImagePatchAddress2d(ptr, x, y, addr):
# def GetValidRegionImage(image):
# def ReleaseKernel(kernel):
# def QueryKernel(kernel, attribute, c_type, python_type=None):
# def SetKernelAttribute(kernel, attribute, value, c_type=None):
# def AddKernel(context, name, enumeration, func_ptr, numParams, input, output, init, deinit):
# def SetMetaFormatAttribute(meta, attribute, value, c_type=None):
# def LoadKernels(context, module):
# def ReleaseGraph(graph):
# def QueryGraph(graph, attribute, c_type, python_type=None):
# def SetGraphAttribute(graph, attribute, value, c_type=None):
# def ReleaseNode(node):
# def QueryNode(node, attribute, c_type, python_type=None):
# def SetNodeAttribute(node, attribute, value, c_type=None):
# def RemoveNode(node):
# def AssignNodeCallback(node, callback):
# def ReleaseParameter(parameter):
# def QueryParameter(parameter, attribute, c_type, python_type=None):
# def CreateScalar(context, data_type, value):
# def ReleaseScalar(scalar):
# def QueryScalar(scalar, attribute, c_type, python_type=None):
# def ReadScalarValue(scalar):
# def WriteScalarValue(scalar, value):
# def reference(reference):
# def from_reference(ref):
# def QueryReference(reference, attribute, c_type, python_type=None):
# def ReleaseDelay(delay):
# def QueryDelay(delay, attribute, c_type, python_type=None):
# def RegisterLogCallback(context, callback, reentrant):
# def wrapper(context, ref, status, string):
# def ReleaseLUT(lut):
# def QueryLUT(lut, attribute, c_type, python_type=None):
# def AccessLUT(lut, ptr, usage):
# def CommitLUT(lut, ptr):
# def ReleaseDistribution(distribution):
# def QueryDistribution(distribution, attribute, c_type, python_type=None):
# def AccessDistribution(distribution, ptr, usage):
# def CommitDistribution(distribution, ptr):
# def ReleaseThreshold(threshold):
# def QueryThreshold(threshold, attribute, c_type, python_type=None):
# def SetThresholdAttribute(threshold, attribute, value, c_type=None):
# def ReleaseMatrix(matrix):
# def QueryMatrix(matrix, attribute, c_type, python_type=None):
# def ReadMatrix(mat, array):
# def WriteMatrix(mat, array):
# def ReleaseConvolution(convolution):
# def QueryConvolution(convolution, attribute, c_type, python_type=None):
# def SetConvolutionAttribute(convolution, attribute, value, c_type=None):
# def WriteConvolutionCoefficients(conv, array):
# def ReadConvolutionCoefficients(conv, array):
# def ReleasePyramid(pyramid):
# def QueryPyramid(pyramid, attribute, c_type, python_type=None):
# def ReleaseRemap(remap):
# def QueryRemap(remap, attribute, c_type, python_type=None):
# def GetRemapPoint(table, dst_x, dst_y):
# def ReleaseArray(array):
# def QueryArray(array, attribute, c_type, python_type=None):
# def FormatArrayPointer(ptr, index, stride):
# def ArrayItem(type, ptr, index, stride):
# def AddArrayItems(arr, count, ptr, stride):
# def AccessArrayRange(arr, start, end, stride, ptr, usage):
# def CommitArrayRange(arr, start, end, ptr):
. Output only the next line. | enum = vx.KERNEL_BASE(vx.ID_DEFAULT, 8) + 1 |
Given the following code snippet before the placeholder: <|code_start|>
if sys.version_info > (3,):
unicode = str
class TestVX(object):
def test_context(self):
<|code_end|>
, predict the next line using imports from the current file:
from array import array
from py.test import raises
from pyvx import vx
from pyvx import vx
from test import mock_backend2
from pyvx import vx
from pyvx import vx
import sys
import pyvx
and context including class names, function names, and sometimes code from other files:
# Path: pyvx/vx.py
# def _get_attribute(func, ref, attribute, c_type, python_type):
# def _set_attribute(func, ref, attribute, value, c_type):
# def _enum2ctype(data_type):
# def _callback(ctype, callback, parent, error):
# def ReleaseContext(context):
# def QueryContext(context, attribute, c_type, python_type=None):
# def SetContextAttribute(context, attribute, value, c_type=None):
# def ReleaseImage(image):
# def QueryImage(image, attribute, c_type, python_type=None):
# def SetImageAttribute(image, attribute, value, c_type=None):
# def CreateUniformImage(context, width, height, color, value, c_type):
# def CreateImageFromHandle(context, color, addrs, ptrs, import_type):
# def AccessImagePatch(image, rect, plane_index, addr, ptr, usage):
# def CommitImagePatch(image, rect, plane_index, addr, ptr):
# def FormatImagePatchAddress1d(ptr, index, addr):
# def FormatImagePatchAddress2d(ptr, x, y, addr):
# def GetValidRegionImage(image):
# def ReleaseKernel(kernel):
# def QueryKernel(kernel, attribute, c_type, python_type=None):
# def SetKernelAttribute(kernel, attribute, value, c_type=None):
# def AddKernel(context, name, enumeration, func_ptr, numParams, input, output, init, deinit):
# def SetMetaFormatAttribute(meta, attribute, value, c_type=None):
# def LoadKernels(context, module):
# def ReleaseGraph(graph):
# def QueryGraph(graph, attribute, c_type, python_type=None):
# def SetGraphAttribute(graph, attribute, value, c_type=None):
# def ReleaseNode(node):
# def QueryNode(node, attribute, c_type, python_type=None):
# def SetNodeAttribute(node, attribute, value, c_type=None):
# def RemoveNode(node):
# def AssignNodeCallback(node, callback):
# def ReleaseParameter(parameter):
# def QueryParameter(parameter, attribute, c_type, python_type=None):
# def CreateScalar(context, data_type, value):
# def ReleaseScalar(scalar):
# def QueryScalar(scalar, attribute, c_type, python_type=None):
# def ReadScalarValue(scalar):
# def WriteScalarValue(scalar, value):
# def reference(reference):
# def from_reference(ref):
# def QueryReference(reference, attribute, c_type, python_type=None):
# def ReleaseDelay(delay):
# def QueryDelay(delay, attribute, c_type, python_type=None):
# def RegisterLogCallback(context, callback, reentrant):
# def wrapper(context, ref, status, string):
# def ReleaseLUT(lut):
# def QueryLUT(lut, attribute, c_type, python_type=None):
# def AccessLUT(lut, ptr, usage):
# def CommitLUT(lut, ptr):
# def ReleaseDistribution(distribution):
# def QueryDistribution(distribution, attribute, c_type, python_type=None):
# def AccessDistribution(distribution, ptr, usage):
# def CommitDistribution(distribution, ptr):
# def ReleaseThreshold(threshold):
# def QueryThreshold(threshold, attribute, c_type, python_type=None):
# def SetThresholdAttribute(threshold, attribute, value, c_type=None):
# def ReleaseMatrix(matrix):
# def QueryMatrix(matrix, attribute, c_type, python_type=None):
# def ReadMatrix(mat, array):
# def WriteMatrix(mat, array):
# def ReleaseConvolution(convolution):
# def QueryConvolution(convolution, attribute, c_type, python_type=None):
# def SetConvolutionAttribute(convolution, attribute, value, c_type=None):
# def WriteConvolutionCoefficients(conv, array):
# def ReadConvolutionCoefficients(conv, array):
# def ReleasePyramid(pyramid):
# def QueryPyramid(pyramid, attribute, c_type, python_type=None):
# def ReleaseRemap(remap):
# def QueryRemap(remap, attribute, c_type, python_type=None):
# def GetRemapPoint(table, dst_x, dst_y):
# def ReleaseArray(array):
# def QueryArray(array, attribute, c_type, python_type=None):
# def FormatArrayPointer(ptr, index, stride):
# def ArrayItem(type, ptr, index, stride):
# def AddArrayItems(arr, count, ptr, stride):
# def AccessArrayRange(arr, start, end, stride, ptr, usage):
# def CommitArrayRange(arr, start, end, ptr):
. Output only the next line. | c = vx.CreateContext() |
Given the code snippet: <|code_start|>
class TestDemo(object):
def test_sobel(self):
c = vx.CreateContext()
img = vx.CreateImage(c, 640, 480, vx.DF_IMAGE_U8)
dx = vx.CreateImage(c, 640, 480, vx.DF_IMAGE_S16)
dy = vx.CreateImage(c, 640, 480, vx.DF_IMAGE_S16)
<|code_end|>
, generate the next line using the imports in this file:
from pyvx import vx, vxu
and context (functions, classes, or occasionally code) from other files:
# Path: pyvx/vx.py
# def _get_attribute(func, ref, attribute, c_type, python_type):
# def _set_attribute(func, ref, attribute, value, c_type):
# def _enum2ctype(data_type):
# def _callback(ctype, callback, parent, error):
# def ReleaseContext(context):
# def QueryContext(context, attribute, c_type, python_type=None):
# def SetContextAttribute(context, attribute, value, c_type=None):
# def ReleaseImage(image):
# def QueryImage(image, attribute, c_type, python_type=None):
# def SetImageAttribute(image, attribute, value, c_type=None):
# def CreateUniformImage(context, width, height, color, value, c_type):
# def CreateImageFromHandle(context, color, addrs, ptrs, import_type):
# def AccessImagePatch(image, rect, plane_index, addr, ptr, usage):
# def CommitImagePatch(image, rect, plane_index, addr, ptr):
# def FormatImagePatchAddress1d(ptr, index, addr):
# def FormatImagePatchAddress2d(ptr, x, y, addr):
# def GetValidRegionImage(image):
# def ReleaseKernel(kernel):
# def QueryKernel(kernel, attribute, c_type, python_type=None):
# def SetKernelAttribute(kernel, attribute, value, c_type=None):
# def AddKernel(context, name, enumeration, func_ptr, numParams, input, output, init, deinit):
# def SetMetaFormatAttribute(meta, attribute, value, c_type=None):
# def LoadKernels(context, module):
# def ReleaseGraph(graph):
# def QueryGraph(graph, attribute, c_type, python_type=None):
# def SetGraphAttribute(graph, attribute, value, c_type=None):
# def ReleaseNode(node):
# def QueryNode(node, attribute, c_type, python_type=None):
# def SetNodeAttribute(node, attribute, value, c_type=None):
# def RemoveNode(node):
# def AssignNodeCallback(node, callback):
# def ReleaseParameter(parameter):
# def QueryParameter(parameter, attribute, c_type, python_type=None):
# def CreateScalar(context, data_type, value):
# def ReleaseScalar(scalar):
# def QueryScalar(scalar, attribute, c_type, python_type=None):
# def ReadScalarValue(scalar):
# def WriteScalarValue(scalar, value):
# def reference(reference):
# def from_reference(ref):
# def QueryReference(reference, attribute, c_type, python_type=None):
# def ReleaseDelay(delay):
# def QueryDelay(delay, attribute, c_type, python_type=None):
# def RegisterLogCallback(context, callback, reentrant):
# def wrapper(context, ref, status, string):
# def ReleaseLUT(lut):
# def QueryLUT(lut, attribute, c_type, python_type=None):
# def AccessLUT(lut, ptr, usage):
# def CommitLUT(lut, ptr):
# def ReleaseDistribution(distribution):
# def QueryDistribution(distribution, attribute, c_type, python_type=None):
# def AccessDistribution(distribution, ptr, usage):
# def CommitDistribution(distribution, ptr):
# def ReleaseThreshold(threshold):
# def QueryThreshold(threshold, attribute, c_type, python_type=None):
# def SetThresholdAttribute(threshold, attribute, value, c_type=None):
# def ReleaseMatrix(matrix):
# def QueryMatrix(matrix, attribute, c_type, python_type=None):
# def ReadMatrix(mat, array):
# def WriteMatrix(mat, array):
# def ReleaseConvolution(convolution):
# def QueryConvolution(convolution, attribute, c_type, python_type=None):
# def SetConvolutionAttribute(convolution, attribute, value, c_type=None):
# def WriteConvolutionCoefficients(conv, array):
# def ReadConvolutionCoefficients(conv, array):
# def ReleasePyramid(pyramid):
# def QueryPyramid(pyramid, attribute, c_type, python_type=None):
# def ReleaseRemap(remap):
# def QueryRemap(remap, attribute, c_type, python_type=None):
# def GetRemapPoint(table, dst_x, dst_y):
# def ReleaseArray(array):
# def QueryArray(array, attribute, c_type, python_type=None):
# def FormatArrayPointer(ptr, index, stride):
# def ArrayItem(type, ptr, index, stride):
# def AddArrayItems(arr, count, ptr, stride):
# def AccessArrayRange(arr, start, end, stride, ptr, usage):
# def CommitArrayRange(arr, start, end, ptr):
#
# Path: pyvx/vxu.py
. Output only the next line. | assert vxu.Sobel3x3(c, img, dx, dy) == vx.SUCCESS |
Given the code snippet: <|code_start|>@api('QueryConvolution', on_exception=return_errno_and_none, returns='status, value')
@api('QueryPyramid', on_exception=return_errno_and_none, returns='status, value')
@api('QueryRemap', on_exception=return_errno_and_none, returns='status, value')
@api('QueryArray', on_exception=return_errno_and_none, returns='status, value')
def query(ref, attribute):
""" Returns status """
return vx.SUCCESS, ref.query(attribute)
@capi('vx_status vxQueryContext(vx_context context, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryImage(vx_image image, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryKernel(vx_kernel kernel, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryGraph(vx_graph graph, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryNode(vx_node node, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryParameter(vx_parameter param, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryScalar(vx_scalar scalar, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryReference(vx_reference ref, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryDelay(vx_delay delay, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryLUT(vx_lut lut, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryDistribution(vx_distribution distribution, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryThreshold(vx_threshold thresh, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryMatrix(vx_matrix mat, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryConvolution(vx_convolution conv, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryPyramid(vx_pyramid pyr, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryRemap(vx_remap r, vx_enum attribute, void *ptr, vx_size size)')
@capi('vx_status vxQueryArray(vx_array arr, vx_enum attribute, void *ptr, vx_size size)')
def c_query(ref, attribute, ptr, size):
value = ref.query(attribute)
a = ref._attributes.get(attribute)
if size != vx.ffi.sizeof(a.ctype):
<|code_end|>
, generate the next line using the imports in this file:
from pyvx.inc import vx
from pyvx.types import VxError
from pyvx import types
from pyvx.optimized_backend import Context
import traceback
and context (functions, classes, or occasionally code) from other files:
# Path: pyvx/types.py
# SCALE_PYRAMID_HALF = 0.5
# SCALE_PYRAMID_ORB = 0.8408964
# FMT_REF = ffi.string(lib._get_FMT_REF())
# FMT_SIZE = ffi.string(lib._get_FMT_SIZE())
# def KERNEL_BASE(vendor, libid):
# def imagepatch_addressing_t(dim_x=0, dim_y=0, stride_x=0, stride_y=0, scale_x=0, scale_y=0, step_x=0, step_y=0):
# def perf_t(tmp=0, beg=0, end=0, sum=0, avg=0, min=0, num=0, max=0):
# def kernel_info_t(enumeration, name):
# def border_mode_t(mode, constant_value=0):
# def keypoint_t(x, y, strength, scale, orientation, tracking_status, error):
# def rectangle_t(start_x, start_y, end_x, end_y):
# def delta_rectangle_t(delta_start_x, delta_start_y, delta_end_x, delta_end_y):
# def coordinates2d_t(x, y):
# def coordinates3d_t(x, y, z):
#
# Path: pyvx/types.py
# SCALE_PYRAMID_HALF = 0.5
# SCALE_PYRAMID_ORB = 0.8408964
# FMT_REF = ffi.string(lib._get_FMT_REF())
# FMT_SIZE = ffi.string(lib._get_FMT_SIZE())
# def KERNEL_BASE(vendor, libid):
# def imagepatch_addressing_t(dim_x=0, dim_y=0, stride_x=0, stride_y=0, scale_x=0, scale_y=0, step_x=0, step_y=0):
# def perf_t(tmp=0, beg=0, end=0, sum=0, avg=0, min=0, num=0, max=0):
# def kernel_info_t(enumeration, name):
# def border_mode_t(mode, constant_value=0):
# def keypoint_t(x, y, strength, scale, orientation, tracking_status, error):
# def rectangle_t(start_x, start_y, end_x, end_y):
# def delta_rectangle_t(delta_start_x, delta_start_y, delta_end_x, delta_end_y):
# def coordinates2d_t(x, y):
# def coordinates3d_t(x, y, z):
. Output only the next line. | raise VxError("Bad size %d in query, expected %d\n" % ( |
Here is a snippet: <|code_start|> fn.apis = []
fn.apis.append(self)
return fn
class capi(object):
def __init__(self, cdecl):
self.cdecl = cdecl
def __call__(self, fn):
if not hasattr(fn, 'capis'):
fn.capis = []
fn.capis.append(self)
return fn
##############################################################################
class Reference(VxObject):
_type = vx.TYPE_REFERENCE
count = attribute(vx.REF_ATTRIBUTE_COUNT, vx.TYPE_UINT32, 1)
type = attribute(vx.REF_ATTRIBUTE_TYPE, vx.TYPE_ENUM, vx.TYPE_REFERENCE)
def query(self, attribute): # xxx: move implementation to backend
try:
return getattr(self, self._attributes[attribute].name)
except KeyError:
msg = 'Attribute %s does not exist' % attribute
<|code_end|>
. Write the next line using the current file imports:
from pyvx.inc import vx
from pyvx.types import VxError
from pyvx import types
from pyvx.optimized_backend import Context
import traceback
and context from other files:
# Path: pyvx/types.py
# SCALE_PYRAMID_HALF = 0.5
# SCALE_PYRAMID_ORB = 0.8408964
# FMT_REF = ffi.string(lib._get_FMT_REF())
# FMT_SIZE = ffi.string(lib._get_FMT_SIZE())
# def KERNEL_BASE(vendor, libid):
# def imagepatch_addressing_t(dim_x=0, dim_y=0, stride_x=0, stride_y=0, scale_x=0, scale_y=0, step_x=0, step_y=0):
# def perf_t(tmp=0, beg=0, end=0, sum=0, avg=0, min=0, num=0, max=0):
# def kernel_info_t(enumeration, name):
# def border_mode_t(mode, constant_value=0):
# def keypoint_t(x, y, strength, scale, orientation, tracking_status, error):
# def rectangle_t(start_x, start_y, end_x, end_y):
# def delta_rectangle_t(delta_start_x, delta_start_y, delta_end_x, delta_end_y):
# def coordinates2d_t(x, y):
# def coordinates3d_t(x, y, z):
#
# Path: pyvx/types.py
# SCALE_PYRAMID_HALF = 0.5
# SCALE_PYRAMID_ORB = 0.8408964
# FMT_REF = ffi.string(lib._get_FMT_REF())
# FMT_SIZE = ffi.string(lib._get_FMT_SIZE())
# def KERNEL_BASE(vendor, libid):
# def imagepatch_addressing_t(dim_x=0, dim_y=0, stride_x=0, stride_y=0, scale_x=0, scale_y=0, step_x=0, step_y=0):
# def perf_t(tmp=0, beg=0, end=0, sum=0, avg=0, min=0, num=0, max=0):
# def kernel_info_t(enumeration, name):
# def border_mode_t(mode, constant_value=0):
# def keypoint_t(x, y, strength, scale, orientation, tracking_status, error):
# def rectangle_t(start_x, start_y, end_x, end_y):
# def delta_rectangle_t(delta_start_x, delta_start_y, delta_end_x, delta_end_y):
# def coordinates2d_t(x, y):
# def coordinates3d_t(x, y, z):
, which may include functions, classes, or code. Output only the next line. | raise types.InvalidParametersError(msg, self) |
Given snippet: <|code_start|>
class VXError(Exception): # FIXME: use different exceptions for different errors
pass
def _check_status(status):
if status != 0: # FIXME vx.SUCCSES
raise VXError(status)
class attribute(object):
def __init__(self, ctype, enum=None, query=None):
self.ctype = ctype
self.enum = enum
self.query = query
def __get__(self, instance, owner):
status, val = self.query(instance.cdata, self.enum, self.ctype)
_check_status(status)
return val
def __set__(self, instance, value):
print("set", instance, value) # FXIME
class VxObjectMeta(type):
def __new__(cls, name, bases, attrs):
for n, a in attrs.items():
if isinstance(a, attribute):
if a.query is None:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import threading
from pyvx import vx
and context:
# Path: pyvx/vx.py
# def _get_attribute(func, ref, attribute, c_type, python_type):
# def _set_attribute(func, ref, attribute, value, c_type):
# def _enum2ctype(data_type):
# def _callback(ctype, callback, parent, error):
# def ReleaseContext(context):
# def QueryContext(context, attribute, c_type, python_type=None):
# def SetContextAttribute(context, attribute, value, c_type=None):
# def ReleaseImage(image):
# def QueryImage(image, attribute, c_type, python_type=None):
# def SetImageAttribute(image, attribute, value, c_type=None):
# def CreateUniformImage(context, width, height, color, value, c_type):
# def CreateImageFromHandle(context, color, addrs, ptrs, import_type):
# def AccessImagePatch(image, rect, plane_index, addr, ptr, usage):
# def CommitImagePatch(image, rect, plane_index, addr, ptr):
# def FormatImagePatchAddress1d(ptr, index, addr):
# def FormatImagePatchAddress2d(ptr, x, y, addr):
# def GetValidRegionImage(image):
# def ReleaseKernel(kernel):
# def QueryKernel(kernel, attribute, c_type, python_type=None):
# def SetKernelAttribute(kernel, attribute, value, c_type=None):
# def AddKernel(context, name, enumeration, func_ptr, numParams, input, output, init, deinit):
# def SetMetaFormatAttribute(meta, attribute, value, c_type=None):
# def LoadKernels(context, module):
# def ReleaseGraph(graph):
# def QueryGraph(graph, attribute, c_type, python_type=None):
# def SetGraphAttribute(graph, attribute, value, c_type=None):
# def ReleaseNode(node):
# def QueryNode(node, attribute, c_type, python_type=None):
# def SetNodeAttribute(node, attribute, value, c_type=None):
# def RemoveNode(node):
# def AssignNodeCallback(node, callback):
# def ReleaseParameter(parameter):
# def QueryParameter(parameter, attribute, c_type, python_type=None):
# def CreateScalar(context, data_type, value):
# def ReleaseScalar(scalar):
# def QueryScalar(scalar, attribute, c_type, python_type=None):
# def ReadScalarValue(scalar):
# def WriteScalarValue(scalar, value):
# def reference(reference):
# def from_reference(ref):
# def QueryReference(reference, attribute, c_type, python_type=None):
# def ReleaseDelay(delay):
# def QueryDelay(delay, attribute, c_type, python_type=None):
# def RegisterLogCallback(context, callback, reentrant):
# def wrapper(context, ref, status, string):
# def ReleaseLUT(lut):
# def QueryLUT(lut, attribute, c_type, python_type=None):
# def AccessLUT(lut, ptr, usage):
# def CommitLUT(lut, ptr):
# def ReleaseDistribution(distribution):
# def QueryDistribution(distribution, attribute, c_type, python_type=None):
# def AccessDistribution(distribution, ptr, usage):
# def CommitDistribution(distribution, ptr):
# def ReleaseThreshold(threshold):
# def QueryThreshold(threshold, attribute, c_type, python_type=None):
# def SetThresholdAttribute(threshold, attribute, value, c_type=None):
# def ReleaseMatrix(matrix):
# def QueryMatrix(matrix, attribute, c_type, python_type=None):
# def ReadMatrix(mat, array):
# def WriteMatrix(mat, array):
# def ReleaseConvolution(convolution):
# def QueryConvolution(convolution, attribute, c_type, python_type=None):
# def SetConvolutionAttribute(convolution, attribute, value, c_type=None):
# def WriteConvolutionCoefficients(conv, array):
# def ReadConvolutionCoefficients(conv, array):
# def ReleasePyramid(pyramid):
# def QueryPyramid(pyramid, attribute, c_type, python_type=None):
# def ReleaseRemap(remap):
# def QueryRemap(remap, attribute, c_type, python_type=None):
# def GetRemapPoint(table, dst_x, dst_y):
# def ReleaseArray(array):
# def QueryArray(array, attribute, c_type, python_type=None):
# def FormatArrayPointer(ptr, index, stride):
# def ArrayItem(type, ptr, index, stride):
# def AddArrayItems(arr, count, ptr, stride):
# def AccessArrayRange(arr, start, end, stride, ptr, usage):
# def CommitArrayRange(arr, start, end, ptr):
which might include code, classes, or functions. Output only the next line. | a.query = getattr(vx, 'Query' + name) |
Given the code snippet: <|code_start|>
TIMEZONE = pytz.timezone("US/Eastern")
class TestCommand(TestCase):
def setUp(self):
self.command = fix_timezone_for_period_data.Command()
flow_event = FlowEventFactory(timestamp=TIMEZONE.localize(
datetime.datetime(2014, 1, 31, 17, 0, 0)))
self.user = flow_event.user
FlowEventFactory(user=self.user,
timestamp=TIMEZONE.localize(datetime.datetime(2014, 8, 28)))
def test_fix_timezone_for_period_data_no_periods(self):
<|code_end|>
, generate the next line using the imports in this file:
import datetime
import pytz
from django.test import TestCase
from periods import models as period_models
from periods.management.commands import fix_timezone_for_period_data
from periods.tests.factories import FlowEventFactory
and context (functions, classes, or occasionally code) from other files:
# Path: periods/models.py
# def today():
# def timezone(self):
# def first_days(self):
# def cycle_count(self):
# def get_previous_period(self, previous_to):
# def get_next_period(self, after=None):
# def get_cache_key(self, data_type):
# def get_cycle_lengths(self):
# def get_sorted_cycle_lengths(self):
# def get_full_name(self):
# def get_short_name(self):
# def __str__(self):
# def choices(cls, blank=False):
# def __str__(self):
# def _get_ordinal_value(self, index):
# def cycle_length_minimum(self):
# def cycle_length_maximum(self):
# def _get_statistics_value(self, method_name, num_values_required=1):
# def cycle_length_mean(self):
# def cycle_length_median(self):
# def cycle_length_mode(self):
# def cycle_length_standard_deviation(self):
# def current_cycle_length(self):
# def first_date(self):
# def first_day(self):
# def set_start_date_and_day(self, min_timestamp):
# def predicted_events(self):
# def __str__(self):
# def get_from_server(from_date):
# def get_for_date(cls, from_date, to_date):
# def create_auth_token(sender, instance=None, created=False, **kwargs):
# def add_to_permissions_group(sender, instance, **kwargs):
# def create_statistics(sender, instance, **kwargs):
# def update_statistics(sender, instance, **kwargs):
# class User(AbstractEmailUser):
# class LabelChoicesEnum(enum.Enum):
# class FlowLevel(LabelChoicesEnum):
# class FlowColor(LabelChoicesEnum):
# class ClotSize(LabelChoicesEnum):
# class CrampLevel(LabelChoicesEnum):
# class FlowEvent(models.Model):
# class Statistics(models.Model):
# class Meta:
# class AerisData(models.Model):
# SPOTTING = 0
# LIGHT = 1
# MEDIUM = 2
# HEAVY = 3
# VERY_HEAVY = 4
# PINK = 0
# LIGHT_RED = 1
# RED = 2
# DARK_RED = 3
# BROWN = 4
# BLACK = 5
# SMALL = 0
# MEDIUM = 1
# LARGE = 2
# SLIGHT = 0
# MODERATE = 1
# SEVERE = 2
#
# Path: periods/management/commands/fix_timezone_for_period_data.py
# class Command(BaseCommand):
# def add_arguments(self, parser):
# def handle(self, *args, **options):
#
# Path: periods/tests/factories.py
# class FlowEventFactory(factory.DjangoModelFactory):
# class Meta:
# model = period_models.FlowEvent
#
# user = factory.SubFactory(UserFactory)
# timestamp = pytz.utc.localize(datetime.datetime(2014, 1, 31, 17, 0, 0))
# first_day = True
. Output only the next line. | period_models.FlowEvent.objects.all().delete() |
Based on the snippet: <|code_start|>
TIMEZONE = pytz.timezone("US/Eastern")
class TestCommand(TestCase):
def setUp(self):
<|code_end|>
, predict the immediate next line with the help of imports:
import datetime
import pytz
from django.test import TestCase
from periods import models as period_models
from periods.management.commands import fix_timezone_for_period_data
from periods.tests.factories import FlowEventFactory
and context (classes, functions, sometimes code) from other files:
# Path: periods/models.py
# def today():
# def timezone(self):
# def first_days(self):
# def cycle_count(self):
# def get_previous_period(self, previous_to):
# def get_next_period(self, after=None):
# def get_cache_key(self, data_type):
# def get_cycle_lengths(self):
# def get_sorted_cycle_lengths(self):
# def get_full_name(self):
# def get_short_name(self):
# def __str__(self):
# def choices(cls, blank=False):
# def __str__(self):
# def _get_ordinal_value(self, index):
# def cycle_length_minimum(self):
# def cycle_length_maximum(self):
# def _get_statistics_value(self, method_name, num_values_required=1):
# def cycle_length_mean(self):
# def cycle_length_median(self):
# def cycle_length_mode(self):
# def cycle_length_standard_deviation(self):
# def current_cycle_length(self):
# def first_date(self):
# def first_day(self):
# def set_start_date_and_day(self, min_timestamp):
# def predicted_events(self):
# def __str__(self):
# def get_from_server(from_date):
# def get_for_date(cls, from_date, to_date):
# def create_auth_token(sender, instance=None, created=False, **kwargs):
# def add_to_permissions_group(sender, instance, **kwargs):
# def create_statistics(sender, instance, **kwargs):
# def update_statistics(sender, instance, **kwargs):
# class User(AbstractEmailUser):
# class LabelChoicesEnum(enum.Enum):
# class FlowLevel(LabelChoicesEnum):
# class FlowColor(LabelChoicesEnum):
# class ClotSize(LabelChoicesEnum):
# class CrampLevel(LabelChoicesEnum):
# class FlowEvent(models.Model):
# class Statistics(models.Model):
# class Meta:
# class AerisData(models.Model):
# SPOTTING = 0
# LIGHT = 1
# MEDIUM = 2
# HEAVY = 3
# VERY_HEAVY = 4
# PINK = 0
# LIGHT_RED = 1
# RED = 2
# DARK_RED = 3
# BROWN = 4
# BLACK = 5
# SMALL = 0
# MEDIUM = 1
# LARGE = 2
# SLIGHT = 0
# MODERATE = 1
# SEVERE = 2
#
# Path: periods/management/commands/fix_timezone_for_period_data.py
# class Command(BaseCommand):
# def add_arguments(self, parser):
# def handle(self, *args, **options):
#
# Path: periods/tests/factories.py
# class FlowEventFactory(factory.DjangoModelFactory):
# class Meta:
# model = period_models.FlowEvent
#
# user = factory.SubFactory(UserFactory)
# timestamp = pytz.utc.localize(datetime.datetime(2014, 1, 31, 17, 0, 0))
# first_day = True
. Output only the next line. | self.command = fix_timezone_for_period_data.Command() |
Using the snippet: <|code_start|>
TIMEZONE = pytz.timezone("US/Eastern")
class TestCommand(TestCase):
def setUp(self):
self.command = fix_timezone_for_period_data.Command()
<|code_end|>
, determine the next line of code. You have imports:
import datetime
import pytz
from django.test import TestCase
from periods import models as period_models
from periods.management.commands import fix_timezone_for_period_data
from periods.tests.factories import FlowEventFactory
and context (class names, function names, or code) available:
# Path: periods/models.py
# def today():
# def timezone(self):
# def first_days(self):
# def cycle_count(self):
# def get_previous_period(self, previous_to):
# def get_next_period(self, after=None):
# def get_cache_key(self, data_type):
# def get_cycle_lengths(self):
# def get_sorted_cycle_lengths(self):
# def get_full_name(self):
# def get_short_name(self):
# def __str__(self):
# def choices(cls, blank=False):
# def __str__(self):
# def _get_ordinal_value(self, index):
# def cycle_length_minimum(self):
# def cycle_length_maximum(self):
# def _get_statistics_value(self, method_name, num_values_required=1):
# def cycle_length_mean(self):
# def cycle_length_median(self):
# def cycle_length_mode(self):
# def cycle_length_standard_deviation(self):
# def current_cycle_length(self):
# def first_date(self):
# def first_day(self):
# def set_start_date_and_day(self, min_timestamp):
# def predicted_events(self):
# def __str__(self):
# def get_from_server(from_date):
# def get_for_date(cls, from_date, to_date):
# def create_auth_token(sender, instance=None, created=False, **kwargs):
# def add_to_permissions_group(sender, instance, **kwargs):
# def create_statistics(sender, instance, **kwargs):
# def update_statistics(sender, instance, **kwargs):
# class User(AbstractEmailUser):
# class LabelChoicesEnum(enum.Enum):
# class FlowLevel(LabelChoicesEnum):
# class FlowColor(LabelChoicesEnum):
# class ClotSize(LabelChoicesEnum):
# class CrampLevel(LabelChoicesEnum):
# class FlowEvent(models.Model):
# class Statistics(models.Model):
# class Meta:
# class AerisData(models.Model):
# SPOTTING = 0
# LIGHT = 1
# MEDIUM = 2
# HEAVY = 3
# VERY_HEAVY = 4
# PINK = 0
# LIGHT_RED = 1
# RED = 2
# DARK_RED = 3
# BROWN = 4
# BLACK = 5
# SMALL = 0
# MEDIUM = 1
# LARGE = 2
# SLIGHT = 0
# MODERATE = 1
# SEVERE = 2
#
# Path: periods/management/commands/fix_timezone_for_period_data.py
# class Command(BaseCommand):
# def add_arguments(self, parser):
# def handle(self, *args, **options):
#
# Path: periods/tests/factories.py
# class FlowEventFactory(factory.DjangoModelFactory):
# class Meta:
# model = period_models.FlowEvent
#
# user = factory.SubFactory(UserFactory)
# timestamp = pytz.utc.localize(datetime.datetime(2014, 1, 31, 17, 0, 0))
# first_day = True
. Output only the next line. | flow_event = FlowEventFactory(timestamp=TIMEZONE.localize( |
Given the code snippet: <|code_start|>
class NullableEnumField(serializers.ChoiceField):
"""
Field that handles empty entries for EnumFields
"""
def __init__(self, enum, **kwargs):
super(NullableEnumField, self).__init__(enum.choices(), allow_blank=True, required=False)
def to_internal_value(self, data):
if data == '' and self.allow_blank:
return None
return super(NullableEnumField, self).to_internal_value(data)
class FlowEventSerializer(serializers.ModelSerializer):
<|code_end|>
, generate the next line using the imports in this file:
import django_filters
from rest_framework import serializers
from periods import models as period_models
and context (functions, classes, or occasionally code) from other files:
# Path: periods/models.py
# def today():
# def timezone(self):
# def first_days(self):
# def cycle_count(self):
# def get_previous_period(self, previous_to):
# def get_next_period(self, after=None):
# def get_cache_key(self, data_type):
# def get_cycle_lengths(self):
# def get_sorted_cycle_lengths(self):
# def get_full_name(self):
# def get_short_name(self):
# def __str__(self):
# def choices(cls, blank=False):
# def __str__(self):
# def _get_ordinal_value(self, index):
# def cycle_length_minimum(self):
# def cycle_length_maximum(self):
# def _get_statistics_value(self, method_name, num_values_required=1):
# def cycle_length_mean(self):
# def cycle_length_median(self):
# def cycle_length_mode(self):
# def cycle_length_standard_deviation(self):
# def current_cycle_length(self):
# def first_date(self):
# def first_day(self):
# def set_start_date_and_day(self, min_timestamp):
# def predicted_events(self):
# def __str__(self):
# def get_from_server(from_date):
# def get_for_date(cls, from_date, to_date):
# def create_auth_token(sender, instance=None, created=False, **kwargs):
# def add_to_permissions_group(sender, instance, **kwargs):
# def create_statistics(sender, instance, **kwargs):
# def update_statistics(sender, instance, **kwargs):
# class User(AbstractEmailUser):
# class LabelChoicesEnum(enum.Enum):
# class FlowLevel(LabelChoicesEnum):
# class FlowColor(LabelChoicesEnum):
# class ClotSize(LabelChoicesEnum):
# class CrampLevel(LabelChoicesEnum):
# class FlowEvent(models.Model):
# class Statistics(models.Model):
# class Meta:
# class AerisData(models.Model):
# SPOTTING = 0
# LIGHT = 1
# MEDIUM = 2
# HEAVY = 3
# VERY_HEAVY = 4
# PINK = 0
# LIGHT_RED = 1
# RED = 2
# DARK_RED = 3
# BROWN = 4
# BLACK = 5
# SMALL = 0
# MEDIUM = 1
# LARGE = 2
# SLIGHT = 0
# MODERATE = 1
# SEVERE = 2
. Output only the next line. | clots = NullableEnumField(period_models.ClotSize) |
Next line prediction: <|code_start|>
class PeriodForm(forms.ModelForm):
comment = forms.CharField(widget=forms.Textarea(attrs={'rows': 3}))
class Meta:
<|code_end|>
. Use current file imports:
(import floppyforms.__future__ as forms
from periods import models as period_models)
and context including class names, function names, or small code snippets from other files:
# Path: periods/models.py
# def today():
# def timezone(self):
# def first_days(self):
# def cycle_count(self):
# def get_previous_period(self, previous_to):
# def get_next_period(self, after=None):
# def get_cache_key(self, data_type):
# def get_cycle_lengths(self):
# def get_sorted_cycle_lengths(self):
# def get_full_name(self):
# def get_short_name(self):
# def __str__(self):
# def choices(cls, blank=False):
# def __str__(self):
# def _get_ordinal_value(self, index):
# def cycle_length_minimum(self):
# def cycle_length_maximum(self):
# def _get_statistics_value(self, method_name, num_values_required=1):
# def cycle_length_mean(self):
# def cycle_length_median(self):
# def cycle_length_mode(self):
# def cycle_length_standard_deviation(self):
# def current_cycle_length(self):
# def first_date(self):
# def first_day(self):
# def set_start_date_and_day(self, min_timestamp):
# def predicted_events(self):
# def __str__(self):
# def get_from_server(from_date):
# def get_for_date(cls, from_date, to_date):
# def create_auth_token(sender, instance=None, created=False, **kwargs):
# def add_to_permissions_group(sender, instance, **kwargs):
# def create_statistics(sender, instance, **kwargs):
# def update_statistics(sender, instance, **kwargs):
# class User(AbstractEmailUser):
# class LabelChoicesEnum(enum.Enum):
# class FlowLevel(LabelChoicesEnum):
# class FlowColor(LabelChoicesEnum):
# class ClotSize(LabelChoicesEnum):
# class CrampLevel(LabelChoicesEnum):
# class FlowEvent(models.Model):
# class Statistics(models.Model):
# class Meta:
# class AerisData(models.Model):
# SPOTTING = 0
# LIGHT = 1
# MEDIUM = 2
# HEAVY = 3
# VERY_HEAVY = 4
# PINK = 0
# LIGHT_RED = 1
# RED = 2
# DARK_RED = 3
# BROWN = 4
# BLACK = 5
# SMALL = 0
# MEDIUM = 1
# LARGE = 2
# SLIGHT = 0
# MODERATE = 1
# SEVERE = 2
. Output only the next line. | model = period_models.FlowEvent |
Here is a snippet: <|code_start|>
class Command(BaseCommand):
help = 'Update FlowEvent data to match User timezone'
def add_arguments(self, parser):
parser.add_argument('--noinput', '--no-input',
action='store_false', dest='interactive', default=True,
help='Tells Django to NOT prompt the user for input of any kind.')
def handle(self, *args, **options):
interactive = options.get('interactive')
<|code_end|>
. Write the next line using the current file imports:
import pytz
from django.core.management.base import BaseCommand
from periods import models as period_models
and context from other files:
# Path: periods/models.py
# def today():
# def timezone(self):
# def first_days(self):
# def cycle_count(self):
# def get_previous_period(self, previous_to):
# def get_next_period(self, after=None):
# def get_cache_key(self, data_type):
# def get_cycle_lengths(self):
# def get_sorted_cycle_lengths(self):
# def get_full_name(self):
# def get_short_name(self):
# def __str__(self):
# def choices(cls, blank=False):
# def __str__(self):
# def _get_ordinal_value(self, index):
# def cycle_length_minimum(self):
# def cycle_length_maximum(self):
# def _get_statistics_value(self, method_name, num_values_required=1):
# def cycle_length_mean(self):
# def cycle_length_median(self):
# def cycle_length_mode(self):
# def cycle_length_standard_deviation(self):
# def current_cycle_length(self):
# def first_date(self):
# def first_day(self):
# def set_start_date_and_day(self, min_timestamp):
# def predicted_events(self):
# def __str__(self):
# def get_from_server(from_date):
# def get_for_date(cls, from_date, to_date):
# def create_auth_token(sender, instance=None, created=False, **kwargs):
# def add_to_permissions_group(sender, instance, **kwargs):
# def create_statistics(sender, instance, **kwargs):
# def update_statistics(sender, instance, **kwargs):
# class User(AbstractEmailUser):
# class LabelChoicesEnum(enum.Enum):
# class FlowLevel(LabelChoicesEnum):
# class FlowColor(LabelChoicesEnum):
# class ClotSize(LabelChoicesEnum):
# class CrampLevel(LabelChoicesEnum):
# class FlowEvent(models.Model):
# class Statistics(models.Model):
# class Meta:
# class AerisData(models.Model):
# SPOTTING = 0
# LIGHT = 1
# MEDIUM = 2
# HEAVY = 3
# VERY_HEAVY = 4
# PINK = 0
# LIGHT_RED = 1
# RED = 2
# DARK_RED = 3
# BROWN = 4
# BLACK = 5
# SMALL = 0
# MEDIUM = 1
# LARGE = 2
# SLIGHT = 0
# MODERATE = 1
# SEVERE = 2
, which may include functions, classes, or code. Output only the next line. | users = period_models.User.objects.filter( |
Predict the next line after this snippet: <|code_start|>
class LoggedInUserTestCase(TestCase):
def setUp(self):
self.user = UserFactory()
self.client = Client()
<|code_end|>
using the current file's imports:
import datetime
import json
import pytz
from django.core.urlresolvers import reverse
from django.http import HttpRequest, QueryDict, Http404
from django.test import Client, TestCase
from mock import patch
from rest_framework.request import Request
from rest_framework.authtoken.models import Token
from periods import models as period_models, views
from periods.serializers import FlowEventSerializer
from periods.tests.factories import FlowEventFactory, UserFactory, PASSWORD
and any relevant context from other files:
# Path: periods/models.py
# def today():
# def timezone(self):
# def first_days(self):
# def cycle_count(self):
# def get_previous_period(self, previous_to):
# def get_next_period(self, after=None):
# def get_cache_key(self, data_type):
# def get_cycle_lengths(self):
# def get_sorted_cycle_lengths(self):
# def get_full_name(self):
# def get_short_name(self):
# def __str__(self):
# def choices(cls, blank=False):
# def __str__(self):
# def _get_ordinal_value(self, index):
# def cycle_length_minimum(self):
# def cycle_length_maximum(self):
# def _get_statistics_value(self, method_name, num_values_required=1):
# def cycle_length_mean(self):
# def cycle_length_median(self):
# def cycle_length_mode(self):
# def cycle_length_standard_deviation(self):
# def current_cycle_length(self):
# def first_date(self):
# def first_day(self):
# def set_start_date_and_day(self, min_timestamp):
# def predicted_events(self):
# def __str__(self):
# def get_from_server(from_date):
# def get_for_date(cls, from_date, to_date):
# def create_auth_token(sender, instance=None, created=False, **kwargs):
# def add_to_permissions_group(sender, instance, **kwargs):
# def create_statistics(sender, instance, **kwargs):
# def update_statistics(sender, instance, **kwargs):
# class User(AbstractEmailUser):
# class LabelChoicesEnum(enum.Enum):
# class FlowLevel(LabelChoicesEnum):
# class FlowColor(LabelChoicesEnum):
# class ClotSize(LabelChoicesEnum):
# class CrampLevel(LabelChoicesEnum):
# class FlowEvent(models.Model):
# class Statistics(models.Model):
# class Meta:
# class AerisData(models.Model):
# SPOTTING = 0
# LIGHT = 1
# MEDIUM = 2
# HEAVY = 3
# VERY_HEAVY = 4
# PINK = 0
# LIGHT_RED = 1
# RED = 2
# DARK_RED = 3
# BROWN = 4
# BLACK = 5
# SMALL = 0
# MEDIUM = 1
# LARGE = 2
# SLIGHT = 0
# MODERATE = 1
# SEVERE = 2
#
# Path: periods/views.py
# class FlowEventViewSet(viewsets.ModelViewSet):
# class StatisticsViewSet(viewsets.ModelViewSet):
# class ApiAuthenticateView(APIView):
# class AerisView(LoginRequiredMixin, JsonView):
# class FlowEventMixin(LoginRequiredMixin):
# class FlowEventCreateView(FlowEventMixin, CreateView):
# class FlowEventUpdateView(FlowEventMixin, UpdateView):
# class FlowEventFormSetView(LoginRequiredMixin, ModelFormSetView):
# class CalendarView(LoginRequiredMixin, TemplateView):
# class CycleLengthFrequencyView(LoginRequiredMixin, JsonView):
# class CycleLengthHistoryView(LoginRequiredMixin, JsonView):
# class QigongCycleView(LoginRequiredMixin, JsonView):
# class StatisticsView(LoginRequiredMixin, TemplateView):
# class ProfileUpdateView(LoginRequiredMixin, UpdateView):
# class ApiInfoView(LoginRequiredMixin, TemplateView):
# class RegenerateKeyView(LoginRequiredMixin, UpdateView):
# def get_queryset(self):
# def perform_create(self, serializer):
# def get_queryset(self):
# def list(self, request, *args, **kwargs):
# def post(self, request, *args, **kwargs):
# def get_context_data(self, **kwargs):
# def convert_to_user_timezone(self, timestamp):
# def set_to_utc(self, timestamp):
# def get_timestamp(self):
# def is_first_day(self, timestamp):
# def get_initial(self):
# def get_object(self, queryset=None):
# def get_queryset(self):
# def get_context_data(self, **kwargs):
# def get_context_data(self, **kwargs):
# def get_context_data(self, **kwargs):
# def _get_level(start_date, today, cycle_length):
# def _generate_cycles(start_date, today, end_date, cycle_length):
# def get_context_data(self, **kwargs):
# def get_context_data(self, **kwargs):
# def get_object(self, *args, **kwargs):
# def get_success_url(self):
# def get_context_data(self, **kwargs):
# def post(self, request, *args, **kwargs):
#
# Path: periods/serializers.py
# class FlowEventSerializer(serializers.ModelSerializer):
# clots = NullableEnumField(period_models.ClotSize)
# cramps = NullableEnumField(period_models.CrampLevel)
#
# class Meta:
# model = period_models.FlowEvent
# exclude = ('user',)
#
# Path: periods/tests/factories.py
# class FlowEventFactory(factory.DjangoModelFactory):
# class Meta:
# model = period_models.FlowEvent
#
# user = factory.SubFactory(UserFactory)
# timestamp = pytz.utc.localize(datetime.datetime(2014, 1, 31, 17, 0, 0))
# first_day = True
#
# class UserFactory(factory.DjangoModelFactory):
# class Meta:
# model = get_user_model()
#
# first_name = u'Jessamyn'
# birth_date = pytz.utc.localize(datetime.datetime(1995, 3, 1))
# email = factory.Sequence(lambda n: "user_%d@example.com" % n)
# password = factory.PostGenerationMethodCall('set_password', PASSWORD)
# last_login = pytz.utc.localize(datetime.datetime(2015, 3, 1))
#
# PASSWORD = 'bogus_password'
. Output only the next line. | self.client.login(email=self.user.email, password=PASSWORD) |
Given snippet: <|code_start|>
class TestCommand(TestCase):
EMAIL_FOOTER = ('Check your calendar: http://example.com/calendar/\nFound a bug? Have a '
'feature request? Please let us know: https://github.com/jessamynsmith/'
'eggtimer-server/issues\nDisable email notifications: '
'http://example.com/accounts/profile/\n')
def setUp(self):
self.command = notify_upcoming_period.Command()
flow_event = FlowEventFactory()
self.user = flow_event.user
FlowEventFactory(user=self.user,
timestamp=pytz.utc.localize(datetime.datetime(2014, 2, 28)))
@patch('django.core.mail.EmailMultiAlternatives.send')
def test_notify_upcoming_period_no_periods(self, mock_send):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import datetime
import pytz
from django.conf import settings
from django.test import TestCase
from mock import ANY, patch
from periods import models as period_models
from periods.management.commands import notify_upcoming_period
from periods.tests.factories import FlowEventFactory
and context:
# Path: periods/models.py
# def today():
# def timezone(self):
# def first_days(self):
# def cycle_count(self):
# def get_previous_period(self, previous_to):
# def get_next_period(self, after=None):
# def get_cache_key(self, data_type):
# def get_cycle_lengths(self):
# def get_sorted_cycle_lengths(self):
# def get_full_name(self):
# def get_short_name(self):
# def __str__(self):
# def choices(cls, blank=False):
# def __str__(self):
# def _get_ordinal_value(self, index):
# def cycle_length_minimum(self):
# def cycle_length_maximum(self):
# def _get_statistics_value(self, method_name, num_values_required=1):
# def cycle_length_mean(self):
# def cycle_length_median(self):
# def cycle_length_mode(self):
# def cycle_length_standard_deviation(self):
# def current_cycle_length(self):
# def first_date(self):
# def first_day(self):
# def set_start_date_and_day(self, min_timestamp):
# def predicted_events(self):
# def __str__(self):
# def get_from_server(from_date):
# def get_for_date(cls, from_date, to_date):
# def create_auth_token(sender, instance=None, created=False, **kwargs):
# def add_to_permissions_group(sender, instance, **kwargs):
# def create_statistics(sender, instance, **kwargs):
# def update_statistics(sender, instance, **kwargs):
# class User(AbstractEmailUser):
# class LabelChoicesEnum(enum.Enum):
# class FlowLevel(LabelChoicesEnum):
# class FlowColor(LabelChoicesEnum):
# class ClotSize(LabelChoicesEnum):
# class CrampLevel(LabelChoicesEnum):
# class FlowEvent(models.Model):
# class Statistics(models.Model):
# class Meta:
# class AerisData(models.Model):
# SPOTTING = 0
# LIGHT = 1
# MEDIUM = 2
# HEAVY = 3
# VERY_HEAVY = 4
# PINK = 0
# LIGHT_RED = 1
# RED = 2
# DARK_RED = 3
# BROWN = 4
# BLACK = 5
# SMALL = 0
# MEDIUM = 1
# LARGE = 2
# SLIGHT = 0
# MODERATE = 1
# SEVERE = 2
#
# Path: periods/management/commands/notify_upcoming_period.py
# class Command(BaseCommand):
# def _format_date(self, date_value):
# def handle(self, *args, **options):
#
# Path: periods/tests/factories.py
# class FlowEventFactory(factory.DjangoModelFactory):
# class Meta:
# model = period_models.FlowEvent
#
# user = factory.SubFactory(UserFactory)
# timestamp = pytz.utc.localize(datetime.datetime(2014, 1, 31, 17, 0, 0))
# first_day = True
which might include code, classes, or functions. Output only the next line. | period_models.FlowEvent.objects.all().delete() |
Continue the code snippet: <|code_start|>
class TestCommand(TestCase):
EMAIL_FOOTER = ('Check your calendar: http://example.com/calendar/\nFound a bug? Have a '
'feature request? Please let us know: https://github.com/jessamynsmith/'
'eggtimer-server/issues\nDisable email notifications: '
'http://example.com/accounts/profile/\n')
def setUp(self):
<|code_end|>
. Use current file imports:
import datetime
import pytz
from django.conf import settings
from django.test import TestCase
from mock import ANY, patch
from periods import models as period_models
from periods.management.commands import notify_upcoming_period
from periods.tests.factories import FlowEventFactory
and context (classes, functions, or code) from other files:
# Path: periods/models.py
# def today():
# def timezone(self):
# def first_days(self):
# def cycle_count(self):
# def get_previous_period(self, previous_to):
# def get_next_period(self, after=None):
# def get_cache_key(self, data_type):
# def get_cycle_lengths(self):
# def get_sorted_cycle_lengths(self):
# def get_full_name(self):
# def get_short_name(self):
# def __str__(self):
# def choices(cls, blank=False):
# def __str__(self):
# def _get_ordinal_value(self, index):
# def cycle_length_minimum(self):
# def cycle_length_maximum(self):
# def _get_statistics_value(self, method_name, num_values_required=1):
# def cycle_length_mean(self):
# def cycle_length_median(self):
# def cycle_length_mode(self):
# def cycle_length_standard_deviation(self):
# def current_cycle_length(self):
# def first_date(self):
# def first_day(self):
# def set_start_date_and_day(self, min_timestamp):
# def predicted_events(self):
# def __str__(self):
# def get_from_server(from_date):
# def get_for_date(cls, from_date, to_date):
# def create_auth_token(sender, instance=None, created=False, **kwargs):
# def add_to_permissions_group(sender, instance, **kwargs):
# def create_statistics(sender, instance, **kwargs):
# def update_statistics(sender, instance, **kwargs):
# class User(AbstractEmailUser):
# class LabelChoicesEnum(enum.Enum):
# class FlowLevel(LabelChoicesEnum):
# class FlowColor(LabelChoicesEnum):
# class ClotSize(LabelChoicesEnum):
# class CrampLevel(LabelChoicesEnum):
# class FlowEvent(models.Model):
# class Statistics(models.Model):
# class Meta:
# class AerisData(models.Model):
# SPOTTING = 0
# LIGHT = 1
# MEDIUM = 2
# HEAVY = 3
# VERY_HEAVY = 4
# PINK = 0
# LIGHT_RED = 1
# RED = 2
# DARK_RED = 3
# BROWN = 4
# BLACK = 5
# SMALL = 0
# MEDIUM = 1
# LARGE = 2
# SLIGHT = 0
# MODERATE = 1
# SEVERE = 2
#
# Path: periods/management/commands/notify_upcoming_period.py
# class Command(BaseCommand):
# def _format_date(self, date_value):
# def handle(self, *args, **options):
#
# Path: periods/tests/factories.py
# class FlowEventFactory(factory.DjangoModelFactory):
# class Meta:
# model = period_models.FlowEvent
#
# user = factory.SubFactory(UserFactory)
# timestamp = pytz.utc.localize(datetime.datetime(2014, 1, 31, 17, 0, 0))
# first_day = True
. Output only the next line. | self.command = notify_upcoming_period.Command() |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.