Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Given the following code snippet before the placeholder: <|code_start|>
try:
except ImportError:
__all__ = [
'hmac_sha1',
'derive_key',
'der_pack',
'der_read',
'get_random_bytes'
]
#
# OATH related
#
def hmac_sha1(secret, message):
return HMAC.new(secret, message, digestmod=SHA).digest()
def time_challenge(t=None):
return struct.pack('>q', int((t or time.time())/30))
def parse_full(resp):
offs = byte2int(resp[-1]) & 0xf
return parse_truncated(resp[offs:offs+4])
<|code_end|>
, predict the next line using imports from the current file:
from yubioath.yubicommon.compat import int2byte, byte2int
from Crypto.Hash import HMAC, SHA
from Crypto.Protocol.KDF import PBKDF2
from Crypto.Random import get_random_bytes
from urlparse import urlparse, parse_qs
from urllib import unquote
from urllib.parse import unquote, urlparse, parse_qs
from win32com.client import GetObject
from win32api import OpenProcess, CloseHandle, TerminateProcess
import subprocess
import struct
import time
import sys
import re
and context including class names, function names, and sometimes code from other files:
# Path: yubioath/yubicommon/compat.py
# def int2byte(i):
# if _PY2:
# return chr(i)
# return bytes((i,))
#
# def byte2int(i):
# if _PY2:
# return ord(i)
# return i
. Output only the next line. | def parse_truncated(resp): |
Next line prediction: <|code_start|>
class CardStatus:
NoCard, InUse, Present = range(3)
class CardWatcher(QtCore.QObject):
status_changed = QtCore.Signal(int)
def __init__(self, reader_name, callback, parent=None):
super(CardWatcher, self).__init__(parent)
self._status = CardStatus.NoCard
self._device = lambda: None
self.reader_name = reader_name
self._callback = callback or (lambda _: _)
self._reader = None
self._reader_observer = _CcidReaderObserver(self)
self._card_observer = _CcidCardObserver(self)
try:
self._update(System.readers(), [])
except EstablishContextException:
pass # No PC/SC context!
def _update(self, added, removed):
if self._reader in removed: # Device removed
self.reader = None
self._set_status(CardStatus.NoCard)
if self._reader is None:
for reader in added:
<|code_end|>
. Use current file imports:
(from ..core.ccid import ScardDevice
from smartcard import System
from smartcard.ReaderMonitoring import ReaderMonitor, ReaderObserver
from smartcard.CardMonitoring import CardMonitor, CardObserver
from smartcard.Exceptions import SmartcardException
from smartcard.pcsc.PCSCExceptions import EstablishContextException
from PySide import QtCore
import weakref)
and context including class names, function names, or small code snippets from other files:
# Path: yubioath/core/ccid.py
# class ScardDevice(object):
#
# """
# Pyscard based backend.
# """
#
# def __init__(self, connection):
# self._conn = connection
#
# def send_apdu(self, cl, ins, p1, p2, data):
# header = [cl, ins, p1, p2, len(data)]
# # from binascii import b2a_hex
# # print("SEND:", b2a_hex(''.join(map(int2byte, header)) + data))
# resp, sw1, sw2 = self._conn.transmit(
# header + [byte2int(b) for b in data])
# # print("RECV:", b2a_hex(b''.join(map(int2byte, resp + [sw1, sw2]))))
# return b''.join(int2byte(i) for i in resp), sw1 << 8 | sw2
#
# def close(self):
# self._conn.disconnect()
#
# def __del__(self):
# self.close()
. Output only the next line. | if self.reader_name in reader.name: |
Using the snippet: <|code_start|> self._callback()
del self._callback
class Worker(QtCore.QObject):
_work_signal = QtCore.Signal(tuple)
_work_done_0 = QtCore.Signal()
@default_messages(_Messages)
def __init__(self, window, m):
super(Worker, self).__init__()
self.m = m
self.window = window
self._work_signal.connect(self.work)
self.work_thread = QtCore.QThread()
self.moveToThread(self.work_thread)
self.work_thread.start()
def post(self, title, fn, callback=None, return_errors=False):
busy = QtGui.QProgressDialog(title, None, 0, 0, get_active_window())
busy.setWindowTitle(self.m.wait)
busy.setWindowModality(QtCore.Qt.WindowModal)
busy.setMinimumDuration(0)
busy.setWindowFlags(
busy.windowFlags() ^ QtCore.Qt.WindowContextHelpButtonHint)
busy.show()
connect_once(self._work_done_0, busy.close)
self.post_bg(fn, callback, return_errors)
def post_bg(self, fn, callback=None, return_errors=False):
<|code_end|>
, determine the next line of code. You have imports:
from PySide import QtGui, QtCore
from functools import partial
from os import getenv
from .utils import connect_once, get_active_window, default_messages
import traceback
and context (class names, function names, or code) available:
# Path: yubioath/yubicommon/qt/utils.py
# def connect_once(signal, slot):
# _SignalConnector(signal, slot)
#
# def get_active_window():
# active_win = QtGui.QApplication.activeWindow()
# if active_win is not None:
# return active_win
#
# wins = [w for w in QtGui.QApplication.topLevelWidgets()
# if isinstance(w, QtGui.QDialog) and w.isVisible()]
#
# if not wins:
# return QtCore.QCoreApplication.instance().window
#
# return wins[0] # TODO: If more than one candidates remain, find best one.
#
# def default_messages(_m, name='m'):
# def inner(fn):
# @wraps(fn)
# def wrapper(*args, **kwargs):
# index = getargspec(fn).args.index(name)
# if len(args) > index:
# args = list(args)
# args[index] = _DefaultMessages(_m, args[index])
# else:
# kwargs[name] = _DefaultMessages(_m, kwargs.get(name))
# return fn(*args, **kwargs)
# return wrapper
# return inner
. Output only the next line. | if isinstance(fn, tuple): |
Using the snippet: <|code_start|># You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Additional permission under GNU GPL version 3 section 7
#
# If you modify this program, or any covered work, by linking or
# combining it with the OpenSSL project's OpenSSL library (or a
# modified version of that library), containing parts covered by the
# terms of the OpenSSL or SSLeay licenses, We grant you additional
# permission to convey the resulting work. Corresponding Source for a
# non-source form of such a combination shall include the source code
# for the parts of OpenSSL used as well as that of the covered work.
from __future__ import absolute_import
class _Messages(object):
wait = 'Please wait...'
class _Event(QtCore.QEvent):
EVENT_TYPE = QtCore.QEvent.Type(QtCore.QEvent.registerEventType())
def __init__(self, callback):
super(_Event, self).__init__(_Event.EVENT_TYPE)
self._callback = callback
def callback(self):
self._callback()
<|code_end|>
, determine the next line of code. You have imports:
from PySide import QtGui, QtCore
from functools import partial
from os import getenv
from .utils import connect_once, get_active_window, default_messages
import traceback
and context (class names, function names, or code) available:
# Path: yubioath/yubicommon/qt/utils.py
# def connect_once(signal, slot):
# _SignalConnector(signal, slot)
#
# def get_active_window():
# active_win = QtGui.QApplication.activeWindow()
# if active_win is not None:
# return active_win
#
# wins = [w for w in QtGui.QApplication.topLevelWidgets()
# if isinstance(w, QtGui.QDialog) and w.isVisible()]
#
# if not wins:
# return QtCore.QCoreApplication.instance().window
#
# return wins[0] # TODO: If more than one candidates remain, find best one.
#
# def default_messages(_m, name='m'):
# def inner(fn):
# @wraps(fn)
# def wrapper(*args, **kwargs):
# index = getargspec(fn).args.index(name)
# if len(args) > index:
# args = list(args)
# args[index] = _DefaultMessages(_m, args[index])
# else:
# kwargs[name] = _DefaultMessages(_m, kwargs.get(name))
# return fn(*args, **kwargs)
# return wrapper
# return inner
. Output only the next line. | del self._callback |
Continue the code snippet: <|code_start|>
from __future__ import absolute_import
class _Messages(object):
wait = 'Please wait...'
class _Event(QtCore.QEvent):
EVENT_TYPE = QtCore.QEvent.Type(QtCore.QEvent.registerEventType())
def __init__(self, callback):
super(_Event, self).__init__(_Event.EVENT_TYPE)
self._callback = callback
def callback(self):
self._callback()
del self._callback
class Worker(QtCore.QObject):
_work_signal = QtCore.Signal(tuple)
_work_done_0 = QtCore.Signal()
@default_messages(_Messages)
def __init__(self, window, m):
super(Worker, self).__init__()
self.m = m
self.window = window
<|code_end|>
. Use current file imports:
from PySide import QtGui, QtCore
from functools import partial
from os import getenv
from .utils import connect_once, get_active_window, default_messages
import traceback
and context (classes, functions, or code) from other files:
# Path: yubioath/yubicommon/qt/utils.py
# def connect_once(signal, slot):
# _SignalConnector(signal, slot)
#
# def get_active_window():
# active_win = QtGui.QApplication.activeWindow()
# if active_win is not None:
# return active_win
#
# wins = [w for w in QtGui.QApplication.topLevelWidgets()
# if isinstance(w, QtGui.QDialog) and w.isVisible()]
#
# if not wins:
# return QtCore.QCoreApplication.instance().window
#
# return wins[0] # TODO: If more than one candidates remain, find best one.
#
# def default_messages(_m, name='m'):
# def inner(fn):
# @wraps(fn)
# def wrapper(*args, **kwargs):
# index = getargspec(fn).args.index(name)
# if len(args) > index:
# args = list(args)
# args[index] = _DefaultMessages(_m, args[index])
# else:
# kwargs[name] = _DefaultMessages(_m, kwargs.get(name))
# return fn(*args, **kwargs)
# return wrapper
# return inner
. Output only the next line. | self._work_signal.connect(self.work) |
Predict the next line for this snippet: <|code_start|># This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Additional permission under GNU GPL version 3 section 7
#
# If you modify this program, or any covered work, by linking or
# combining it with the OpenSSL project's OpenSSL library (or a
# modified version of that library), containing parts covered by the
# terms of the OpenSSL or SSLeay licenses, We grant you additional
# permission to convey the resulting work. Corresponding Source for a
# non-source form of such a combination shall include the source code
# for the parts of OpenSSL used as well as that of the covered work.
YKLEGACY_AID = b'\xa0\x00\x00\x05\x27\x20\x01'
INS_CHALRESP = 0x01
SLOTS = [
-1,
0x30,
0x38
]
<|code_end|>
with the help of current file imports:
from .exc import CardError, InvalidSlotError, NeedsTouchError
from .utils import (format_code, parse_full, time_challenge)
and context from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class InvalidSlotError(Exception):
#
# def __init__(self):
# super(InvalidSlotError, self).__init__(
# 'The selected slot does not contain a valid OATH credential.')
#
# class NeedsTouchError(Exception):
#
# def __init__(self):
# super(NeedsTouchError, self).__init__(
# 'The selected slot needs touch to be used.')
#
# Path: yubioath/core/utils.py
# def format_code(code, digits=6):
# return ('%%0%dd' % digits) % (code % 10 ** digits)
#
# def parse_full(resp):
# offs = byte2int(resp[-1]) & 0xf
# return parse_truncated(resp[offs:offs+4])
#
# def time_challenge(t=None):
# return struct.pack('>q', int((t or time.time())/30))
, which may contain function names, class names, or code. Output only the next line. | class LegacyOathCcid(object): |
Next line prediction: <|code_start|># it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Additional permission under GNU GPL version 3 section 7
#
# If you modify this program, or any covered work, by linking or
# combining it with the OpenSSL project's OpenSSL library (or a
# modified version of that library), containing parts covered by the
# terms of the OpenSSL or SSLeay licenses, We grant you additional
# permission to convey the resulting work. Corresponding Source for a
# non-source form of such a combination shall include the source code
# for the parts of OpenSSL used as well as that of the covered work.
YKLEGACY_AID = b'\xa0\x00\x00\x05\x27\x20\x01'
INS_CHALRESP = 0x01
SLOTS = [
-1,
0x30,
<|code_end|>
. Use current file imports:
(from .exc import CardError, InvalidSlotError, NeedsTouchError
from .utils import (format_code, parse_full, time_challenge))
and context including class names, function names, or small code snippets from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class InvalidSlotError(Exception):
#
# def __init__(self):
# super(InvalidSlotError, self).__init__(
# 'The selected slot does not contain a valid OATH credential.')
#
# class NeedsTouchError(Exception):
#
# def __init__(self):
# super(NeedsTouchError, self).__init__(
# 'The selected slot needs touch to be used.')
#
# Path: yubioath/core/utils.py
# def format_code(code, digits=6):
# return ('%%0%dd' % digits) % (code % 10 ** digits)
#
# def parse_full(resp):
# offs = byte2int(resp[-1]) & 0xf
# return parse_truncated(resp[offs:offs+4])
#
# def time_challenge(t=None):
# return struct.pack('>q', int((t or time.time())/30))
. Output only the next line. | 0x38 |
Continue the code snippet: <|code_start|># This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Additional permission under GNU GPL version 3 section 7
#
# If you modify this program, or any covered work, by linking or
# combining it with the OpenSSL project's OpenSSL library (or a
# modified version of that library), containing parts covered by the
# terms of the OpenSSL or SSLeay licenses, We grant you additional
# permission to convey the resulting work. Corresponding Source for a
# non-source form of such a combination shall include the source code
# for the parts of OpenSSL used as well as that of the covered work.
YKLEGACY_AID = b'\xa0\x00\x00\x05\x27\x20\x01'
INS_CHALRESP = 0x01
SLOTS = [
-1,
<|code_end|>
. Use current file imports:
from .exc import CardError, InvalidSlotError, NeedsTouchError
from .utils import (format_code, parse_full, time_challenge)
and context (classes, functions, or code) from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class InvalidSlotError(Exception):
#
# def __init__(self):
# super(InvalidSlotError, self).__init__(
# 'The selected slot does not contain a valid OATH credential.')
#
# class NeedsTouchError(Exception):
#
# def __init__(self):
# super(NeedsTouchError, self).__init__(
# 'The selected slot needs touch to be used.')
#
# Path: yubioath/core/utils.py
# def format_code(code, digits=6):
# return ('%%0%dd' % digits) % (code % 10 ** digits)
#
# def parse_full(resp):
# offs = byte2int(resp[-1]) & 0xf
# return parse_truncated(resp[offs:offs+4])
#
# def time_challenge(t=None):
# return struct.pack('>q', int((t or time.time())/30))
. Output only the next line. | 0x30, |
Based on the snippet: <|code_start|>#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Additional permission under GNU GPL version 3 section 7
#
# If you modify this program, or any covered work, by linking or
# combining it with the OpenSSL project's OpenSSL library (or a
# modified version of that library), containing parts covered by the
# terms of the OpenSSL or SSLeay licenses, We grant you additional
# permission to convey the resulting work. Corresponding Source for a
# non-source form of such a combination shall include the source code
# for the parts of OpenSSL used as well as that of the covered work.
YKLEGACY_AID = b'\xa0\x00\x00\x05\x27\x20\x01'
INS_CHALRESP = 0x01
SLOTS = [
<|code_end|>
, predict the immediate next line with the help of imports:
from .exc import CardError, InvalidSlotError, NeedsTouchError
from .utils import (format_code, parse_full, time_challenge)
and context (classes, functions, sometimes code) from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class InvalidSlotError(Exception):
#
# def __init__(self):
# super(InvalidSlotError, self).__init__(
# 'The selected slot does not contain a valid OATH credential.')
#
# class NeedsTouchError(Exception):
#
# def __init__(self):
# super(NeedsTouchError, self).__init__(
# 'The selected slot needs touch to be used.')
#
# Path: yubioath/core/utils.py
# def format_code(code, digits=6):
# return ('%%0%dd' % digits) % (code % 10 ** digits)
#
# def parse_full(resp):
# offs = byte2int(resp[-1]) & 0xf
# return parse_truncated(resp[offs:offs+4])
#
# def time_challenge(t=None):
# return struct.pack('>q', int((t or time.time())/30))
. Output only the next line. | -1, |
Continue the code snippet: <|code_start|># This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Additional permission under GNU GPL version 3 section 7
#
# If you modify this program, or any covered work, by linking or
# combining it with the OpenSSL project's OpenSSL library (or a
# modified version of that library), containing parts covered by the
# terms of the OpenSSL or SSLeay licenses, We grant you additional
# permission to convey the resulting work. Corresponding Source for a
# non-source form of such a combination shall include the source code
# for the parts of OpenSSL used as well as that of the covered work.
YKLEGACY_AID = b'\xa0\x00\x00\x05\x27\x20\x01'
INS_CHALRESP = 0x01
SLOTS = [
-1,
0x30,
0x38
]
<|code_end|>
. Use current file imports:
from .exc import CardError, InvalidSlotError, NeedsTouchError
from .utils import (format_code, parse_full, time_challenge)
and context (classes, functions, or code) from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class InvalidSlotError(Exception):
#
# def __init__(self):
# super(InvalidSlotError, self).__init__(
# 'The selected slot does not contain a valid OATH credential.')
#
# class NeedsTouchError(Exception):
#
# def __init__(self):
# super(NeedsTouchError, self).__init__(
# 'The selected slot needs touch to be used.')
#
# Path: yubioath/core/utils.py
# def format_code(code, digits=6):
# return ('%%0%dd' % digits) % (code % 10 ** digits)
#
# def parse_full(resp):
# offs = byte2int(resp[-1]) & 0xf
# return parse_truncated(resp[offs:offs+4])
#
# def time_challenge(t=None):
# return struct.pack('>q', int((t or time.time())/30))
. Output only the next line. | class LegacyOathCcid(object): |
Given the code snippet: <|code_start|># This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Additional permission under GNU GPL version 3 section 7
#
# If you modify this program, or any covered work, by linking or
# combining it with the OpenSSL project's OpenSSL library (or a
# modified version of that library), containing parts covered by the
# terms of the OpenSSL or SSLeay licenses, We grant you additional
# permission to convey the resulting work. Corresponding Source for a
# non-source form of such a combination shall include the source code
# for the parts of OpenSSL used as well as that of the covered work.
YKLEGACY_AID = b'\xa0\x00\x00\x05\x27\x20\x01'
INS_CHALRESP = 0x01
SLOTS = [
-1,
0x30,
0x38
]
<|code_end|>
, generate the next line using the imports in this file:
from .exc import CardError, InvalidSlotError, NeedsTouchError
from .utils import (format_code, parse_full, time_challenge)
and context (functions, classes, or occasionally code) from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class InvalidSlotError(Exception):
#
# def __init__(self):
# super(InvalidSlotError, self).__init__(
# 'The selected slot does not contain a valid OATH credential.')
#
# class NeedsTouchError(Exception):
#
# def __init__(self):
# super(NeedsTouchError, self).__init__(
# 'The selected slot needs touch to be used.')
#
# Path: yubioath/core/utils.py
# def format_code(code, digits=6):
# return ('%%0%dd' % digits) % (code % 10 ** digits)
#
# def parse_full(resp):
# offs = byte2int(resp[-1]) & 0xf
# return parse_truncated(resp[offs:offs+4])
#
# def time_challenge(t=None):
# return struct.pack('>q', int((t or time.time())/30))
. Output only the next line. | class LegacyOathCcid(object): |
Next line prediction: <|code_start|># combining it with the OpenSSL project's OpenSSL library (or a
# modified version of that library), containing parts covered by the
# terms of the OpenSSL or SSLeay licenses, We grant you additional
# permission to convey the resulting work. Corresponding Source for a
# non-source form of such a combination shall include the source code
# for the parts of OpenSSL used as well as that of the covered work.
from __future__ import print_function, division
YKOATH_AID = b'\xa0\x00\x00\x05\x27\x21\x01\x01'
YKOATH_NO_SPACE = 0x6a84
INS_PUT = 0x01
INS_DELETE = 0x02
INS_SET_CODE = 0x03
INS_RESET = 0x04
INS_LIST = 0xa1
INS_CALCULATE = 0xa2
INS_VALIDATE = 0xa3
INS_CALC_ALL = 0xa4
INS_SEND_REMAINING = 0xa5
RESP_MORE_DATA = 0x61
TAG_NAME = 0x71
TAG_NAME_LIST = 0x72
TAG_KEY = 0x73
TAG_CHALLENGE = 0x74
TAG_RESPONSE = 0x75
<|code_end|>
. Use current file imports:
(from .exc import CardError, DeviceLockedError, NoSpaceError
from .utils import (
der_read, der_pack, hmac_sha1, derive_key, get_random_bytes,
time_challenge, parse_truncated, format_code)
from yubioath.yubicommon.compat import int2byte, byte2int
import hashlib
import struct
import os)
and context including class names, function names, or small code snippets from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class DeviceLockedError(Exception):
#
# def __init__(self):
# super(DeviceLockedError, self).__init__('Device is locked!')
#
# class NoSpaceError(Exception):
#
# def __init__(self):
# super(NoSpaceError, self).__init__('No space available on device.')
#
# Path: yubioath/core/utils.py
# def hmac_sha1(secret, message):
# def time_challenge(t=None):
# def parse_full(resp):
# def parse_truncated(resp):
# def format_code(code, digits=6):
# def parse_uri(uri):
# def derive_key(salt, passphrase):
# def der_pack(*values):
# def der_read(der_data, expected_t=None):
# def b2len(bs):
# def kill_scdaemon():
# def ccid_supported_but_disabled():
# def _get_pids_linux():
# def _get_pids_osx():
# def _get_pids_win():
# WMI = GetObject('winmgmts:')
# NON_CCID_YK_PIDS = set([0x0110, 0x0113, 0x0114, 0x0401, 0x0402, 0x0403])
#
# Path: yubioath/yubicommon/compat.py
# def int2byte(i):
# if _PY2:
# return chr(i)
# return bytes((i,))
#
# def byte2int(i):
# if _PY2:
# return ord(i)
# return i
. Output only the next line. | TAG_T_RESPONSE = 0x76 |
Using the snippet: <|code_start|>SCHEME_STANDARD = 0x00
SCHEME_STEAM = 0x01
STEAM_CHAR_TABLE = "23456789BCDFGHJKMNPQRTVWXY"
def format_code_steam(int_data, digits):
chars = []
for i in range(5):
chars.append(STEAM_CHAR_TABLE[int_data % len(STEAM_CHAR_TABLE)])
int_data //= len(STEAM_CHAR_TABLE)
return ''.join(chars)
def ensure_unlocked(ykoath):
if ykoath.locked:
raise DeviceLockedError()
def format_truncated(t_resp, scheme=SCHEME_STANDARD):
digits, data = byte2int(t_resp[0]), t_resp[1:]
int_data = parse_truncated(data)
if scheme == SCHEME_STANDARD:
return format_code(int_data, digits)
elif scheme == SCHEME_STEAM:
return format_code_steam(int_data, digits)
def hmac_shorten_key(key, algo):
if algo == ALG_SHA1:
<|code_end|>
, determine the next line of code. You have imports:
from .exc import CardError, DeviceLockedError, NoSpaceError
from .utils import (
der_read, der_pack, hmac_sha1, derive_key, get_random_bytes,
time_challenge, parse_truncated, format_code)
from yubioath.yubicommon.compat import int2byte, byte2int
import hashlib
import struct
import os
and context (class names, function names, or code) available:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class DeviceLockedError(Exception):
#
# def __init__(self):
# super(DeviceLockedError, self).__init__('Device is locked!')
#
# class NoSpaceError(Exception):
#
# def __init__(self):
# super(NoSpaceError, self).__init__('No space available on device.')
#
# Path: yubioath/core/utils.py
# def hmac_sha1(secret, message):
# def time_challenge(t=None):
# def parse_full(resp):
# def parse_truncated(resp):
# def format_code(code, digits=6):
# def parse_uri(uri):
# def derive_key(salt, passphrase):
# def der_pack(*values):
# def der_read(der_data, expected_t=None):
# def b2len(bs):
# def kill_scdaemon():
# def ccid_supported_but_disabled():
# def _get_pids_linux():
# def _get_pids_osx():
# def _get_pids_win():
# WMI = GetObject('winmgmts:')
# NON_CCID_YK_PIDS = set([0x0110, 0x0113, 0x0114, 0x0401, 0x0402, 0x0403])
#
# Path: yubioath/yubicommon/compat.py
# def int2byte(i):
# if _PY2:
# return chr(i)
# return bytes((i,))
#
# def byte2int(i):
# if _PY2:
# return ord(i)
# return i
. Output only the next line. | h = hashlib.sha1() |
Here is a snippet: <|code_start|># permission to convey the resulting work. Corresponding Source for a
# non-source form of such a combination shall include the source code
# for the parts of OpenSSL used as well as that of the covered work.
from __future__ import print_function, division
YKOATH_AID = b'\xa0\x00\x00\x05\x27\x21\x01\x01'
YKOATH_NO_SPACE = 0x6a84
INS_PUT = 0x01
INS_DELETE = 0x02
INS_SET_CODE = 0x03
INS_RESET = 0x04
INS_LIST = 0xa1
INS_CALCULATE = 0xa2
INS_VALIDATE = 0xa3
INS_CALC_ALL = 0xa4
INS_SEND_REMAINING = 0xa5
RESP_MORE_DATA = 0x61
TAG_NAME = 0x71
TAG_NAME_LIST = 0x72
TAG_KEY = 0x73
TAG_CHALLENGE = 0x74
TAG_RESPONSE = 0x75
TAG_T_RESPONSE = 0x76
TAG_NO_RESPONSE = 0x77
TAG_PROPERTY = 0x78
<|code_end|>
. Write the next line using the current file imports:
from .exc import CardError, DeviceLockedError, NoSpaceError
from .utils import (
der_read, der_pack, hmac_sha1, derive_key, get_random_bytes,
time_challenge, parse_truncated, format_code)
from yubioath.yubicommon.compat import int2byte, byte2int
import hashlib
import struct
import os
and context from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class DeviceLockedError(Exception):
#
# def __init__(self):
# super(DeviceLockedError, self).__init__('Device is locked!')
#
# class NoSpaceError(Exception):
#
# def __init__(self):
# super(NoSpaceError, self).__init__('No space available on device.')
#
# Path: yubioath/core/utils.py
# def hmac_sha1(secret, message):
# def time_challenge(t=None):
# def parse_full(resp):
# def parse_truncated(resp):
# def format_code(code, digits=6):
# def parse_uri(uri):
# def derive_key(salt, passphrase):
# def der_pack(*values):
# def der_read(der_data, expected_t=None):
# def b2len(bs):
# def kill_scdaemon():
# def ccid_supported_but_disabled():
# def _get_pids_linux():
# def _get_pids_osx():
# def _get_pids_win():
# WMI = GetObject('winmgmts:')
# NON_CCID_YK_PIDS = set([0x0110, 0x0113, 0x0114, 0x0401, 0x0402, 0x0403])
#
# Path: yubioath/yubicommon/compat.py
# def int2byte(i):
# if _PY2:
# return chr(i)
# return bytes((i,))
#
# def byte2int(i):
# if _PY2:
# return ord(i)
# return i
, which may include functions, classes, or code. Output only the next line. | TAG_VERSION = 0x79 |
Next line prediction: <|code_start|>STEAM_CHAR_TABLE = "23456789BCDFGHJKMNPQRTVWXY"
def format_code_steam(int_data, digits):
chars = []
for i in range(5):
chars.append(STEAM_CHAR_TABLE[int_data % len(STEAM_CHAR_TABLE)])
int_data //= len(STEAM_CHAR_TABLE)
return ''.join(chars)
def ensure_unlocked(ykoath):
if ykoath.locked:
raise DeviceLockedError()
def format_truncated(t_resp, scheme=SCHEME_STANDARD):
digits, data = byte2int(t_resp[0]), t_resp[1:]
int_data = parse_truncated(data)
if scheme == SCHEME_STANDARD:
return format_code(int_data, digits)
elif scheme == SCHEME_STEAM:
return format_code_steam(int_data, digits)
def hmac_shorten_key(key, algo):
if algo == ALG_SHA1:
h = hashlib.sha1()
elif algo == ALG_SHA256:
h = hashlib.sha256()
<|code_end|>
. Use current file imports:
(from .exc import CardError, DeviceLockedError, NoSpaceError
from .utils import (
der_read, der_pack, hmac_sha1, derive_key, get_random_bytes,
time_challenge, parse_truncated, format_code)
from yubioath.yubicommon.compat import int2byte, byte2int
import hashlib
import struct
import os)
and context including class names, function names, or small code snippets from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class DeviceLockedError(Exception):
#
# def __init__(self):
# super(DeviceLockedError, self).__init__('Device is locked!')
#
# class NoSpaceError(Exception):
#
# def __init__(self):
# super(NoSpaceError, self).__init__('No space available on device.')
#
# Path: yubioath/core/utils.py
# def hmac_sha1(secret, message):
# def time_challenge(t=None):
# def parse_full(resp):
# def parse_truncated(resp):
# def format_code(code, digits=6):
# def parse_uri(uri):
# def derive_key(salt, passphrase):
# def der_pack(*values):
# def der_read(der_data, expected_t=None):
# def b2len(bs):
# def kill_scdaemon():
# def ccid_supported_but_disabled():
# def _get_pids_linux():
# def _get_pids_osx():
# def _get_pids_win():
# WMI = GetObject('winmgmts:')
# NON_CCID_YK_PIDS = set([0x0110, 0x0113, 0x0114, 0x0401, 0x0402, 0x0403])
#
# Path: yubioath/yubicommon/compat.py
# def int2byte(i):
# if _PY2:
# return chr(i)
# return bytes((i,))
#
# def byte2int(i):
# if _PY2:
# return ord(i)
# return i
. Output only the next line. | else: |
Based on the snippet: <|code_start|>#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Additional permission under GNU GPL version 3 section 7
#
# If you modify this program, or any covered work, by linking or
# combining it with the OpenSSL project's OpenSSL library (or a
# modified version of that library), containing parts covered by the
# terms of the OpenSSL or SSLeay licenses, We grant you additional
# permission to convey the resulting work. Corresponding Source for a
# non-source form of such a combination shall include the source code
# for the parts of OpenSSL used as well as that of the covered work.
from __future__ import print_function, division
YKOATH_AID = b'\xa0\x00\x00\x05\x27\x21\x01\x01'
YKOATH_NO_SPACE = 0x6a84
INS_PUT = 0x01
INS_DELETE = 0x02
INS_SET_CODE = 0x03
INS_RESET = 0x04
INS_LIST = 0xa1
<|code_end|>
, predict the immediate next line with the help of imports:
from .exc import CardError, DeviceLockedError, NoSpaceError
from .utils import (
der_read, der_pack, hmac_sha1, derive_key, get_random_bytes,
time_challenge, parse_truncated, format_code)
from yubioath.yubicommon.compat import int2byte, byte2int
import hashlib
import struct
import os
and context (classes, functions, sometimes code) from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class DeviceLockedError(Exception):
#
# def __init__(self):
# super(DeviceLockedError, self).__init__('Device is locked!')
#
# class NoSpaceError(Exception):
#
# def __init__(self):
# super(NoSpaceError, self).__init__('No space available on device.')
#
# Path: yubioath/core/utils.py
# def hmac_sha1(secret, message):
# def time_challenge(t=None):
# def parse_full(resp):
# def parse_truncated(resp):
# def format_code(code, digits=6):
# def parse_uri(uri):
# def derive_key(salt, passphrase):
# def der_pack(*values):
# def der_read(der_data, expected_t=None):
# def b2len(bs):
# def kill_scdaemon():
# def ccid_supported_but_disabled():
# def _get_pids_linux():
# def _get_pids_osx():
# def _get_pids_win():
# WMI = GetObject('winmgmts:')
# NON_CCID_YK_PIDS = set([0x0110, 0x0113, 0x0114, 0x0401, 0x0402, 0x0403])
#
# Path: yubioath/yubicommon/compat.py
# def int2byte(i):
# if _PY2:
# return chr(i)
# return bytes((i,))
#
# def byte2int(i):
# if _PY2:
# return ord(i)
# return i
. Output only the next line. | INS_CALCULATE = 0xa2 |
Given the following code snippet before the placeholder: <|code_start|># permission to convey the resulting work. Corresponding Source for a
# non-source form of such a combination shall include the source code
# for the parts of OpenSSL used as well as that of the covered work.
from __future__ import print_function, division
YKOATH_AID = b'\xa0\x00\x00\x05\x27\x21\x01\x01'
YKOATH_NO_SPACE = 0x6a84
INS_PUT = 0x01
INS_DELETE = 0x02
INS_SET_CODE = 0x03
INS_RESET = 0x04
INS_LIST = 0xa1
INS_CALCULATE = 0xa2
INS_VALIDATE = 0xa3
INS_CALC_ALL = 0xa4
INS_SEND_REMAINING = 0xa5
RESP_MORE_DATA = 0x61
TAG_NAME = 0x71
TAG_NAME_LIST = 0x72
TAG_KEY = 0x73
TAG_CHALLENGE = 0x74
TAG_RESPONSE = 0x75
TAG_T_RESPONSE = 0x76
TAG_NO_RESPONSE = 0x77
TAG_PROPERTY = 0x78
<|code_end|>
, predict the next line using imports from the current file:
from .exc import CardError, DeviceLockedError, NoSpaceError
from .utils import (
der_read, der_pack, hmac_sha1, derive_key, get_random_bytes,
time_challenge, parse_truncated, format_code)
from yubioath.yubicommon.compat import int2byte, byte2int
import hashlib
import struct
import os
and context including class names, function names, and sometimes code from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class DeviceLockedError(Exception):
#
# def __init__(self):
# super(DeviceLockedError, self).__init__('Device is locked!')
#
# class NoSpaceError(Exception):
#
# def __init__(self):
# super(NoSpaceError, self).__init__('No space available on device.')
#
# Path: yubioath/core/utils.py
# def hmac_sha1(secret, message):
# def time_challenge(t=None):
# def parse_full(resp):
# def parse_truncated(resp):
# def format_code(code, digits=6):
# def parse_uri(uri):
# def derive_key(salt, passphrase):
# def der_pack(*values):
# def der_read(der_data, expected_t=None):
# def b2len(bs):
# def kill_scdaemon():
# def ccid_supported_but_disabled():
# def _get_pids_linux():
# def _get_pids_osx():
# def _get_pids_win():
# WMI = GetObject('winmgmts:')
# NON_CCID_YK_PIDS = set([0x0110, 0x0113, 0x0114, 0x0401, 0x0402, 0x0403])
#
# Path: yubioath/yubicommon/compat.py
# def int2byte(i):
# if _PY2:
# return chr(i)
# return bytes((i,))
#
# def byte2int(i):
# if _PY2:
# return ord(i)
# return i
. Output only the next line. | TAG_VERSION = 0x79 |
Here is a snippet: <|code_start|>TAG_NAME = 0x71
TAG_NAME_LIST = 0x72
TAG_KEY = 0x73
TAG_CHALLENGE = 0x74
TAG_RESPONSE = 0x75
TAG_T_RESPONSE = 0x76
TAG_NO_RESPONSE = 0x77
TAG_PROPERTY = 0x78
TAG_VERSION = 0x79
TAG_IMF = 0x7a
TAG_ALGO = 0x7b
TAG_TOUCH_RESPONSE = 0x7c
TYPE_MASK = 0xf0
TYPE_HOTP = 0x10
TYPE_TOTP = 0x20
ALG_MASK = 0x0f
ALG_SHA1 = 0x01
ALG_SHA256 = 0x02
PROP_ALWAYS_INC = 0x01
PROP_REQUIRE_TOUCH = 0x02
SCHEME_STANDARD = 0x00
SCHEME_STEAM = 0x01
STEAM_CHAR_TABLE = "23456789BCDFGHJKMNPQRTVWXY"
<|code_end|>
. Write the next line using the current file imports:
from .exc import CardError, DeviceLockedError, NoSpaceError
from .utils import (
der_read, der_pack, hmac_sha1, derive_key, get_random_bytes,
time_challenge, parse_truncated, format_code)
from yubioath.yubicommon.compat import int2byte, byte2int
import hashlib
import struct
import os
and context from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class DeviceLockedError(Exception):
#
# def __init__(self):
# super(DeviceLockedError, self).__init__('Device is locked!')
#
# class NoSpaceError(Exception):
#
# def __init__(self):
# super(NoSpaceError, self).__init__('No space available on device.')
#
# Path: yubioath/core/utils.py
# def hmac_sha1(secret, message):
# def time_challenge(t=None):
# def parse_full(resp):
# def parse_truncated(resp):
# def format_code(code, digits=6):
# def parse_uri(uri):
# def derive_key(salt, passphrase):
# def der_pack(*values):
# def der_read(der_data, expected_t=None):
# def b2len(bs):
# def kill_scdaemon():
# def ccid_supported_but_disabled():
# def _get_pids_linux():
# def _get_pids_osx():
# def _get_pids_win():
# WMI = GetObject('winmgmts:')
# NON_CCID_YK_PIDS = set([0x0110, 0x0113, 0x0114, 0x0401, 0x0402, 0x0403])
#
# Path: yubioath/yubicommon/compat.py
# def int2byte(i):
# if _PY2:
# return chr(i)
# return bytes((i,))
#
# def byte2int(i):
# if _PY2:
# return ord(i)
# return i
, which may include functions, classes, or code. Output only the next line. | def format_code_steam(int_data, digits): |
Here is a snippet: <|code_start|>
YKOATH_AID = b'\xa0\x00\x00\x05\x27\x21\x01\x01'
YKOATH_NO_SPACE = 0x6a84
INS_PUT = 0x01
INS_DELETE = 0x02
INS_SET_CODE = 0x03
INS_RESET = 0x04
INS_LIST = 0xa1
INS_CALCULATE = 0xa2
INS_VALIDATE = 0xa3
INS_CALC_ALL = 0xa4
INS_SEND_REMAINING = 0xa5
RESP_MORE_DATA = 0x61
TAG_NAME = 0x71
TAG_NAME_LIST = 0x72
TAG_KEY = 0x73
TAG_CHALLENGE = 0x74
TAG_RESPONSE = 0x75
TAG_T_RESPONSE = 0x76
TAG_NO_RESPONSE = 0x77
TAG_PROPERTY = 0x78
TAG_VERSION = 0x79
TAG_IMF = 0x7a
TAG_ALGO = 0x7b
TAG_TOUCH_RESPONSE = 0x7c
TYPE_MASK = 0xf0
<|code_end|>
. Write the next line using the current file imports:
from .exc import CardError, DeviceLockedError, NoSpaceError
from .utils import (
der_read, der_pack, hmac_sha1, derive_key, get_random_bytes,
time_challenge, parse_truncated, format_code)
from yubioath.yubicommon.compat import int2byte, byte2int
import hashlib
import struct
import os
and context from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class DeviceLockedError(Exception):
#
# def __init__(self):
# super(DeviceLockedError, self).__init__('Device is locked!')
#
# class NoSpaceError(Exception):
#
# def __init__(self):
# super(NoSpaceError, self).__init__('No space available on device.')
#
# Path: yubioath/core/utils.py
# def hmac_sha1(secret, message):
# def time_challenge(t=None):
# def parse_full(resp):
# def parse_truncated(resp):
# def format_code(code, digits=6):
# def parse_uri(uri):
# def derive_key(salt, passphrase):
# def der_pack(*values):
# def der_read(der_data, expected_t=None):
# def b2len(bs):
# def kill_scdaemon():
# def ccid_supported_but_disabled():
# def _get_pids_linux():
# def _get_pids_osx():
# def _get_pids_win():
# WMI = GetObject('winmgmts:')
# NON_CCID_YK_PIDS = set([0x0110, 0x0113, 0x0114, 0x0401, 0x0402, 0x0403])
#
# Path: yubioath/yubicommon/compat.py
# def int2byte(i):
# if _PY2:
# return chr(i)
# return bytes((i,))
#
# def byte2int(i):
# if _PY2:
# return ord(i)
# return i
, which may include functions, classes, or code. Output only the next line. | TYPE_HOTP = 0x10 |
Continue the code snippet: <|code_start|># (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Additional permission under GNU GPL version 3 section 7
#
# If you modify this program, or any covered work, by linking or
# combining it with the OpenSSL project's OpenSSL library (or a
# modified version of that library), containing parts covered by the
# terms of the OpenSSL or SSLeay licenses, We grant you additional
# permission to convey the resulting work. Corresponding Source for a
# non-source form of such a combination shall include the source code
# for the parts of OpenSSL used as well as that of the covered work.
from __future__ import print_function, division
YKOATH_AID = b'\xa0\x00\x00\x05\x27\x21\x01\x01'
YKOATH_NO_SPACE = 0x6a84
INS_PUT = 0x01
INS_DELETE = 0x02
INS_SET_CODE = 0x03
INS_RESET = 0x04
<|code_end|>
. Use current file imports:
from .exc import CardError, DeviceLockedError, NoSpaceError
from .utils import (
der_read, der_pack, hmac_sha1, derive_key, get_random_bytes,
time_challenge, parse_truncated, format_code)
from yubioath.yubicommon.compat import int2byte, byte2int
import hashlib
import struct
import os
and context (classes, functions, or code) from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class DeviceLockedError(Exception):
#
# def __init__(self):
# super(DeviceLockedError, self).__init__('Device is locked!')
#
# class NoSpaceError(Exception):
#
# def __init__(self):
# super(NoSpaceError, self).__init__('No space available on device.')
#
# Path: yubioath/core/utils.py
# def hmac_sha1(secret, message):
# def time_challenge(t=None):
# def parse_full(resp):
# def parse_truncated(resp):
# def format_code(code, digits=6):
# def parse_uri(uri):
# def derive_key(salt, passphrase):
# def der_pack(*values):
# def der_read(der_data, expected_t=None):
# def b2len(bs):
# def kill_scdaemon():
# def ccid_supported_but_disabled():
# def _get_pids_linux():
# def _get_pids_osx():
# def _get_pids_win():
# WMI = GetObject('winmgmts:')
# NON_CCID_YK_PIDS = set([0x0110, 0x0113, 0x0114, 0x0401, 0x0402, 0x0403])
#
# Path: yubioath/yubicommon/compat.py
# def int2byte(i):
# if _PY2:
# return chr(i)
# return bytes((i,))
#
# def byte2int(i):
# if _PY2:
# return ord(i)
# return i
. Output only the next line. | INS_LIST = 0xa1 |
Predict the next line for this snippet: <|code_start|># MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Additional permission under GNU GPL version 3 section 7
#
# If you modify this program, or any covered work, by linking or
# combining it with the OpenSSL project's OpenSSL library (or a
# modified version of that library), containing parts covered by the
# terms of the OpenSSL or SSLeay licenses, We grant you additional
# permission to convey the resulting work. Corresponding Source for a
# non-source form of such a combination shall include the source code
# for the parts of OpenSSL used as well as that of the covered work.
from __future__ import print_function, division
YKOATH_AID = b'\xa0\x00\x00\x05\x27\x21\x01\x01'
YKOATH_NO_SPACE = 0x6a84
INS_PUT = 0x01
INS_DELETE = 0x02
INS_SET_CODE = 0x03
INS_RESET = 0x04
INS_LIST = 0xa1
INS_CALCULATE = 0xa2
INS_VALIDATE = 0xa3
INS_CALC_ALL = 0xa4
<|code_end|>
with the help of current file imports:
from .exc import CardError, DeviceLockedError, NoSpaceError
from .utils import (
der_read, der_pack, hmac_sha1, derive_key, get_random_bytes,
time_challenge, parse_truncated, format_code)
from yubioath.yubicommon.compat import int2byte, byte2int
import hashlib
import struct
import os
and context from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class DeviceLockedError(Exception):
#
# def __init__(self):
# super(DeviceLockedError, self).__init__('Device is locked!')
#
# class NoSpaceError(Exception):
#
# def __init__(self):
# super(NoSpaceError, self).__init__('No space available on device.')
#
# Path: yubioath/core/utils.py
# def hmac_sha1(secret, message):
# def time_challenge(t=None):
# def parse_full(resp):
# def parse_truncated(resp):
# def format_code(code, digits=6):
# def parse_uri(uri):
# def derive_key(salt, passphrase):
# def der_pack(*values):
# def der_read(der_data, expected_t=None):
# def b2len(bs):
# def kill_scdaemon():
# def ccid_supported_but_disabled():
# def _get_pids_linux():
# def _get_pids_osx():
# def _get_pids_win():
# WMI = GetObject('winmgmts:')
# NON_CCID_YK_PIDS = set([0x0110, 0x0113, 0x0114, 0x0401, 0x0402, 0x0403])
#
# Path: yubioath/yubicommon/compat.py
# def int2byte(i):
# if _PY2:
# return chr(i)
# return bytes((i,))
#
# def byte2int(i):
# if _PY2:
# return ord(i)
# return i
, which may contain function names, class names, or code. Output only the next line. | INS_SEND_REMAINING = 0xa5 |
Given snippet: <|code_start|>TAG_T_RESPONSE = 0x76
TAG_NO_RESPONSE = 0x77
TAG_PROPERTY = 0x78
TAG_VERSION = 0x79
TAG_IMF = 0x7a
TAG_ALGO = 0x7b
TAG_TOUCH_RESPONSE = 0x7c
TYPE_MASK = 0xf0
TYPE_HOTP = 0x10
TYPE_TOTP = 0x20
ALG_MASK = 0x0f
ALG_SHA1 = 0x01
ALG_SHA256 = 0x02
PROP_ALWAYS_INC = 0x01
PROP_REQUIRE_TOUCH = 0x02
SCHEME_STANDARD = 0x00
SCHEME_STEAM = 0x01
STEAM_CHAR_TABLE = "23456789BCDFGHJKMNPQRTVWXY"
def format_code_steam(int_data, digits):
chars = []
for i in range(5):
chars.append(STEAM_CHAR_TABLE[int_data % len(STEAM_CHAR_TABLE)])
int_data //= len(STEAM_CHAR_TABLE)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .exc import CardError, DeviceLockedError, NoSpaceError
from .utils import (
der_read, der_pack, hmac_sha1, derive_key, get_random_bytes,
time_challenge, parse_truncated, format_code)
from yubioath.yubicommon.compat import int2byte, byte2int
import hashlib
import struct
import os
and context:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class DeviceLockedError(Exception):
#
# def __init__(self):
# super(DeviceLockedError, self).__init__('Device is locked!')
#
# class NoSpaceError(Exception):
#
# def __init__(self):
# super(NoSpaceError, self).__init__('No space available on device.')
#
# Path: yubioath/core/utils.py
# def hmac_sha1(secret, message):
# def time_challenge(t=None):
# def parse_full(resp):
# def parse_truncated(resp):
# def format_code(code, digits=6):
# def parse_uri(uri):
# def derive_key(salt, passphrase):
# def der_pack(*values):
# def der_read(der_data, expected_t=None):
# def b2len(bs):
# def kill_scdaemon():
# def ccid_supported_but_disabled():
# def _get_pids_linux():
# def _get_pids_osx():
# def _get_pids_win():
# WMI = GetObject('winmgmts:')
# NON_CCID_YK_PIDS = set([0x0110, 0x0113, 0x0114, 0x0401, 0x0402, 0x0403])
#
# Path: yubioath/yubicommon/compat.py
# def int2byte(i):
# if _PY2:
# return chr(i)
# return bytes((i,))
#
# def byte2int(i):
# if _PY2:
# return ord(i)
# return i
which might include code, classes, or functions. Output only the next line. | return ''.join(chars) |
Continue the code snippet: <|code_start|># (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# Additional permission under GNU GPL version 3 section 7
#
# If you modify this program, or any covered work, by linking or
# combining it with the OpenSSL project's OpenSSL library (or a
# modified version of that library), containing parts covered by the
# terms of the OpenSSL or SSLeay licenses, We grant you additional
# permission to convey the resulting work. Corresponding Source for a
# non-source form of such a combination shall include the source code
# for the parts of OpenSSL used as well as that of the covered work.
from __future__ import print_function, division
YKOATH_AID = b'\xa0\x00\x00\x05\x27\x21\x01\x01'
YKOATH_NO_SPACE = 0x6a84
INS_PUT = 0x01
INS_DELETE = 0x02
INS_SET_CODE = 0x03
INS_RESET = 0x04
<|code_end|>
. Use current file imports:
from .exc import CardError, DeviceLockedError, NoSpaceError
from .utils import (
der_read, der_pack, hmac_sha1, derive_key, get_random_bytes,
time_challenge, parse_truncated, format_code)
from yubioath.yubicommon.compat import int2byte, byte2int
import hashlib
import struct
import os
and context (classes, functions, or code) from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class DeviceLockedError(Exception):
#
# def __init__(self):
# super(DeviceLockedError, self).__init__('Device is locked!')
#
# class NoSpaceError(Exception):
#
# def __init__(self):
# super(NoSpaceError, self).__init__('No space available on device.')
#
# Path: yubioath/core/utils.py
# def hmac_sha1(secret, message):
# def time_challenge(t=None):
# def parse_full(resp):
# def parse_truncated(resp):
# def format_code(code, digits=6):
# def parse_uri(uri):
# def derive_key(salt, passphrase):
# def der_pack(*values):
# def der_read(der_data, expected_t=None):
# def b2len(bs):
# def kill_scdaemon():
# def ccid_supported_but_disabled():
# def _get_pids_linux():
# def _get_pids_osx():
# def _get_pids_win():
# WMI = GetObject('winmgmts:')
# NON_CCID_YK_PIDS = set([0x0110, 0x0113, 0x0114, 0x0401, 0x0402, 0x0403])
#
# Path: yubioath/yubicommon/compat.py
# def int2byte(i):
# if _PY2:
# return chr(i)
# return bytes((i,))
#
# def byte2int(i):
# if _PY2:
# return ord(i)
# return i
. Output only the next line. | INS_LIST = 0xa1 |
Given the code snippet: <|code_start|>TAG_NAME = 0x71
TAG_NAME_LIST = 0x72
TAG_KEY = 0x73
TAG_CHALLENGE = 0x74
TAG_RESPONSE = 0x75
TAG_T_RESPONSE = 0x76
TAG_NO_RESPONSE = 0x77
TAG_PROPERTY = 0x78
TAG_VERSION = 0x79
TAG_IMF = 0x7a
TAG_ALGO = 0x7b
TAG_TOUCH_RESPONSE = 0x7c
TYPE_MASK = 0xf0
TYPE_HOTP = 0x10
TYPE_TOTP = 0x20
ALG_MASK = 0x0f
ALG_SHA1 = 0x01
ALG_SHA256 = 0x02
PROP_ALWAYS_INC = 0x01
PROP_REQUIRE_TOUCH = 0x02
SCHEME_STANDARD = 0x00
SCHEME_STEAM = 0x01
STEAM_CHAR_TABLE = "23456789BCDFGHJKMNPQRTVWXY"
<|code_end|>
, generate the next line using the imports in this file:
from .exc import CardError, DeviceLockedError, NoSpaceError
from .utils import (
der_read, der_pack, hmac_sha1, derive_key, get_random_bytes,
time_challenge, parse_truncated, format_code)
from yubioath.yubicommon.compat import int2byte, byte2int
import hashlib
import struct
import os
and context (functions, classes, or occasionally code) from other files:
# Path: yubioath/core/exc.py
# class CardError(Exception):
#
# def __init__(self, status, message=''):
# super(CardError, self).__init__('Card Error (%04x): %s' %
# (status, message))
# self.status = status
#
# class DeviceLockedError(Exception):
#
# def __init__(self):
# super(DeviceLockedError, self).__init__('Device is locked!')
#
# class NoSpaceError(Exception):
#
# def __init__(self):
# super(NoSpaceError, self).__init__('No space available on device.')
#
# Path: yubioath/core/utils.py
# def hmac_sha1(secret, message):
# def time_challenge(t=None):
# def parse_full(resp):
# def parse_truncated(resp):
# def format_code(code, digits=6):
# def parse_uri(uri):
# def derive_key(salt, passphrase):
# def der_pack(*values):
# def der_read(der_data, expected_t=None):
# def b2len(bs):
# def kill_scdaemon():
# def ccid_supported_but_disabled():
# def _get_pids_linux():
# def _get_pids_osx():
# def _get_pids_win():
# WMI = GetObject('winmgmts:')
# NON_CCID_YK_PIDS = set([0x0110, 0x0113, 0x0114, 0x0401, 0x0402, 0x0403])
#
# Path: yubioath/yubicommon/compat.py
# def int2byte(i):
# if _PY2:
# return chr(i)
# return bytes((i,))
#
# def byte2int(i):
# if _PY2:
# return ord(i)
# return i
. Output only the next line. | def format_code_steam(int_data, digits): |
Here is a snippet: <|code_start|>
class SiteTestCase(TestCase):
pass
class SiteFormTestCase(TestCase):
def test_form_validation_success(self):
domain = 'www.google.com'
form = SiteForm(data={'domain': domain})
if form.is_valid():
site = form.save()
self.assertEqual(site.domain, domain)
def test_url_contains_protocol_success(self):
<|code_end|>
. Write the next line using the current file imports:
from django.test import TestCase
from comments.forms import SiteForm
and context from other files:
# Path: comments/forms.py
# class SiteForm(forms.ModelForm):
#
# class Meta:
# model = Site
# exclude = ()
#
# def clean_domain(self):
# p = re.compile(settings.DOMAIN_URL_PATTERN)
# m = p.match(self.cleaned_data['domain'])
#
# if m:
# self.cleaned_data['domain'] = m.groups()[1]
# else:
# raise forms.ValidationError(_("Enter a valid value"))
#
# return self.cleaned_data['domain']
, which may include functions, classes, or code. Output only the next line. | domain = 'https://www.google.com' |
Predict the next line after this snippet: <|code_start|> # for given list of tags.
try:
return self._session.query("name", "c").from_statement(sql).all()
except ResourceClosedError:
return []
else:
# First we get a list of item ids
sql = '''--get_related_tags(): getting list of id for all selected tags
select * from tags t
where t.name in (''' + hlp.to_commalist(tag_names, lambda x: "'" + x + "'") + ''')
order by t.id'''
try:
tags = self._session.query(db.Tag).from_statement(sql).all()
except ResourceClosedError:
tags = []
tag_ids = []
for tag in tags:
tag_ids.append(tag.id)
if len(tag_ids) == 0:
#TODO Maybe raise an exception?
return []
sub_from = ""
for i in range(len(tag_ids)):
if i == 0:
sub_from = sub_from + " items_tags it{} ".format(i+1)
else:
sub_from = sub_from + \
<|code_end|>
using the current file's imports:
from sqlalchemy.orm import contains_eager, joinedload_all
from sqlalchemy.orm.exc import NoResultFound
from sqlalchemy.exc import ResourceClosedError
from reggata.user_config import UserConfig
from reggata.data import operations
from reggata.helpers import to_db_format
import shutil
import datetime
import logging
import os.path
import reggata.errors as err
import reggata.helpers as hlp
import reggata.consts as consts
import reggata.data.db_schema as db
and any relevant context from other files:
# Path: reggata/user_config.py
# class UserConfig(object):
# '''
# This class is an interface for reggata.conf configuration file.
# It is a singleton class.
# '''
# _instance = None
# _props = None
#
# def __new__(cls, *args, **kwargs):
# if not cls._instance:
# cls._instance = super(UserConfig, cls).__new__(cls, *args, **kwargs)
#
# cls._props = Properties()
# if not os.path.exists(consts.USER_CONFIG_DIR):
# os.makedirs(consts.USER_CONFIG_DIR)
#
# if not os.path.exists(consts.USER_CONFIG_FILE):
# with codecs.open(consts.USER_CONFIG_FILE, "w", "utf-8") as f:
# f.write(reggata_default_conf.reggataDefaultConf)
#
# with codecs.open(consts.USER_CONFIG_FILE, "r", "utf-8") as f:
# cls._props.load(f)
#
# return cls._instance
#
# def __init__(self):
# pass
#
# def __getitem__(self, key):
# '''
# This is an operation []. It returns a value of parameter with given key.
# If there is no such key, an exception is raised.
# '''
# return self._props[key]
#
# def get(self, key, default=None):
# '''
# Returns value of parameter with given key. If there are no such key in
# configuration, then a default value is returned.
# '''
# return self._props.get(key, default)
#
# def store(self, key, value):
# self._props[key] = str(value)
# with codecs.open(consts.USER_CONFIG_FILE, 'w', "utf-8") as f:
# self._props.store(f)
#
# def storeAll(self, d):
# if type(d) != dict:
# raise TypeError("This is not a dict instance.")
# for key in d.keys():
# self._props[key] = str(d[key])
# with codecs.open(consts.USER_CONFIG_FILE, 'w', "utf-8") as f:
# self._props.store(f)
#
# def refresh(self):
# with codecs.open(consts.USER_CONFIG_FILE, 'r', "utf-8") as f:
# self._props.load(f)
#
# Path: reggata/data/operations.py
# class ItemOperations:
# def addTags(session, item, tagNames, userLogin):
# def removeTags(session, item, tagNames):
# def removeFields(session, item, fieldNames):
# def addOrUpdateFields(session, item, nameValuePairs, userLogin):
# def addUntrackedFile(session, item, repoBasePath, srcAbsPath, dstRelPath, userLogin):
# def addStoredFile(session, item, repoBasePath, dataRef):
# def removeFile(session, item):
# def moveFile(session, item, repoBasePath, newDstRelPath):
# def renameFile(session, item, newFileName):
# def addThumbnail(session, item):
# def clearThumbnails(session, item):
#
# Path: reggata/helpers.py
# def to_db_format(path):
# '''
# Converts slashes of the given path from current OS format to UNIX format.
# Note: all paths in reggata database are stored in UNIX format.
# '''
# if platform.system() == "Windows":
# return path.replace(os.sep, "/")
# else:
# # Linux and MacOS use UNIX format
# return path
. Output only the next line. | (" join items_tags it{1} on it{1}.item_id=it{0}.item_id " + \ |
Next line prediction: <|code_start|> # DataRef objects are deleted from database, if there are no references to it from other alive Items.
# TODO: Make admin users to be able to delete any files, owned by anybody.
item = self._session.query(db.Item).get(item_id)
if item.user_login != user_login:
raise err.AccessError("Cannot delete item id={0} because it is owned by another user {1}."
.format(item_id, item.user_login))
if item.hasTagsExceptOf(user_login):
raise err.AccessError("Cannot delete item id={0} because another user tagged it."
.format(item_id))
if item.hasFieldsExceptOf(user_login):
raise err.AccessError("Cannot delete item id={0} because another user attached a field to it."
.format(item_id))
data_ref = item.data_ref
item.data_ref = None
item.data_ref_id = None
item.alive = False
self._session.flush()
#All bounded ItemTag and ItemField objects stays in database with the Item
#If data_ref is not referenced by other Items, we delete it
delete_data_ref = data_ref is not None
#We should not delete DataRef if it is owned by another user
<|code_end|>
. Use current file imports:
(from sqlalchemy.orm import contains_eager, joinedload_all
from sqlalchemy.orm.exc import NoResultFound
from sqlalchemy.exc import ResourceClosedError
from reggata.user_config import UserConfig
from reggata.data import operations
from reggata.helpers import to_db_format
import shutil
import datetime
import logging
import os.path
import reggata.errors as err
import reggata.helpers as hlp
import reggata.consts as consts
import reggata.data.db_schema as db)
and context including class names, function names, or small code snippets from other files:
# Path: reggata/user_config.py
# class UserConfig(object):
# '''
# This class is an interface for reggata.conf configuration file.
# It is a singleton class.
# '''
# _instance = None
# _props = None
#
# def __new__(cls, *args, **kwargs):
# if not cls._instance:
# cls._instance = super(UserConfig, cls).__new__(cls, *args, **kwargs)
#
# cls._props = Properties()
# if not os.path.exists(consts.USER_CONFIG_DIR):
# os.makedirs(consts.USER_CONFIG_DIR)
#
# if not os.path.exists(consts.USER_CONFIG_FILE):
# with codecs.open(consts.USER_CONFIG_FILE, "w", "utf-8") as f:
# f.write(reggata_default_conf.reggataDefaultConf)
#
# with codecs.open(consts.USER_CONFIG_FILE, "r", "utf-8") as f:
# cls._props.load(f)
#
# return cls._instance
#
# def __init__(self):
# pass
#
# def __getitem__(self, key):
# '''
# This is an operation []. It returns a value of parameter with given key.
# If there is no such key, an exception is raised.
# '''
# return self._props[key]
#
# def get(self, key, default=None):
# '''
# Returns value of parameter with given key. If there are no such key in
# configuration, then a default value is returned.
# '''
# return self._props.get(key, default)
#
# def store(self, key, value):
# self._props[key] = str(value)
# with codecs.open(consts.USER_CONFIG_FILE, 'w', "utf-8") as f:
# self._props.store(f)
#
# def storeAll(self, d):
# if type(d) != dict:
# raise TypeError("This is not a dict instance.")
# for key in d.keys():
# self._props[key] = str(d[key])
# with codecs.open(consts.USER_CONFIG_FILE, 'w', "utf-8") as f:
# self._props.store(f)
#
# def refresh(self):
# with codecs.open(consts.USER_CONFIG_FILE, 'r', "utf-8") as f:
# self._props.load(f)
#
# Path: reggata/data/operations.py
# class ItemOperations:
# def addTags(session, item, tagNames, userLogin):
# def removeTags(session, item, tagNames):
# def removeFields(session, item, fieldNames):
# def addOrUpdateFields(session, item, nameValuePairs, userLogin):
# def addUntrackedFile(session, item, repoBasePath, srcAbsPath, dstRelPath, userLogin):
# def addStoredFile(session, item, repoBasePath, dataRef):
# def removeFile(session, item):
# def moveFile(session, item, repoBasePath, newDstRelPath):
# def renameFile(session, item, newFileName):
# def addThumbnail(session, item):
# def clearThumbnails(session, item):
#
# Path: reggata/helpers.py
# def to_db_format(path):
# '''
# Converts slashes of the given path from current OS format to UNIX format.
# Note: all paths in reggata database are stored in UNIX format.
# '''
# if platform.system() == "Windows":
# return path.replace(os.sep, "/")
# else:
# # Linux and MacOS use UNIX format
# return path
. Output only the next line. | if delete_data_ref and data_ref.user_login != user_login: |
Given the code snippet: <|code_start|> Limit affects only if tag_names is empty. In other cases limit is ignored.
If limit == 0 it means there is no limit.
'''
#TODO This command should return list of tags, related to arbitrary list of selected items.
def __init__(self, tag_names=[], user_logins=[], limit=0):
self.__tag_names = tag_names
self.__user_logins = user_logins
self.__limit = limit
def _execute(self, uow):
self._session = uow.session
return self.__getRelatedTags(self.__tag_names, self.__user_logins, self.__limit)
def __getRelatedTags(self, tag_names, user_logins, limit):
#TODO user_logins is not used yet..
if len(tag_names) == 0:
#TODO The more items in the repository, the slower this query is performed.
#I think, I should store in database some statistics information, such as number of items
#tagged with each tag. With this information, the query can be rewritten and became much faster.
if limit > 0:
sql = '''
select name, c
from
(select t.name as name, count(*) as c
from items i, tags t
join items_tags it on it.tag_id = t.id and it.item_id = i.id and i.alive
where
1
group by t.name
ORDER BY c DESC LIMIT ''' + str(limit) + ''') as sub
<|code_end|>
, generate the next line using the imports in this file:
from sqlalchemy.orm import contains_eager, joinedload_all
from sqlalchemy.orm.exc import NoResultFound
from sqlalchemy.exc import ResourceClosedError
from reggata.user_config import UserConfig
from reggata.data import operations
from reggata.helpers import to_db_format
import shutil
import datetime
import logging
import os.path
import reggata.errors as err
import reggata.helpers as hlp
import reggata.consts as consts
import reggata.data.db_schema as db
and context (functions, classes, or occasionally code) from other files:
# Path: reggata/user_config.py
# class UserConfig(object):
# '''
# This class is an interface for reggata.conf configuration file.
# It is a singleton class.
# '''
# _instance = None
# _props = None
#
# def __new__(cls, *args, **kwargs):
# if not cls._instance:
# cls._instance = super(UserConfig, cls).__new__(cls, *args, **kwargs)
#
# cls._props = Properties()
# if not os.path.exists(consts.USER_CONFIG_DIR):
# os.makedirs(consts.USER_CONFIG_DIR)
#
# if not os.path.exists(consts.USER_CONFIG_FILE):
# with codecs.open(consts.USER_CONFIG_FILE, "w", "utf-8") as f:
# f.write(reggata_default_conf.reggataDefaultConf)
#
# with codecs.open(consts.USER_CONFIG_FILE, "r", "utf-8") as f:
# cls._props.load(f)
#
# return cls._instance
#
# def __init__(self):
# pass
#
# def __getitem__(self, key):
# '''
# This is an operation []. It returns a value of parameter with given key.
# If there is no such key, an exception is raised.
# '''
# return self._props[key]
#
# def get(self, key, default=None):
# '''
# Returns value of parameter with given key. If there are no such key in
# configuration, then a default value is returned.
# '''
# return self._props.get(key, default)
#
# def store(self, key, value):
# self._props[key] = str(value)
# with codecs.open(consts.USER_CONFIG_FILE, 'w', "utf-8") as f:
# self._props.store(f)
#
# def storeAll(self, d):
# if type(d) != dict:
# raise TypeError("This is not a dict instance.")
# for key in d.keys():
# self._props[key] = str(d[key])
# with codecs.open(consts.USER_CONFIG_FILE, 'w', "utf-8") as f:
# self._props.store(f)
#
# def refresh(self):
# with codecs.open(consts.USER_CONFIG_FILE, 'r', "utf-8") as f:
# self._props.load(f)
#
# Path: reggata/data/operations.py
# class ItemOperations:
# def addTags(session, item, tagNames, userLogin):
# def removeTags(session, item, tagNames):
# def removeFields(session, item, fieldNames):
# def addOrUpdateFields(session, item, nameValuePairs, userLogin):
# def addUntrackedFile(session, item, repoBasePath, srcAbsPath, dstRelPath, userLogin):
# def addStoredFile(session, item, repoBasePath, dataRef):
# def removeFile(session, item):
# def moveFile(session, item, repoBasePath, newDstRelPath):
# def renameFile(session, item, newFileName):
# def addThumbnail(session, item):
# def clearThumbnails(session, item):
#
# Path: reggata/helpers.py
# def to_db_format(path):
# '''
# Converts slashes of the given path from current OS format to UNIX format.
# Note: all paths in reggata database are stored in UNIX format.
# '''
# if platform.system() == "Windows":
# return path.replace(os.sep, "/")
# else:
# # Linux and MacOS use UNIX format
# return path
. Output only the next line. | ORDER BY name |
Continue the code snippet: <|code_start|>
def _defaultFormatObj(row, obj, role):
raise NotImplementedError()
class UnivTableColumn(object):
def __init__(self, columnId, title, formatObjFun=_defaultFormatObj,
delegate=QtGui.QStyledItemDelegate(), setDataFun=None):
self.id = columnId
self.title = title
self._formatObjFun = formatObjFun
self.delegate = delegate
self._setDataFun = setDataFun
def formatObj(self, row, obj, role):
return self._formatObjFun(row, obj, role)
<|code_end|>
. Use current file imports:
from PyQt4 import QtCore, QtGui
from PyQt4.QtCore import Qt
from reggata import helpers
from reggata.user_config import UserConfig
and context (classes, functions, or code) from other files:
# Path: reggata/helpers.py
# def show_exc_info(parent, ex, tracebk=True, details=None, title=None):
# def format_exc_info(excType, value, tb):
# def to_db_format(path):
# def from_db_format(path):
# def to_os_format(path):
# def to_commalist(seq, apply_each=repr, sep=", "):
# def index_of(seq, match=None):
# def is_none_or_empty(s):
# def stringToBool(s):
# def is_internal(url, base_path):
# def removeTrailingOsSeps(path):
# def computeFileHash(filename, chunksize=128*1024): # chunksize = 128 Kbytes
# def _computeFullFileHash(filename, chunksize, algorithm):
# def _computePartialFileHash(filename, chunksize, algorithm, maxBytesToHash):
# def computePasswordHash(strPassword):
# def __init__(self, parent=None):
# def sizeHint(self, option, index):
# def paint(self, painter, option, index):
# def __init__(self, parent=None, r=10):
# def sizeHint(self, option, index):
# def paint(self, painter, option, index):
# def createEditor(self, parent, option, index):
# def setEditorData(self, editor, index):
# def setModelData(self, editor, model, index):
# def updateEditorGeometry(self, editor, option, index):
# def __init__(self, parent=None):
# def sizeHint(self, option, index):
# def paint(self, painter, option, index):
# class ImageThumbDelegate(QtGui.QStyledItemDelegate):
# class RatingDelegate(QtGui.QStyledItemDelegate):
# class HTMLDelegate(QtGui.QStyledItemDelegate):
#
# Path: reggata/user_config.py
# class UserConfig(object):
# '''
# This class is an interface for reggata.conf configuration file.
# It is a singleton class.
# '''
# _instance = None
# _props = None
#
# def __new__(cls, *args, **kwargs):
# if not cls._instance:
# cls._instance = super(UserConfig, cls).__new__(cls, *args, **kwargs)
#
# cls._props = Properties()
# if not os.path.exists(consts.USER_CONFIG_DIR):
# os.makedirs(consts.USER_CONFIG_DIR)
#
# if not os.path.exists(consts.USER_CONFIG_FILE):
# with codecs.open(consts.USER_CONFIG_FILE, "w", "utf-8") as f:
# f.write(reggata_default_conf.reggataDefaultConf)
#
# with codecs.open(consts.USER_CONFIG_FILE, "r", "utf-8") as f:
# cls._props.load(f)
#
# return cls._instance
#
# def __init__(self):
# pass
#
# def __getitem__(self, key):
# '''
# This is an operation []. It returns a value of parameter with given key.
# If there is no such key, an exception is raised.
# '''
# return self._props[key]
#
# def get(self, key, default=None):
# '''
# Returns value of parameter with given key. If there are no such key in
# configuration, then a default value is returned.
# '''
# return self._props.get(key, default)
#
# def store(self, key, value):
# self._props[key] = str(value)
# with codecs.open(consts.USER_CONFIG_FILE, 'w', "utf-8") as f:
# self._props.store(f)
#
# def storeAll(self, d):
# if type(d) != dict:
# raise TypeError("This is not a dict instance.")
# for key in d.keys():
# self._props[key] = str(d[key])
# with codecs.open(consts.USER_CONFIG_FILE, 'w', "utf-8") as f:
# self._props.store(f)
#
# def refresh(self):
# with codecs.open(consts.USER_CONFIG_FILE, 'r', "utf-8") as f:
# self._props.load(f)
. Output only the next line. | def setData(self, obj, row, value, role): |
Using the snippet: <|code_start|>
def is_image(self):
supported = set([".bmp", ".gif", ".jpg", ".jpeg", ".png", ".pbm", ".pgm",
".ppm", ".xbm", ".xpm"])
if self.type and self.type == "FILE" and not is_none_or_empty(self.url):
_root, ext = os.path.splitext(self.url.lower())
if ext in supported:
return True
return False
class Thumbnail(Base):
__tablename__ = "thumbnails"
data_ref_id = sqa.Column(sqa.Integer, ForeignKey("data_refs.id"), primary_key=True)
# Size of thumbnail in pixels
size = sqa.Column(sqa.Integer, primary_key=True)
data = sqa.Column(sqa.LargeBinary)
date_created = sqa.Column(sqa.DateTime)
def __init__(self):
<|code_end|>
, determine the next line of code. You have imports:
import sqlalchemy as sqa
import datetime
import os
import hashlib
import reggata.memento as memento
import reggata.helpers as helpers
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
from sqlalchemy import ForeignKey, orm
from reggata.helpers import is_none_or_empty
and context (class names, function names, or code) available:
# Path: reggata/helpers.py
# def is_none_or_empty(s):
# '''
# Returns True, if given string s is None or "" (empty string).
# If s is and instance of class different from str, function raises TypeError.
# '''
# if s is None:
# return True
# else:
# if not isinstance(s, str):
# raise TypeError("is_none_or_empty() can be applied only to str objects.")
# return True if s == "" else False
. Output only the next line. | self.data_ref_id = None |
Given the code snippet: <|code_start|>t_ignore = ' \t\n\r'
def t_error(t):
raise LexError("Lexical error in '{}'".format(t.value[0]))
def build_lexer():
# TODO: use file for logging
#lex_errorlog = ply.lex.PlyLogger(open(os.path.join(USER_CONFIG_DIR, "lex.log"), "w"))
lex_errorlog = lex.NullLogger()
lexer = lex.lex(errorlog=lex_errorlog)
return lexer
def needs_quote(string):
if re.search(r'\s', string):
return True
m = re.match(t_STRING.__doc__, string)
if m is None or m.group() != string:
return True
return False
if __name__ == '__main__':
data = r'''
Tag1 : "Slash\\:quote\" end"
<|code_end|>
, generate the next line using the imports in this file:
from ply import lex
from reggata.errors import LexError
import re
import reggata.consts as consts
and context (functions, classes, or occasionally code) from other files:
# Path: reggata/errors.py
# class LexError(Exception):
# def __init__(self, msg=None, cause=None):
# super(LexError, self).__init__(msg)
# self.cause = cause
. Output only the next line. | and:"tag 2" |
Using the snippet: <|code_start|> raise YaccError("Syntax error in '{}'".format(str(p)))
# TODO: use file for logging
#yacc_errorlog = ply.yacc.PlyLogger(open(os.path.join(USER_CONFIG_DIR, "yacc.log"), "w"))
yacc_errorlog = yacc.NullLogger()
tokens # This line is needed to supress warning that 'tokens is unused'
lexer = build_lexer()
parsetabPyDir = consts.USER_CONFIG_DIR
parser = yacc.yacc(errorlog=yacc_errorlog,
debug=(1 if consts.DEBUG else 0), # If debug yacc creates parser.out log file
tabmodule="parsetab_query",
outputdir=parsetabPyDir)
def parse(text):
'''
Returns the root node of syntax tree, constructed from text.
'''
return parser.parse(text, lexer=lexer)
if __name__ == '__main__':
##############################
# Test data
data_0 = r'''
Tag1 "Slash\\ quote\" end" and "tag 2" user : "asdf"
'''
data_1 = r'''
<|code_end|>
, determine the next line of code. You have imports:
import ply.yacc as yacc
import reggata.parsers.query_tree_nodes as tree
from reggata.parsers.query_tokens import tokens, build_lexer
from reggata.errors import YaccError
from reggata import consts
and context (class names, function names, or code) available:
# Path: reggata/parsers/query_tokens.py
# ALL_OPERATOR = QCoreApplication.translate("parsers", 'all', None, QCoreApplication.UnicodeUTF8)
# AND_OPERATOR = QCoreApplication.translate("parsers", 'and', None, QCoreApplication.UnicodeUTF8)
# OR_OPERATOR = QCoreApplication.translate("parsers", 'or', None, QCoreApplication.UnicodeUTF8)
# NOT_OPERATOR = QCoreApplication.translate("parsers", 'not', None, QCoreApplication.UnicodeUTF8)
# USER_KEYWORD = QCoreApplication.translate("parsers", 'user', None, QCoreApplication.UnicodeUTF8)
# PATH_KEYWORD = QCoreApplication.translate("parsers", 'path', None, QCoreApplication.UnicodeUTF8)
# TITLE_KEYWORD = QCoreApplication.translate("parsers", 'title', None, QCoreApplication.UnicodeUTF8)
# def t_STRING(t):
# def t_error(t):
# def needs_quote(string):
# def build_lexer():
#
# Path: reggata/errors.py
# class YaccError(Exception):
# def __init__(self, msg=None, cause=None):
# super(YaccError, self).__init__(msg)
# self.cause = cause
#
# Path: reggata/consts.py
# DEBUG = False
# METADATA_DIR = ".reggata"
# DB_FILE = "database.sqlite3"
# USER_CONFIG_DIR = os.path.join(os.path.expanduser("~"), ".config", "reggata")
# USER_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "reggata.conf")
# LOGGING_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "logging.conf")
# THUMBNAIL_DEFAULT_SIZE = 100
# DEFAULT_TMP_DIR = USER_CONFIG_DIR + os.sep + "tmp"
# RATING_FIELD = "Rating"
# NOTES_FIELD = "Notes"
# RESERVED_FIELDS = [RATING_FIELD, NOTES_FIELD]
# STATUSBAR_TIMEOUT = 5000
# DEFAULT_USER_LOGIN = "user"
# DEFAULT_USER_PASSWORD = ""
# STATISTICS_SERVER = "http://reggata-stats.appspot.com"
# MAX_FILE_SIZE_FOR_FULL_HASHING = 100*1024*1024
# MAX_BYTES_FOR_PARTIAL_HASHING = 10*1024*1024
. Output only the next line. | FieldA >= 10 FieldB~2010% and some = sdfsdf |
Predict the next line for this snippet: <|code_start|>yacc_errorlog = yacc.NullLogger()
tokens # This line is needed to supress warning that 'tokens is unused'
lexer = build_lexer()
parsetabPyDir = consts.USER_CONFIG_DIR
parser = yacc.yacc(errorlog=yacc_errorlog,
debug=(1 if consts.DEBUG else 0), # If debug yacc creates parser.out log file
tabmodule="parsetab_query",
outputdir=parsetabPyDir)
def parse(text):
'''
Returns the root node of syntax tree, constructed from text.
'''
return parser.parse(text, lexer=lexer)
if __name__ == '__main__':
##############################
# Test data
data_0 = r'''
Tag1 "Slash\\ quote\" end" and "tag 2" user : "asdf"
'''
data_1 = r'''
FieldA >= 10 FieldB~2010% and some = sdfsdf
'''
data_2 = r'''
<|code_end|>
with the help of current file imports:
import ply.yacc as yacc
import reggata.parsers.query_tree_nodes as tree
from reggata.parsers.query_tokens import tokens, build_lexer
from reggata.errors import YaccError
from reggata import consts
and context from other files:
# Path: reggata/parsers/query_tokens.py
# ALL_OPERATOR = QCoreApplication.translate("parsers", 'all', None, QCoreApplication.UnicodeUTF8)
# AND_OPERATOR = QCoreApplication.translate("parsers", 'and', None, QCoreApplication.UnicodeUTF8)
# OR_OPERATOR = QCoreApplication.translate("parsers", 'or', None, QCoreApplication.UnicodeUTF8)
# NOT_OPERATOR = QCoreApplication.translate("parsers", 'not', None, QCoreApplication.UnicodeUTF8)
# USER_KEYWORD = QCoreApplication.translate("parsers", 'user', None, QCoreApplication.UnicodeUTF8)
# PATH_KEYWORD = QCoreApplication.translate("parsers", 'path', None, QCoreApplication.UnicodeUTF8)
# TITLE_KEYWORD = QCoreApplication.translate("parsers", 'title', None, QCoreApplication.UnicodeUTF8)
# def t_STRING(t):
# def t_error(t):
# def needs_quote(string):
# def build_lexer():
#
# Path: reggata/errors.py
# class YaccError(Exception):
# def __init__(self, msg=None, cause=None):
# super(YaccError, self).__init__(msg)
# self.cause = cause
#
# Path: reggata/consts.py
# DEBUG = False
# METADATA_DIR = ".reggata"
# DB_FILE = "database.sqlite3"
# USER_CONFIG_DIR = os.path.join(os.path.expanduser("~"), ".config", "reggata")
# USER_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "reggata.conf")
# LOGGING_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "logging.conf")
# THUMBNAIL_DEFAULT_SIZE = 100
# DEFAULT_TMP_DIR = USER_CONFIG_DIR + os.sep + "tmp"
# RATING_FIELD = "Rating"
# NOTES_FIELD = "Notes"
# RESERVED_FIELDS = [RATING_FIELD, NOTES_FIELD]
# STATUSBAR_TIMEOUT = 5000
# DEFAULT_USER_LOGIN = "user"
# DEFAULT_USER_PASSWORD = ""
# STATISTICS_SERVER = "http://reggata-stats.appspot.com"
# MAX_FILE_SIZE_FOR_FULL_HASHING = 100*1024*1024
# MAX_BYTES_FOR_PARTIAL_HASHING = 10*1024*1024
, which may contain function names, class names, or code. Output only the next line. | (FieldA >= 10) |
Based on the snippet: <|code_start|>yacc_errorlog = yacc.NullLogger()
tokens # This line is needed to supress warning that 'tokens is unused'
lexer = build_lexer()
parsetabPyDir = consts.USER_CONFIG_DIR
parser = yacc.yacc(errorlog=yacc_errorlog,
debug=(1 if consts.DEBUG else 0), # If debug yacc creates parser.out log file
tabmodule="parsetab_query",
outputdir=parsetabPyDir)
def parse(text):
'''
Returns the root node of syntax tree, constructed from text.
'''
return parser.parse(text, lexer=lexer)
if __name__ == '__main__':
##############################
# Test data
data_0 = r'''
Tag1 "Slash\\ quote\" end" and "tag 2" user : "asdf"
'''
data_1 = r'''
FieldA >= 10 FieldB~2010% and some = sdfsdf
'''
data_2 = r'''
<|code_end|>
, predict the immediate next line with the help of imports:
import ply.yacc as yacc
import reggata.parsers.query_tree_nodes as tree
from reggata.parsers.query_tokens import tokens, build_lexer
from reggata.errors import YaccError
from reggata import consts
and context (classes, functions, sometimes code) from other files:
# Path: reggata/parsers/query_tokens.py
# ALL_OPERATOR = QCoreApplication.translate("parsers", 'all', None, QCoreApplication.UnicodeUTF8)
# AND_OPERATOR = QCoreApplication.translate("parsers", 'and', None, QCoreApplication.UnicodeUTF8)
# OR_OPERATOR = QCoreApplication.translate("parsers", 'or', None, QCoreApplication.UnicodeUTF8)
# NOT_OPERATOR = QCoreApplication.translate("parsers", 'not', None, QCoreApplication.UnicodeUTF8)
# USER_KEYWORD = QCoreApplication.translate("parsers", 'user', None, QCoreApplication.UnicodeUTF8)
# PATH_KEYWORD = QCoreApplication.translate("parsers", 'path', None, QCoreApplication.UnicodeUTF8)
# TITLE_KEYWORD = QCoreApplication.translate("parsers", 'title', None, QCoreApplication.UnicodeUTF8)
# def t_STRING(t):
# def t_error(t):
# def needs_quote(string):
# def build_lexer():
#
# Path: reggata/errors.py
# class YaccError(Exception):
# def __init__(self, msg=None, cause=None):
# super(YaccError, self).__init__(msg)
# self.cause = cause
#
# Path: reggata/consts.py
# DEBUG = False
# METADATA_DIR = ".reggata"
# DB_FILE = "database.sqlite3"
# USER_CONFIG_DIR = os.path.join(os.path.expanduser("~"), ".config", "reggata")
# USER_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "reggata.conf")
# LOGGING_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "logging.conf")
# THUMBNAIL_DEFAULT_SIZE = 100
# DEFAULT_TMP_DIR = USER_CONFIG_DIR + os.sep + "tmp"
# RATING_FIELD = "Rating"
# NOTES_FIELD = "Notes"
# RESERVED_FIELDS = [RATING_FIELD, NOTES_FIELD]
# STATUSBAR_TIMEOUT = 5000
# DEFAULT_USER_LOGIN = "user"
# DEFAULT_USER_PASSWORD = ""
# STATISTICS_SERVER = "http://reggata-stats.appspot.com"
# MAX_FILE_SIZE_FOR_FULL_HASHING = 100*1024*1024
# MAX_BYTES_FOR_PARTIAL_HASHING = 10*1024*1024
. Output only the next line. | (FieldA >= 10) |
Given snippet: <|code_start|>yacc_errorlog = yacc.NullLogger()
tokens # This line is needed to supress warning that 'tokens is unused'
lexer = build_lexer()
parsetabPyDir = consts.USER_CONFIG_DIR
parser = yacc.yacc(errorlog=yacc_errorlog,
debug=(1 if consts.DEBUG else 0), # If debug yacc creates parser.out log file
tabmodule="parsetab_query",
outputdir=parsetabPyDir)
def parse(text):
'''
Returns the root node of syntax tree, constructed from text.
'''
return parser.parse(text, lexer=lexer)
if __name__ == '__main__':
##############################
# Test data
data_0 = r'''
Tag1 "Slash\\ quote\" end" and "tag 2" user : "asdf"
'''
data_1 = r'''
FieldA >= 10 FieldB~2010% and some = sdfsdf
'''
data_2 = r'''
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import ply.yacc as yacc
import reggata.parsers.query_tree_nodes as tree
from reggata.parsers.query_tokens import tokens, build_lexer
from reggata.errors import YaccError
from reggata import consts
and context:
# Path: reggata/parsers/query_tokens.py
# ALL_OPERATOR = QCoreApplication.translate("parsers", 'all', None, QCoreApplication.UnicodeUTF8)
# AND_OPERATOR = QCoreApplication.translate("parsers", 'and', None, QCoreApplication.UnicodeUTF8)
# OR_OPERATOR = QCoreApplication.translate("parsers", 'or', None, QCoreApplication.UnicodeUTF8)
# NOT_OPERATOR = QCoreApplication.translate("parsers", 'not', None, QCoreApplication.UnicodeUTF8)
# USER_KEYWORD = QCoreApplication.translate("parsers", 'user', None, QCoreApplication.UnicodeUTF8)
# PATH_KEYWORD = QCoreApplication.translate("parsers", 'path', None, QCoreApplication.UnicodeUTF8)
# TITLE_KEYWORD = QCoreApplication.translate("parsers", 'title', None, QCoreApplication.UnicodeUTF8)
# def t_STRING(t):
# def t_error(t):
# def needs_quote(string):
# def build_lexer():
#
# Path: reggata/errors.py
# class YaccError(Exception):
# def __init__(self, msg=None, cause=None):
# super(YaccError, self).__init__(msg)
# self.cause = cause
#
# Path: reggata/consts.py
# DEBUG = False
# METADATA_DIR = ".reggata"
# DB_FILE = "database.sqlite3"
# USER_CONFIG_DIR = os.path.join(os.path.expanduser("~"), ".config", "reggata")
# USER_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "reggata.conf")
# LOGGING_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "logging.conf")
# THUMBNAIL_DEFAULT_SIZE = 100
# DEFAULT_TMP_DIR = USER_CONFIG_DIR + os.sep + "tmp"
# RATING_FIELD = "Rating"
# NOTES_FIELD = "Notes"
# RESERVED_FIELDS = [RATING_FIELD, NOTES_FIELD]
# STATUSBAR_TIMEOUT = 5000
# DEFAULT_USER_LOGIN = "user"
# DEFAULT_USER_PASSWORD = ""
# STATISTICS_SERVER = "http://reggata-stats.appspot.com"
# MAX_FILE_SIZE_FOR_FULL_HASHING = 100*1024*1024
# MAX_BYTES_FOR_PARTIAL_HASHING = 10*1024*1024
which might include code, classes, or functions. Output only the next line. | (FieldA >= 10) |
Predict the next line after this snippet: <|code_start|> def test_getNonExistingItem(self):
cmd = cmds.GetExpungedItemCommand(context.nonExistingItem.id)
self.assertRaises(err.NotFoundError, self.uow.executeCommand, (cmd))
def test_passBadIdToGetItem(self):
cmd = cmds.GetExpungedItemCommand("This str is NOT a valid item id!")
self.assertRaises(err.NotFoundError, self.uow.executeCommand, (cmd))
class SaveNewItemTest(AbstractTestCaseWithRepo):
def test_saveNewMinimalItem(self):
# "Minimal item" here means that this item has no data references, tags or fields
item = db.Item("user", "Minimal Item")
try:
uow = self.repo.createUnitOfWork()
cmd = cmds.SaveNewItemCommand(item)
self.savedItemId = uow.executeCommand(cmd)
finally:
uow.close()
try:
uow = self.repo.createUnitOfWork()
savedItem = uow.executeCommand(cmds.GetExpungedItemCommand(self.savedItemId))
self.assertEqual(savedItem.title, item.title)
finally:
uow.close()
def test_saveNewItemByNonExistentUserLogin(self):
<|code_end|>
using the current file's imports:
from reggata.tests.abstract_test_cases import AbstractTestCaseWithRepoAndSingleUOW, \
AbstractTestCaseWithRepo
import reggata
import reggata.tests.tests_context as context
import reggata.data.db_schema as db
import reggata.data.commands as cmds
import reggata.errors as err
import reggata.helpers as hlp
import os
and any relevant context from other files:
# Path: reggata/tests/abstract_test_cases.py
# class AbstractTestCaseWithRepoAndSingleUOW(unittest.TestCase):
#
# def setUp(self):
# self.repoBasePath = tests_context.TEST_REPO_BASE_PATH
# self.copyOfRepoBasePath = tests_context.COPY_OF_TEST_REPO_BASE_PATH
#
# if (os.path.exists(self.copyOfRepoBasePath)):
# shutil.rmtree(self.copyOfRepoBasePath)
# shutil.copytree(self.repoBasePath, self.copyOfRepoBasePath)
#
# self.repo = RepoMgr(self.copyOfRepoBasePath)
# self.uow = self.repo.createUnitOfWork()
#
# def tearDown(self):
# self.uow.close()
# self.uow = None
# self.repo = None
# shutil.rmtree(self.copyOfRepoBasePath)
#
# class AbstractTestCaseWithRepo(unittest.TestCase):
#
# def setUp(self):
# self.repoBasePath = tests_context.TEST_REPO_BASE_PATH
# self.copyOfRepoBasePath = tests_context.COPY_OF_TEST_REPO_BASE_PATH
#
# if (os.path.exists(self.copyOfRepoBasePath)):
# shutil.rmtree(self.copyOfRepoBasePath)
# shutil.copytree(self.repoBasePath, self.copyOfRepoBasePath)
#
# self.repo = RepoMgr(self.copyOfRepoBasePath)
#
# def tearDown(self):
# self.repo = None
# shutil.rmtree(self.copyOfRepoBasePath)
#
# def getExistingItem(self, itemId):
# try:
# uow = self.repo.createUnitOfWork()
# item = uow.executeCommand(GetExpungedItemCommand(itemId))
# self.assertIsNotNone(item)
# finally:
# uow.close()
# return item
#
# def getDataRef(self, url):
# # In the case when this DataRef is a file, url should be a relative path
# try:
# uow = self.repo.createUnitOfWork()
# dataRef = uow._session.query(DataRef) \
# .filter(DataRef.url_raw==helpers.to_db_format(url)).first()
# # NOTE: dataRef could be None
# finally:
# uow.close()
# return dataRef
#
#
# def getDataRefById(self, objId):
# '''
# Returns a DataRef object with given id or None, if DataRef object not found.
# '''
# try:
# uow = self.repo.createUnitOfWork()
# dataRef = uow._session.query(DataRef).filter(DataRef.id==objId).first()
# finally:
# uow.close()
# return dataRef
#
#
# def getDataRefsFromDir(self, dirRelPath):
# dataRefs = []
# try:
# uow = self.repo.createUnitOfWork()
# dataRefs = uow._session.query(DataRef).filter(
# DataRef.url_raw.like(helpers.to_db_format(dirRelPath) + "/%")).all()
# finally:
# uow.close()
# return dataRefs
#
#
# def updateExistingItem(self, detachedItem, newSrcAbsPath, newDstRelPath, user_login):
# item = None
# try:
# uow = self.repo.createUnitOfWork()
# cmd = UpdateExistingItemCommand(detachedItem, newSrcAbsPath, newDstRelPath, user_login)
# item = uow.executeCommand(cmd)
# finally:
# uow.close()
# return item
. Output only the next line. | nonExistentUserLogin = "NonExistentUserLogin" |
Given the following code snippet before the placeholder: <|code_start|> p[0] = p[1]
def p_error(p):
raise YaccError("Syntax error in '{}'".format(str(p)))
lexer = build_lexer()
# TODO: use file for logging
#yacc_errorlog = ply.yacc.PlyLogger(open(os.path.join(USER_CONFIG_DIR, "yacc.log"), "w"))
yacc_errorlog = yacc.NullLogger()
tokens # This line is needed to supress warning that 'tokens is unused'
parsetabPyDir = consts.USER_CONFIG_DIR
parser = yacc.yacc(errorlog=yacc_errorlog,
debug=(1 if consts.DEBUG else 0), # If debug yacc creates parser.out log file
tabmodule="parsetab_def",
outputdir=parsetabPyDir)
def parse(text):
return parser.parse(text, lexer=lexer)
if __name__ == '__main__':
data = r'''
Tag1 : "Slash\\:quote\" end"
and:"tag 2" LOOK
user : "asdf"
<|code_end|>
, predict the next line using imports from the current file:
import ply.yacc as yacc
from reggata.parsers.definition_tokens import tokens, build_lexer
from reggata.errors import YaccError
from reggata import consts
and context including class names, function names, and sometimes code from other files:
# Path: reggata/parsers/definition_tokens.py
# def t_STRING(t):
# def t_error(t):
# def build_lexer():
# def needs_quote(string):
#
# Path: reggata/errors.py
# class YaccError(Exception):
# def __init__(self, msg=None, cause=None):
# super(YaccError, self).__init__(msg)
# self.cause = cause
#
# Path: reggata/consts.py
# DEBUG = False
# METADATA_DIR = ".reggata"
# DB_FILE = "database.sqlite3"
# USER_CONFIG_DIR = os.path.join(os.path.expanduser("~"), ".config", "reggata")
# USER_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "reggata.conf")
# LOGGING_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "logging.conf")
# THUMBNAIL_DEFAULT_SIZE = 100
# DEFAULT_TMP_DIR = USER_CONFIG_DIR + os.sep + "tmp"
# RATING_FIELD = "Rating"
# NOTES_FIELD = "Notes"
# RESERVED_FIELDS = [RATING_FIELD, NOTES_FIELD]
# STATUSBAR_TIMEOUT = 5000
# DEFAULT_USER_LOGIN = "user"
# DEFAULT_USER_PASSWORD = ""
# STATISTICS_SERVER = "http://reggata-stats.appspot.com"
# MAX_FILE_SIZE_FOR_FULL_HASHING = 100*1024*1024
# MAX_BYTES_FOR_PARTIAL_HASHING = 10*1024*1024
. Output only the next line. | TAG AND MORE TAGS |
Predict the next line for this snippet: <|code_start|> '''
p[0] = p[1]
def p_error(p):
raise YaccError("Syntax error in '{}'".format(str(p)))
lexer = build_lexer()
# TODO: use file for logging
#yacc_errorlog = ply.yacc.PlyLogger(open(os.path.join(USER_CONFIG_DIR, "yacc.log"), "w"))
yacc_errorlog = yacc.NullLogger()
tokens # This line is needed to supress warning that 'tokens is unused'
parsetabPyDir = consts.USER_CONFIG_DIR
parser = yacc.yacc(errorlog=yacc_errorlog,
debug=(1 if consts.DEBUG else 0), # If debug yacc creates parser.out log file
tabmodule="parsetab_def",
outputdir=parsetabPyDir)
def parse(text):
return parser.parse(text, lexer=lexer)
if __name__ == '__main__':
data = r'''
Tag1 : "Slash\\:quote\" end"
and:"tag 2" LOOK
<|code_end|>
with the help of current file imports:
import ply.yacc as yacc
from reggata.parsers.definition_tokens import tokens, build_lexer
from reggata.errors import YaccError
from reggata import consts
and context from other files:
# Path: reggata/parsers/definition_tokens.py
# def t_STRING(t):
# def t_error(t):
# def build_lexer():
# def needs_quote(string):
#
# Path: reggata/errors.py
# class YaccError(Exception):
# def __init__(self, msg=None, cause=None):
# super(YaccError, self).__init__(msg)
# self.cause = cause
#
# Path: reggata/consts.py
# DEBUG = False
# METADATA_DIR = ".reggata"
# DB_FILE = "database.sqlite3"
# USER_CONFIG_DIR = os.path.join(os.path.expanduser("~"), ".config", "reggata")
# USER_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "reggata.conf")
# LOGGING_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "logging.conf")
# THUMBNAIL_DEFAULT_SIZE = 100
# DEFAULT_TMP_DIR = USER_CONFIG_DIR + os.sep + "tmp"
# RATING_FIELD = "Rating"
# NOTES_FIELD = "Notes"
# RESERVED_FIELDS = [RATING_FIELD, NOTES_FIELD]
# STATUSBAR_TIMEOUT = 5000
# DEFAULT_USER_LOGIN = "user"
# DEFAULT_USER_PASSWORD = ""
# STATISTICS_SERVER = "http://reggata-stats.appspot.com"
# MAX_FILE_SIZE_FOR_FULL_HASHING = 100*1024*1024
# MAX_BYTES_FOR_PARTIAL_HASHING = 10*1024*1024
, which may contain function names, class names, or code. Output only the next line. | user : "asdf" |
Next line prediction: <|code_start|>def p_tag(p):
'''tag : STRING
'''
p[0] = p[1]
def p_error(p):
raise YaccError("Syntax error in '{}'".format(str(p)))
lexer = build_lexer()
# TODO: use file for logging
#yacc_errorlog = ply.yacc.PlyLogger(open(os.path.join(USER_CONFIG_DIR, "yacc.log"), "w"))
yacc_errorlog = yacc.NullLogger()
tokens # This line is needed to supress warning that 'tokens is unused'
parsetabPyDir = consts.USER_CONFIG_DIR
parser = yacc.yacc(errorlog=yacc_errorlog,
debug=(1 if consts.DEBUG else 0), # If debug yacc creates parser.out log file
tabmodule="parsetab_def",
outputdir=parsetabPyDir)
def parse(text):
return parser.parse(text, lexer=lexer)
if __name__ == '__main__':
data = r'''
<|code_end|>
. Use current file imports:
(import ply.yacc as yacc
from reggata.parsers.definition_tokens import tokens, build_lexer
from reggata.errors import YaccError
from reggata import consts)
and context including class names, function names, or small code snippets from other files:
# Path: reggata/parsers/definition_tokens.py
# def t_STRING(t):
# def t_error(t):
# def build_lexer():
# def needs_quote(string):
#
# Path: reggata/errors.py
# class YaccError(Exception):
# def __init__(self, msg=None, cause=None):
# super(YaccError, self).__init__(msg)
# self.cause = cause
#
# Path: reggata/consts.py
# DEBUG = False
# METADATA_DIR = ".reggata"
# DB_FILE = "database.sqlite3"
# USER_CONFIG_DIR = os.path.join(os.path.expanduser("~"), ".config", "reggata")
# USER_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "reggata.conf")
# LOGGING_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "logging.conf")
# THUMBNAIL_DEFAULT_SIZE = 100
# DEFAULT_TMP_DIR = USER_CONFIG_DIR + os.sep + "tmp"
# RATING_FIELD = "Rating"
# NOTES_FIELD = "Notes"
# RESERVED_FIELDS = [RATING_FIELD, NOTES_FIELD]
# STATUSBAR_TIMEOUT = 5000
# DEFAULT_USER_LOGIN = "user"
# DEFAULT_USER_PASSWORD = ""
# STATISTICS_SERVER = "http://reggata-stats.appspot.com"
# MAX_FILE_SIZE_FOR_FULL_HASHING = 100*1024*1024
# MAX_BYTES_FOR_PARTIAL_HASHING = 10*1024*1024
. Output only the next line. | Tag1 : "Slash\\:quote\" end" |
Next line prediction: <|code_start|> '''
p[0] = p[1]
def p_error(p):
raise YaccError("Syntax error in '{}'".format(str(p)))
lexer = build_lexer()
# TODO: use file for logging
#yacc_errorlog = ply.yacc.PlyLogger(open(os.path.join(USER_CONFIG_DIR, "yacc.log"), "w"))
yacc_errorlog = yacc.NullLogger()
tokens # This line is needed to supress warning that 'tokens is unused'
parsetabPyDir = consts.USER_CONFIG_DIR
parser = yacc.yacc(errorlog=yacc_errorlog,
debug=(1 if consts.DEBUG else 0), # If debug yacc creates parser.out log file
tabmodule="parsetab_def",
outputdir=parsetabPyDir)
def parse(text):
return parser.parse(text, lexer=lexer)
if __name__ == '__main__':
data = r'''
Tag1 : "Slash\\:quote\" end"
and:"tag 2" LOOK
<|code_end|>
. Use current file imports:
(import ply.yacc as yacc
from reggata.parsers.definition_tokens import tokens, build_lexer
from reggata.errors import YaccError
from reggata import consts)
and context including class names, function names, or small code snippets from other files:
# Path: reggata/parsers/definition_tokens.py
# def t_STRING(t):
# def t_error(t):
# def build_lexer():
# def needs_quote(string):
#
# Path: reggata/errors.py
# class YaccError(Exception):
# def __init__(self, msg=None, cause=None):
# super(YaccError, self).__init__(msg)
# self.cause = cause
#
# Path: reggata/consts.py
# DEBUG = False
# METADATA_DIR = ".reggata"
# DB_FILE = "database.sqlite3"
# USER_CONFIG_DIR = os.path.join(os.path.expanduser("~"), ".config", "reggata")
# USER_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "reggata.conf")
# LOGGING_CONFIG_FILE = os.path.join(USER_CONFIG_DIR, "logging.conf")
# THUMBNAIL_DEFAULT_SIZE = 100
# DEFAULT_TMP_DIR = USER_CONFIG_DIR + os.sep + "tmp"
# RATING_FIELD = "Rating"
# NOTES_FIELD = "Notes"
# RESERVED_FIELDS = [RATING_FIELD, NOTES_FIELD]
# STATUSBAR_TIMEOUT = 5000
# DEFAULT_USER_LOGIN = "user"
# DEFAULT_USER_PASSWORD = ""
# STATISTICS_SERVER = "http://reggata-stats.appspot.com"
# MAX_FILE_SIZE_FOR_FULL_HASHING = 100*1024*1024
# MAX_BYTES_FOR_PARTIAL_HASHING = 10*1024*1024
. Output only the next line. | user : "asdf" |
Given the code snippet: <|code_start|>
class Tag(QueryExpression):
'''
A syntax tree node, representing a Tag.
'''
def __init__(self, name, is_negative=False):
self.name = name
self.is_negative = is_negative
def negate(self):
self.is_negative = not self.is_negative
def interpret(self):
return self.name
def __str__(self):
return self.name
class AllItems(SimpleQuery):
'''
A query that selects all alive items from repository.
'''
def __init__(self):
super(AllItems, self).__init__()
def interpret(self):
s = '''
--AllItems.interpret()
select distinct
<|code_end|>
, generate the next line using the imports in this file:
import reggata.helpers as helpers
from reggata.data import db_schema
and context (functions, classes, or occasionally code) from other files:
# Path: reggata/data/db_schema.py
# class JsonUnsupportedVersionError(Exception):
# class User(Base):
# class HistoryRec(Base):
# class Item(Base, memento.Serializable):
# class DataRef(Base, memento.Serializable):
# class Thumbnail(Base):
# class Tag(Base):
# class Item_Tag(Base):
# class Field(Base):
# class Item_Field(Base):
# def __init__(self, msg=None, cause=None):
# def __init__(self, login=None, password=None, group=USER):
# def checkValid(self):
# def __init__(self, item_id=None, item_hash=None, data_ref_hash=None, \
# data_ref_url=None, operation=None, user_login=None, \
# parent1_id=None, parent2_id=None):
# def _get_data_ref_url(self):
# def _set_data_ref_url(self, value):
# def __eq__(self, obj):
# def __ne__(self, obj):
# def __str__(self):
# def __init__(self, user_login=None, title=None, date_created=None, alive=True):
# def __init_on_load__(self):
# def __listOfTagsAndTheirOwners(self):
# def __listOfFieldValsAndTheirOwners(self):
# def toJson(self):
# def fromJson(objState):
# def fromJsonVersion0(objState):
# def fromJsonVersionCurrent(objState):
# def hash(self):
# def getFieldValue(self, fieldName, userLogin=None):
# def hasTagsExceptOf(self, userLogin):
# def hasFieldsExceptOf(self, userLogin):
# def addTag(self, name, userLogin):
# def setFieldValue(self, name, value, userLogin):
# def format_field_vals(self):
# def format_tags(self):
# def removeTag(self, tagName):
# def removeField(self, fieldName):
# def hasTag(self, tagName):
# def hasField(self, fieldName, fieldValue=None):
# def checkValid(self):
# def hasDataRef(self):
# def __init__(self, objType=None, url=None, date_created=None):
# def __init_on_load__(self):
# def toJson(self):
# def fromJson(objState):
# def fromJsonVersion0(objState):
# def fromJsonVersionCurrent(objState):
# def _get_url(self):
# def _set_url(self, value):
# def _sql_from():
# def is_image(self):
# def __init__(self):
# def _sql_from():
# def __init__(self, name=None):
# def _sql_from():
# def __init__(self, tag=None, user_login=None):
# def _sql_from():
# def __init__(self, name=None):
# def _sql_from():
# def __init__(self, field=None, value=None, user_login=None):
# def _sql_from():
# USER = 'USER'
# ADMIN = 'ADMIN'
# CREATE = "CREATE"
# UPDATE = "UPDATE"
# DELETE = "DELETE"
# MERGE = "MERGE"
# ERROR_FILE_NOT_FOUND = 1
# ERROR_FILE_HASH_MISMATCH = 2
# CURRENT_JSON_VERSION = 1
# FILE = "FILE"
# URL = "URL" #TODO: URL type is deprecated. Do not use it anymore. User can always save an url for an item with a field
# CURRENT_JSON_VERSION = 1
. Output only the next line. | i.*, |
Continue the code snippet: <|code_start|> This slot is usually connected to the 'exception' signal, emitted from a
worker thread.
'''
self.reject()
def closeEvent(self, close_event):
close_event.ignore() # Disable close button (X) of the dialog.
def set_progress(self, percent_completed):
'''This slot is called to display progress in percents.'''
logger.debug("Completed {}%".format(percent_completed))
self.progress_bar.setValue(percent_completed)
class TextEdit(QtGui.QTextEdit):
'''Modified QTextEdit, that supports Completer class. When user presses shortcut Ctrl+Space,
it shows a completer (if such exists) that helps user to enter tag/field names.'''
def __init__(self, parent=None, completer=None, completer_end_str=" ", one_line=False):
super(TextEdit, self).__init__(parent)
self.completer = completer
self.completer_end_str = completer_end_str
self.setPlainText("")
self.one_line = one_line
if one_line:
#In this case TextEdit should emulate QLineEdit behaviour
<|code_end|>
. Use current file imports:
import os
import logging
import PyQt4.QtGui as QtGui
import PyQt4.QtCore as QtCore
import reggata.parsers as parsers
import reggata.consts as consts
from PyQt4.QtCore import Qt
from reggata.helpers import is_none_or_empty
from reggata.data.commands import GetNamesOfAllTagsAndFields
and context (classes, functions, or code) from other files:
# Path: reggata/helpers.py
# def is_none_or_empty(s):
# '''
# Returns True, if given string s is None or "" (empty string).
# If s is and instance of class different from str, function raises TypeError.
# '''
# if s is None:
# return True
# else:
# if not isinstance(s, str):
# raise TypeError("is_none_or_empty() can be applied only to str objects.")
# return True if s == "" else False
#
# Path: reggata/data/commands.py
# class GetNamesOfAllTagsAndFields(AbstractCommand):
# def _execute(self, uow):
# self._session = uow.session
# return self.__getNamesOfAllTagsAndFields()
#
# def __getNamesOfAllTagsAndFields(self):
# sql = '''
# select distinct name from tags
# UNION
# select distinct name from fields
# ORDER BY name
# '''
# try:
# return self._session.query("name").from_statement(sql).all()
# except ResourceClosedError:
# return []
. Output only the next line. | self.setWordWrapMode(QtGui.QTextOption.NoWrap) |
Next line prediction: <|code_start|>
class TextEdit(QtGui.QTextEdit):
'''Modified QTextEdit, that supports Completer class. When user presses shortcut Ctrl+Space,
it shows a completer (if such exists) that helps user to enter tag/field names.'''
def __init__(self, parent=None, completer=None, completer_end_str=" ", one_line=False):
super(TextEdit, self).__init__(parent)
self.completer = completer
self.completer_end_str = completer_end_str
self.setPlainText("")
self.one_line = one_line
if one_line:
#In this case TextEdit should emulate QLineEdit behaviour
self.setWordWrapMode(QtGui.QTextOption.NoWrap)
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setTabChangesFocus(True)
self.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Fixed)
#TODO I dont like this:
self.setFixedHeight(QtGui.QLineEdit().sizeHint().height())
def set_completer(self, completer):
self.completer = completer
<|code_end|>
. Use current file imports:
(import os
import logging
import PyQt4.QtGui as QtGui
import PyQt4.QtCore as QtCore
import reggata.parsers as parsers
import reggata.consts as consts
from PyQt4.QtCore import Qt
from reggata.helpers import is_none_or_empty
from reggata.data.commands import GetNamesOfAllTagsAndFields)
and context including class names, function names, or small code snippets from other files:
# Path: reggata/helpers.py
# def is_none_or_empty(s):
# '''
# Returns True, if given string s is None or "" (empty string).
# If s is and instance of class different from str, function raises TypeError.
# '''
# if s is None:
# return True
# else:
# if not isinstance(s, str):
# raise TypeError("is_none_or_empty() can be applied only to str objects.")
# return True if s == "" else False
#
# Path: reggata/data/commands.py
# class GetNamesOfAllTagsAndFields(AbstractCommand):
# def _execute(self, uow):
# self._session = uow.session
# return self.__getNamesOfAllTagsAndFields()
#
# def __getNamesOfAllTagsAndFields(self):
# sql = '''
# select distinct name from tags
# UNION
# select distinct name from fields
# ORDER BY name
# '''
# try:
# return self._session.query("name").from_statement(sql).all()
# except ResourceClosedError:
# return []
. Output only the next line. | def text(self): |
Given the following code snippet before the placeholder: <|code_start|>
sys.path.insert(0, os.path.abspath('../'))
# -- Project information -----------------------------------------------------
_year = datetime.datetime.now().year
project = 'pyconll'
author = 'Matias Grioni'
copyright = '{}, {}'.format(_year, author)
# The short X.Y version
_v = parse.package_version('../pyconll/_version.py').strip()
version = _v
# The full version, including alpha/beta/rc tags
release = _v
# -- General configuration ---------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
<|code_end|>
, predict the next line using imports from the current file:
import datetime
import os
import sys
from util import parse
and context including class names, function names, and sometimes code from other files:
# Path: util/parse.py
# def package_version(path: Union[str, Path]) -> str:
. Output only the next line. | 'sphinx.ext.autodoc', |
Given snippet: <|code_start|>
__author__ = 'Danyang'
class Plotter(object):
def __init__(self):
pass
def _plot(self, models, dist_metric=EuclideanDistance()):
expr = Experiment(froze_shuffle=True)
for model in models:
cv = expr.experiment(model, threshold_up=1, debug=False, dist_metric=dist_metric)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from experiment_setup import *
from expr.kernelpca_ski import KPCA
from util.commons_util.decorators.general import print_func_name
import numpy as np
and context:
# Path: expr/kernelpca_ski.py
# class KPCA(AbstractFeature):
# def __init__(self, num_components=50, kernel="poly", degree=3, coef0=0.0, gamma=None):
# AbstractFeature.__init__(self)
# self._num_components = num_components
# self._kernel = kernel
# self._degree = degree
# self._coef0 = coef0
# self._gamma = gamma
#
# self._kpca = None
#
# def compute(self, X, y):
# """
# PCA over the entire images set
# dimension reduction for entire images set
#
#
# * Prepare the data with each column representing an image.
# * Subtract the mean image from the data.
# * Calculate the eigenvectors and eigenvalues of the covariance matrix.
# * Find the optimal transformation matrix by selecting the principal components (eigenvectors with largest eigenvalues).
# * Project the centered data into the subspace.
# Reference: http://en.wikipedia.org/wiki/Eigenface#Practical_implementation
#
# :param X: The images, which is a Python list of numpy arrays.
# :param y: The corresponding labels (the unique number of the subject, person) in a Python list.
# :return:
# """
# # build the column matrix
# XC = asColumnMatrix(X)
# y = np.asarray(y)
#
# # set a valid number of components
# if self._num_components <= 0 or (self._num_components > XC.shape[1]-1):
# self._num_components = XC.shape[1]-1 # one less dimension
#
# # center dataset
# self._mean = XC.mean(axis=1).reshape(-1,1)
# XC = XC - self._mean
# n_features = XC.shape[0]
# # get the features from the given data
# # http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.KernelPCA.html
# self._kpca = KernelPCA(n_components=self._num_components,
# kernel=self._kernel,
# degree=self._degree,
# coef0=self._coef0,
# gamma=self._gamma)
#
# self._kpca.fit(XC.T)
#
# features = []
# for x in X:
# features.append(self.extract(x))
# return features
#
# def extract(self,X):
# X = np.asarray(X).reshape(-1,1)
# return self.project(X)
#
# def project(self, X):
# """
# Need to transpose to fit the dim requirement of KernelPCA
# """
# X = X - self._mean
# return self._kpca.transform(X.T)
#
# @property
# def num_components(self):
# return self._num_components
#
# def __repr__(self):
# return "KernelPCA (num_components=%d)" % self._num_components
#
# def short_name(self):
# return "KernelPCA"
#
# Path: util/commons_util/decorators/general.py
# def print_func_name(func):
# """
# print the current executing function name
# possible use:
# >>> print sys._getframe().f_code.co_name
# :param func: the function, whose result you would like to cached based on input arguments
# """
# def ret(*args):
# print func.func_name
# result = func(*args)
# return result
# return ret
which might include code, classes, or functions. Output only the next line. | expr.plot_roc(cv) |
Predict the next line for this snippet: <|code_start|>
__author__ = 'Danyang'
class Plotter(object):
def __init__(self):
pass
def _plot(self, models, dist_metric=EuclideanDistance()):
expr = Experiment(froze_shuffle=True)
for model in models:
cv = expr.experiment(model, threshold_up=1, debug=False, dist_metric=dist_metric)
expr.plot_roc(cv)
expr.show_plot()
def _simple_run(self, models, dist_metric=EuclideanDistance()):
expr = Experiment(froze_shuffle=True)
for model in models:
expr.experiment(model, threshold_up=0, debug=False, dist_metric=dist_metric)
class PlotterPCA(Plotter):
def plot_components(self):
models = []
for num_component in xrange(10, 150, 30):
models.append(PCA(num_component))
self._plot(models)
<|code_end|>
with the help of current file imports:
from experiment_setup import *
from expr.kernelpca_ski import KPCA
from util.commons_util.decorators.general import print_func_name
import numpy as np
and context from other files:
# Path: expr/kernelpca_ski.py
# class KPCA(AbstractFeature):
# def __init__(self, num_components=50, kernel="poly", degree=3, coef0=0.0, gamma=None):
# AbstractFeature.__init__(self)
# self._num_components = num_components
# self._kernel = kernel
# self._degree = degree
# self._coef0 = coef0
# self._gamma = gamma
#
# self._kpca = None
#
# def compute(self, X, y):
# """
# PCA over the entire images set
# dimension reduction for entire images set
#
#
# * Prepare the data with each column representing an image.
# * Subtract the mean image from the data.
# * Calculate the eigenvectors and eigenvalues of the covariance matrix.
# * Find the optimal transformation matrix by selecting the principal components (eigenvectors with largest eigenvalues).
# * Project the centered data into the subspace.
# Reference: http://en.wikipedia.org/wiki/Eigenface#Practical_implementation
#
# :param X: The images, which is a Python list of numpy arrays.
# :param y: The corresponding labels (the unique number of the subject, person) in a Python list.
# :return:
# """
# # build the column matrix
# XC = asColumnMatrix(X)
# y = np.asarray(y)
#
# # set a valid number of components
# if self._num_components <= 0 or (self._num_components > XC.shape[1]-1):
# self._num_components = XC.shape[1]-1 # one less dimension
#
# # center dataset
# self._mean = XC.mean(axis=1).reshape(-1,1)
# XC = XC - self._mean
# n_features = XC.shape[0]
# # get the features from the given data
# # http://scikit-learn.org/stable/modules/generated/sklearn.decomposition.KernelPCA.html
# self._kpca = KernelPCA(n_components=self._num_components,
# kernel=self._kernel,
# degree=self._degree,
# coef0=self._coef0,
# gamma=self._gamma)
#
# self._kpca.fit(XC.T)
#
# features = []
# for x in X:
# features.append(self.extract(x))
# return features
#
# def extract(self,X):
# X = np.asarray(X).reshape(-1,1)
# return self.project(X)
#
# def project(self, X):
# """
# Need to transpose to fit the dim requirement of KernelPCA
# """
# X = X - self._mean
# return self._kpca.transform(X.T)
#
# @property
# def num_components(self):
# return self._num_components
#
# def __repr__(self):
# return "KernelPCA (num_components=%d)" % self._num_components
#
# def short_name(self):
# return "KernelPCA"
#
# Path: util/commons_util/decorators/general.py
# def print_func_name(func):
# """
# print the current executing function name
# possible use:
# >>> print sys._getframe().f_code.co_name
# :param func: the function, whose result you would like to cached based on input arguments
# """
# def ret(*args):
# print func.func_name
# result = func(*args)
# return result
# return ret
, which may contain function names, class names, or code. Output only the next line. | def plot_energy(self): |
Predict the next line for this snippet: <|code_start|>
class AbstractFeature(object):
def compute(self, X, y):
raise NotImplementedError("Every AbstractFeature must implement the compute method.")
def extract(self, X):
raise NotImplementedError("Every AbstractFeature must implement the extract method.")
def save(self):
raise NotImplementedError("Not implemented yet (TODO).")
def load(self):
raise NotImplementedError("Not implemented yet (TODO).")
def __repr__(self):
return self.short_name()
def short_name(self):
<|code_end|>
with the help of current file imports:
import numpy as np
from facerec_py.facerec.util import asColumnMatrix
from facerec_py.facerec.operators import ChainOperator, CombineOperator
from facerec_py.facerec.lbp import *
and context from other files:
# Path: facerec_py/facerec/util.py
# def asColumnMatrix(X):
# """
# Creates a column-matrix from multi-dimensional data items in list X.
#
# X [list] List with multi-dimensional data.
# """
# if len(X) == 0:
# return np.array([])
# total = 1
# for i in range(0, np.ndim(X[0])):
# total = total * X[0].shape[i]
# mat = np.empty([total, 0], dtype=X[0].dtype)
# for col in X:
# mat = np.append(mat, col.reshape(-1, 1), axis=1) # same as hstack
# return np.asmatrix(mat)
#
# Path: facerec_py/facerec/operators.py
# class ChainOperator(FeatureOperator):
# """
# The ChainOperator chains two feature extraction modules:
# model2.compute(model1.compute(X,y),y)
# Where X can be generic input data.
#
# Args:
# model1 [AbstractFeature]
# model2 [AbstractFeature]
# """
#
# def __init__(self, model1, model2):
# FeatureOperator.__init__(self, model1, model2)
#
# def compute(self, X, y):
# X = self.model1.compute(X, y)
# return self.model2.compute(X, y)
#
# def extract(self, X):
# X = self.model1.extract(X)
# return self.model2.extract(X)
#
# def __repr__(self):
# return "ChainOperator(" + repr(self.model1) + "," + repr(self.model2) + ")"
#
# class CombineOperator(FeatureOperator):
# """
# The CombineOperator combines the output of two feature extraction modules as:
# (model1.compute(X,y),model2.compute(X,y))
# , where the output of each feature is a [1xN] or [Nx1] feature vector.
#
#
# Args:
# model1 [AbstractFeature]
# model2 [AbstractFeature]
#
# """
#
# def __init__(self, model1, model2):
# FeatureOperator.__init__(self, model1, model2)
#
# def compute(self, X, y):
# A = self.model1.compute(X, y)
# B = self.model2.compute(X, y)
# C = []
# for i in range(0, len(A)):
# ai = np.asarray(A[i]).reshape(1, -1)
# bi = np.asarray(B[i]).reshape(1, -1)
# C.append(np.hstack((ai, bi)))
# return C
#
# def extract(self, X):
# ai = self.model1.extract(X)
# bi = self.model2.extract(X)
# ai = np.asarray(ai).reshape(1, -1)
# bi = np.asarray(bi).reshape(1, -1)
# return np.hstack((ai, bi))
#
# def __repr__(self):
# return "CombineOperator(" + repr(self.model1) + "," + repr(self.model2) + ")"
, which may contain function names, class names, or code. Output only the next line. | return self.__class__.__name__ |
Using the snippet: <|code_start|>
__author__ = 'Danyang'
class KPCA(AbstractFeature):
def __init__(self, num_components=50, kernel="poly", degree=3, coef0=0.0, gamma=None):
AbstractFeature.__init__(self)
self._num_components = num_components
self._kernel = kernel
self._degree = degree
self._coef0 = coef0
self._gamma = gamma
<|code_end|>
, determine the next line of code. You have imports:
from facerec_py.facerec.feature import AbstractFeature
from facerec_py.facerec.util import asColumnMatrix
from sklearn.decomposition import KernelPCA
import numpy as np
and context (class names, function names, or code) available:
# Path: facerec_py/facerec/feature.py
# class AbstractFeature(object):
# def compute(self, X, y):
# raise NotImplementedError("Every AbstractFeature must implement the compute method.")
#
# def extract(self, X):
# raise NotImplementedError("Every AbstractFeature must implement the extract method.")
#
# def save(self):
# raise NotImplementedError("Not implemented yet (TODO).")
#
# def load(self):
# raise NotImplementedError("Not implemented yet (TODO).")
#
# def __repr__(self):
# return self.short_name()
#
# def short_name(self):
# return self.__class__.__name__
#
# Path: facerec_py/facerec/util.py
# def asColumnMatrix(X):
# """
# Creates a column-matrix from multi-dimensional data items in list X.
#
# X [list] List with multi-dimensional data.
# """
# if len(X) == 0:
# return np.array([])
# total = 1
# for i in range(0, np.ndim(X[0])):
# total = total * X[0].shape[i]
# mat = np.empty([total, 0], dtype=X[0].dtype)
# for col in X:
# mat = np.append(mat, col.reshape(-1, 1), axis=1) # same as hstack
# return np.asmatrix(mat)
. Output only the next line. | self._kpca = None |
Given snippet: <|code_start|>
__author__ = 'Danyang'
class KPCA(AbstractFeature):
def __init__(self, num_components=50, kernel="poly", degree=3, coef0=0.0, gamma=None):
AbstractFeature.__init__(self)
self._num_components = num_components
self._kernel = kernel
self._degree = degree
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from facerec_py.facerec.feature import AbstractFeature
from facerec_py.facerec.util import asColumnMatrix
from sklearn.decomposition import KernelPCA
import numpy as np
and context:
# Path: facerec_py/facerec/feature.py
# class AbstractFeature(object):
# def compute(self, X, y):
# raise NotImplementedError("Every AbstractFeature must implement the compute method.")
#
# def extract(self, X):
# raise NotImplementedError("Every AbstractFeature must implement the extract method.")
#
# def save(self):
# raise NotImplementedError("Not implemented yet (TODO).")
#
# def load(self):
# raise NotImplementedError("Not implemented yet (TODO).")
#
# def __repr__(self):
# return self.short_name()
#
# def short_name(self):
# return self.__class__.__name__
#
# Path: facerec_py/facerec/util.py
# def asColumnMatrix(X):
# """
# Creates a column-matrix from multi-dimensional data items in list X.
#
# X [list] List with multi-dimensional data.
# """
# if len(X) == 0:
# return np.array([])
# total = 1
# for i in range(0, np.ndim(X[0])):
# total = total * X[0].shape[i]
# mat = np.empty([total, 0], dtype=X[0].dtype)
# for col in X:
# mat = np.append(mat, col.reshape(-1, 1), axis=1) # same as hstack
# return np.asmatrix(mat)
which might include code, classes, or functions. Output only the next line. | self._coef0 = coef0 |
Predict the next line for this snippet: <|code_start|># Implements various distance metrics (because my old scipy.spatial.distance module is horrible)
class AbstractDistance(object):
def __init__(self, name):
self._name = name
def __call__(self,p,q):
<|code_end|>
with the help of current file imports:
import numpy as np
from facerec_py.facerec import normalization
and context from other files:
# Path: facerec_py/facerec/normalization.py
# def minmax(X, low, high, minX=None, maxX=None, dtype=np.float):
# def zscore(X, mean=None, std=None):
# def gaussian(X, mu, sig):
# def inverse_dissim(X):
# def vector_normalize(x):
# def gaussian_kernel(X, mu=None, sig=None):
# X = np.asarray(X)
# X = X * (high - low)
# X = X + low
# X = np.asarray(X)
# X = (X - mean) / std
# X = np.asarray(X)
# X = zscore(X)
# X = minmax(X, 0, 10)
# X = np.asarray(X)
, which may contain function names, class names, or code. Output only the next line. | raise NotImplementedError("Every AbstractDistance must implement the __call__ method.") |
Based on the snippet: <|code_start|>from __future__ import absolute_import
# TODO The evaluation of a model should be completely moved to the generic ValidationStrategy. The specific Validation
# implementations should only care about partition the data, which would make a lot sense. Currently it is not
# possible to calculate the true_negatives and false_negatives with the way the predicitions are generated and
# data is prepared.
#
# The mentioned problem makes a change in the PredictionResult necessary, which basically means refactoring the
# entire framework. The refactoring is planned, but I can't give any details as time of writing.
#
# Please be careful, when referring to the Performance Metrics at the moment, only the Precision is implemented,
# and the rest has no use at the moment. Due to the missing refactoring discussed above.
#
class TFPN(object):
def __init__(self, TP=0, FP=0, TN=0, FN=0):
self.rates = np.array([TP, FP, TN, FN], dtype=np.double)
@property
def TP(self):
return self.rates[0]
<|code_end|>
, predict the immediate next line with the help of imports:
import math as math
import random as random
import logging
import cv2
import numpy as np
from facerec_py.facerec.model import PredictableModel, AbstractPredictableModel
from util.commons_util.fundamentals.generators import frange
and context (classes, functions, sometimes code) from other files:
# Path: facerec_py/facerec/model.py
# class PredictableModel(AbstractPredictableModel):
# def __init__(self, feature, classifier):
# super(PredictableModel, self).__init__()
# if not isinstance(feature, AbstractFeature):
# raise TypeError("feature must be of type AbstractFeature!")
# if not isinstance(classifier, AbstractClassifier):
# raise TypeError("classifier must be of type AbstractClassifier!")
#
# self.feature = feature
# self.classifier = classifier
#
# def compute(self, X, y):
# features = self.feature.compute(X, y)
# self.classifier.compute(features, y)
#
# def predict(self, X):
# q = self.feature.extract(X)
# return self.classifier.predict(q)
#
# def __repr__(self):
# feature_repr = repr(self.feature)
# classifier_repr = repr(self.classifier)
# return "%s(feature=%s, classifier=%s)" % (self.__class__.__name__, feature_repr, classifier_repr)
#
# class AbstractPredictableModel(object):
# def compute(self, X, y):
# raise NotImplementedError("Every AbstractPredictableModel must implement the compute method.")
#
# def predict(self, X):
# raise NotImplementedError("Every AbstractPredictableModel must implement the predict method.")
#
# def __repr__(self):
# return self.__class__.__name__
#
# Path: util/commons_util/fundamentals/generators.py
# def frange(start, stop, step):
# return list(drange(start, stop, step))
. Output only the next line. | @TP.setter |
Using the snippet: <|code_start|>
# TODO The evaluation of a model should be completely moved to the generic ValidationStrategy. The specific Validation
# implementations should only care about partition the data, which would make a lot sense. Currently it is not
# possible to calculate the true_negatives and false_negatives with the way the predicitions are generated and
# data is prepared.
#
# The mentioned problem makes a change in the PredictionResult necessary, which basically means refactoring the
# entire framework. The refactoring is planned, but I can't give any details as time of writing.
#
# Please be careful, when referring to the Performance Metrics at the moment, only the Precision is implemented,
# and the rest has no use at the moment. Due to the missing refactoring discussed above.
#
class TFPN(object):
def __init__(self, TP=0, FP=0, TN=0, FN=0):
self.rates = np.array([TP, FP, TN, FN], dtype=np.double)
@property
def TP(self):
return self.rates[0]
@TP.setter
def TP(self, value):
self.rates[0] = value
@property
def FP(self):
<|code_end|>
, determine the next line of code. You have imports:
import math as math
import random as random
import logging
import cv2
import numpy as np
from facerec_py.facerec.model import PredictableModel, AbstractPredictableModel
from util.commons_util.fundamentals.generators import frange
and context (class names, function names, or code) available:
# Path: facerec_py/facerec/model.py
# class PredictableModel(AbstractPredictableModel):
# def __init__(self, feature, classifier):
# super(PredictableModel, self).__init__()
# if not isinstance(feature, AbstractFeature):
# raise TypeError("feature must be of type AbstractFeature!")
# if not isinstance(classifier, AbstractClassifier):
# raise TypeError("classifier must be of type AbstractClassifier!")
#
# self.feature = feature
# self.classifier = classifier
#
# def compute(self, X, y):
# features = self.feature.compute(X, y)
# self.classifier.compute(features, y)
#
# def predict(self, X):
# q = self.feature.extract(X)
# return self.classifier.predict(q)
#
# def __repr__(self):
# feature_repr = repr(self.feature)
# classifier_repr = repr(self.classifier)
# return "%s(feature=%s, classifier=%s)" % (self.__class__.__name__, feature_repr, classifier_repr)
#
# class AbstractPredictableModel(object):
# def compute(self, X, y):
# raise NotImplementedError("Every AbstractPredictableModel must implement the compute method.")
#
# def predict(self, X):
# raise NotImplementedError("Every AbstractPredictableModel must implement the predict method.")
#
# def __repr__(self):
# return self.__class__.__name__
#
# Path: util/commons_util/fundamentals/generators.py
# def frange(start, stop, step):
# return list(drange(start, stop, step))
. Output only the next line. | return self.rates[1] |
Predict the next line after this snippet: <|code_start|>
class AbstractClassifier(object):
def compute(self, X, y):
raise NotImplementedError("Every AbstractClassifier must implement the compute method.")
def predict(self, X):
<|code_end|>
using the current file's imports:
from facerec_py.facerec.distance import EuclideanDistance
from facerec_py.facerec.normalization import gaussian_kernel, inverse_dissim
from facerec_py.facerec.util import asRowMatrix
from svmutil import *
from StringIO import StringIO
from svmutil import *
import logging
import numpy as np
import operator as op
import sys
and any relevant context from other files:
# Path: facerec_py/facerec/distance.py
# class EuclideanDistance(AbstractDistance):
# def __init__(self):
# AbstractDistance.__init__(self, "EuclideanDistance")
#
# def __call__(self, p, q):
# p = np.asarray(p).flatten()
# q = np.asarray(q).flatten()
# return np.sqrt(np.sum(np.power(p-q, 2)))
#
# Path: facerec_py/facerec/normalization.py
# def gaussian_kernel(X, mu=None, sig=None):
# """
# gaussian kernel.
# convert distance to similarity by setting mu=0
# :param X:
# :param mu:
# :param sig:
# :return:
# """
# X = np.asarray(X)
# if mu is None:
# mu = X.mean()
# if sig is None:
# sig = X.std()
#
# return np.exp(-np.power(X-mu, 2)/(2*sig**2))
#
# def inverse_dissim(X):
# """
#
# :param X: int or np.array
# :return:
# """
# X = np.asarray(X)
# X = zscore(X)
# X = minmax(X, 0, 10)
# return 1./(1+X)
#
# Path: facerec_py/facerec/util.py
# def asRowMatrix(X):
# """
# Creates a row-matrix from multi-dimensional data items in list l.
#
# X [list] List with multi-dimensional data.
# """
# if len(X) == 0:
# return np.array([])
# total = 1
# for i in range(0, np.ndim(X[0])):
# total = total * X[0].shape[i]
# mat = np.empty([0, total], dtype=X[0].dtype)
# for row in X:
# mat = np.append(mat, row.reshape(1, -1), axis=0) # same as vstack
# return np.asmatrix(mat)
. Output only the next line. | raise NotImplementedError("Every AbstractClassifier must implement the predict method.") |
Based on the snippet: <|code_start|>
class AbstractClassifier(object):
def compute(self, X, y):
raise NotImplementedError("Every AbstractClassifier must implement the compute method.")
<|code_end|>
, predict the immediate next line with the help of imports:
from facerec_py.facerec.distance import EuclideanDistance
from facerec_py.facerec.normalization import gaussian_kernel, inverse_dissim
from facerec_py.facerec.util import asRowMatrix
from svmutil import *
from StringIO import StringIO
from svmutil import *
import logging
import numpy as np
import operator as op
import sys
and context (classes, functions, sometimes code) from other files:
# Path: facerec_py/facerec/distance.py
# class EuclideanDistance(AbstractDistance):
# def __init__(self):
# AbstractDistance.__init__(self, "EuclideanDistance")
#
# def __call__(self, p, q):
# p = np.asarray(p).flatten()
# q = np.asarray(q).flatten()
# return np.sqrt(np.sum(np.power(p-q, 2)))
#
# Path: facerec_py/facerec/normalization.py
# def gaussian_kernel(X, mu=None, sig=None):
# """
# gaussian kernel.
# convert distance to similarity by setting mu=0
# :param X:
# :param mu:
# :param sig:
# :return:
# """
# X = np.asarray(X)
# if mu is None:
# mu = X.mean()
# if sig is None:
# sig = X.std()
#
# return np.exp(-np.power(X-mu, 2)/(2*sig**2))
#
# def inverse_dissim(X):
# """
#
# :param X: int or np.array
# :return:
# """
# X = np.asarray(X)
# X = zscore(X)
# X = minmax(X, 0, 10)
# return 1./(1+X)
#
# Path: facerec_py/facerec/util.py
# def asRowMatrix(X):
# """
# Creates a row-matrix from multi-dimensional data items in list l.
#
# X [list] List with multi-dimensional data.
# """
# if len(X) == 0:
# return np.array([])
# total = 1
# for i in range(0, np.ndim(X[0])):
# total = total * X[0].shape[i]
# mat = np.empty([0, total], dtype=X[0].dtype)
# for row in X:
# mat = np.append(mat, row.reshape(1, -1), axis=0) # same as vstack
# return np.asmatrix(mat)
. Output only the next line. | def predict(self, X): |
Given the following code snippet before the placeholder: <|code_start|>
# try to import the PIL Image module
try:
except ImportError:
def create_font(fontname='Tahoma', fontsize=10):
return { 'fontname': fontname, 'fontsize':fontsize }
def plot_gray(X, sz=None, filename=None):
if not sz is None:
X = X.reshape(sz)
X = minmax(I, 0, 255)
fig = plt.figure()
implot = plt.imshow(np.asarray(Ig), cmap=cm.gray)
if filename is None:
plt.show()
else:
fig.savefig(filename, format="png", transparent=False)
<|code_end|>
, predict the next line using imports from the current file:
from facerec_py.facerec.normalization import minmax
from PIL import Image
import os as os
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm
import Image
import math as math
and context including class names, function names, and sometimes code from other files:
# Path: facerec_py/facerec/normalization.py
# def minmax(X, low, high, minX=None, maxX=None, dtype=np.float):
# X = np.asarray(X)
# if minX is None:
# minX = np.min(X)
# if maxX is None:
# maxX = np.max(X)
# # normalize to [0...1].
# X -= float(minX)
# X /= float((maxX - minX))
# # scale to [low...high].
# X = X * (high - low)
# X = X + low
# return np.asarray(X, dtype=dtype)
. Output only the next line. | def plot_eigenvectors(eigenvectors, num_components, sz, filename=None, start_component=0, rows = None, cols = None, title="Subplot", color=True): |
Next line prediction: <|code_start|>class AbstractPredictableModel(object):
def compute(self, X, y):
raise NotImplementedError("Every AbstractPredictableModel must implement the compute method.")
def predict(self, X):
raise NotImplementedError("Every AbstractPredictableModel must implement the predict method.")
def __repr__(self):
return self.__class__.__name__
class PredictableModel(AbstractPredictableModel):
def __init__(self, feature, classifier):
super(PredictableModel, self).__init__()
if not isinstance(feature, AbstractFeature):
raise TypeError("feature must be of type AbstractFeature!")
if not isinstance(classifier, AbstractClassifier):
raise TypeError("classifier must be of type AbstractClassifier!")
self.feature = feature
self.classifier = classifier
def compute(self, X, y):
features = self.feature.compute(X, y)
self.classifier.compute(features, y)
def predict(self, X):
q = self.feature.extract(X)
return self.classifier.predict(q)
<|code_end|>
. Use current file imports:
(import copy
import collections
from facerec_py.facerec.feature import AbstractFeature
from facerec_py.facerec.classifier import AbstractClassifier)
and context including class names, function names, or small code snippets from other files:
# Path: facerec_py/facerec/feature.py
# class AbstractFeature(object):
# def compute(self, X, y):
# raise NotImplementedError("Every AbstractFeature must implement the compute method.")
#
# def extract(self, X):
# raise NotImplementedError("Every AbstractFeature must implement the extract method.")
#
# def save(self):
# raise NotImplementedError("Not implemented yet (TODO).")
#
# def load(self):
# raise NotImplementedError("Not implemented yet (TODO).")
#
# def __repr__(self):
# return self.short_name()
#
# def short_name(self):
# return self.__class__.__name__
#
# Path: facerec_py/facerec/classifier.py
# class AbstractClassifier(object):
# def compute(self, X, y):
# raise NotImplementedError("Every AbstractClassifier must implement the compute method.")
#
# def predict(self, X):
# raise NotImplementedError("Every AbstractClassifier must implement the predict method.")
#
# def update(self, X, y):
# raise NotImplementedError("This Classifier is cannot be updated.")
#
# def binary_predict(self, q, lbl):
# """
#
# :param q: feature
# :param lbl: the specified class label
# :return conf: confidence interval [0, 1]
# :raise NotImplementedError:
# """
# raise NotImplementedError("The binary prediction is not implemented")
. Output only the next line. | def __repr__(self): |
Given the following code snippet before the placeholder: <|code_start|> return self.classifier.predict(q)
def __repr__(self):
feature_repr = repr(self.feature)
classifier_repr = repr(self.classifier)
return "%s(feature=%s, classifier=%s)" % (self.__class__.__name__, feature_repr, classifier_repr)
class FeaturesEnsemblePredictableModel(AbstractPredictableModel):
def __init__(self, features, classifier):
super(FeaturesEnsemblePredictableModel, self).__init__()
for feature in features:
if not isinstance(feature, AbstractFeature):
raise TypeError("feature must be of type AbstractFeature!")
if not isinstance(classifier, AbstractClassifier):
raise TypeError("classifier must be of type AbstractClassifier!")
self.features = features
self.classifiers = [copy.deepcopy(classifier) for _ in features]
def compute(self, X, y):
for i in xrange(len(self.features)):
feats = self.features[i].compute(X, y)
self.classifiers[i].compute(feats, y)
def predict(self, X):
qs = [feature.extract(X) for feature in self.features]
ps = [self.classifiers[i].predict(qs[i]) for i in xrange(len(qs))]
# majority voting
dic = collections.defaultdict(int)
<|code_end|>
, predict the next line using imports from the current file:
import copy
import collections
from facerec_py.facerec.feature import AbstractFeature
from facerec_py.facerec.classifier import AbstractClassifier
and context including class names, function names, and sometimes code from other files:
# Path: facerec_py/facerec/feature.py
# class AbstractFeature(object):
# def compute(self, X, y):
# raise NotImplementedError("Every AbstractFeature must implement the compute method.")
#
# def extract(self, X):
# raise NotImplementedError("Every AbstractFeature must implement the extract method.")
#
# def save(self):
# raise NotImplementedError("Not implemented yet (TODO).")
#
# def load(self):
# raise NotImplementedError("Not implemented yet (TODO).")
#
# def __repr__(self):
# return self.short_name()
#
# def short_name(self):
# return self.__class__.__name__
#
# Path: facerec_py/facerec/classifier.py
# class AbstractClassifier(object):
# def compute(self, X, y):
# raise NotImplementedError("Every AbstractClassifier must implement the compute method.")
#
# def predict(self, X):
# raise NotImplementedError("Every AbstractClassifier must implement the predict method.")
#
# def update(self, X, y):
# raise NotImplementedError("This Classifier is cannot be updated.")
#
# def binary_predict(self, q, lbl):
# """
#
# :param q: feature
# :param lbl: the specified class label
# :return conf: confidence interval [0, 1]
# :raise NotImplementedError:
# """
# raise NotImplementedError("The binary prediction is not implemented")
. Output only the next line. | for elt in ps: |
Predict the next line for this snippet: <|code_start|>
# Fixtures
@pytest.fixture
def path(tmpdir):
path = tmpdir.mkdir('reports').join('report.csv').strpath
return text_type(path)
@pytest.fixture
def report_writer(path):
return reports.ReportWriter(path)
@pytest.fixture
def tsv_writer(path):
return reports.TSVWriter(path)
@pytest.fixture
def ical_writer(path):
return reports.ICALWriter(path)
@pytest.fixture
def xml_writer(path):
return reports.XMLWriter(path)
# Tests
<|code_end|>
with the help of current file imports:
import csv
import datetime
import os.path
import xml
import pytest
from hamster_lib import reports
from icalendar import Calendar
from six import text_type
and context from other files:
# Path: hamster_lib/reports.py
# class ReportWriter(object):
# class TSVWriter(ReportWriter):
# class ICALWriter(ReportWriter):
# class XMLWriter(ReportWriter):
# def __init__(self, path, datetime_format="%Y-%m-%d %H:%M:%S"):
# def write_report(self, facts):
# def _fact_to_tuple(self, fact):
# def _write_fact(self, fact):
# def _close(self):
# def __init__(self, path):
# def _fact_to_tuple(self, fact):
# def _write_fact(self, fact_tuple):
# def __init__(self, path, datetime_format="%Y-%m-%d %H:%M:%S"):
# def _fact_to_tuple(self, fact):
# def _write_fact(self, fact_tuple):
# def _close(self):
# def __init__(self, path, datetime_format="%Y-%m-%d %H:%M:%S"):
# def _fact_to_tuple(self, fact):
# def _write_fact(self, fact_tuple):
# def _close(self):
, which may contain function names, class names, or code. Output only the next line. | class TestReportWriter(object): |
Based on the snippet: <|code_start|> config['day_start'] = day_start
assert time_helpers.end_day_to_datetime(end_day, config) == expectation
class TestParseTime(object):
@pytest.mark.parametrize(('time', 'expectation'), [
('18:55', datetime.time(18, 55)),
('18:55:34', datetime.time(18, 55, 34)),
('2014-12-10', datetime.date(2014, 12, 10)),
('2015-10-02 18:12', datetime.datetime(2015, 10, 2, 18, 12)),
('2015-10-02 18:12:33', datetime.datetime(2015, 10, 2, 18, 12, 33)),
])
def test_various_times(self, time, expectation):
"""Make sure that given times are parsed as expected."""
assert time_helpers.parse_time(time) == expectation
@pytest.mark.parametrize('time', ['18 55', '18:555', '2014 01 04 12:30'])
def test_various_invalid_times(self, time):
"""Ensure that invalid times throw an exception."""
with pytest.raises(ValueError):
time_helpers.parse_time(time)
class TestValidateStartEndRange(object):
"Unittests for validation function."""
@pytest.mark.parametrize('range', (
(datetime.datetime(2016, 12, 1, 12, 30), datetime.datetime(2016, 12, 1, 12, 45)),
(datetime.datetime(2016, 1, 1, 12, 30), datetime.datetime(2016, 12, 1, 12, 45)),
(datetime.datetime(2016, 1, 1, 12, 30), datetime.datetime(2016, 12, 1, 1, 45)),
<|code_end|>
, predict the immediate next line with the help of imports:
import datetime
import pytest
from freezegun import freeze_time
from hamster_lib.helpers import time as time_helpers
from hamster_lib.helpers.time import TimeFrame
and context (classes, functions, sometimes code) from other files:
# Path: hamster_lib/helpers/time.py
# def get_day_end(config):
# def end_day_to_datetime(end_day, config):
# def extract_time_info(text):
# def get_time(time, seconds=None):
# def get_date(date):
# def date_time_from_groupdict(groupdict):
# def complete_timeframe(timeframe, config, partial=False):
# def complete_start_date(date):
# def complete_start_time(time, day_start):
# def complete_start(date, time, config):
# def complete_end_date(date):
# def complete_end(date, time, config):
# def parse_time(time):
# def validate_start_end_range(range_tuple):
#
# Path: hamster_lib/helpers/time.py
# def get_day_end(config):
# def end_day_to_datetime(end_day, config):
# def extract_time_info(text):
# def get_time(time, seconds=None):
# def get_date(date):
# def date_time_from_groupdict(groupdict):
# def complete_timeframe(timeframe, config, partial=False):
# def complete_start_date(date):
# def complete_start_time(time, day_start):
# def complete_start(date, time, config):
# def complete_end_date(date):
# def complete_end(date, time, config):
# def parse_time(time):
# def validate_start_end_range(range_tuple):
. Output only the next line. | )) |
Predict the next line for this snippet: <|code_start|># -*- encoding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
class TestGetDayEnd(object):
@pytest.mark.parametrize(('day_start', 'expectation'), [
(datetime.time(0, 0, 0), datetime.time(23, 59, 59)),
(datetime.time(5, 30, 0), datetime.time(5, 29, 59)),
(datetime.time(23, 59, 59), datetime.time(23, 59, 58)),
(datetime.time(14, 44, 23), datetime.time(14, 44, 22)),
])
<|code_end|>
with the help of current file imports:
import datetime
import pytest
from freezegun import freeze_time
from hamster_lib.helpers import time as time_helpers
from hamster_lib.helpers.time import TimeFrame
and context from other files:
# Path: hamster_lib/helpers/time.py
# def get_day_end(config):
# def end_day_to_datetime(end_day, config):
# def extract_time_info(text):
# def get_time(time, seconds=None):
# def get_date(date):
# def date_time_from_groupdict(groupdict):
# def complete_timeframe(timeframe, config, partial=False):
# def complete_start_date(date):
# def complete_start_time(time, day_start):
# def complete_start(date, time, config):
# def complete_end_date(date):
# def complete_end(date, time, config):
# def parse_time(time):
# def validate_start_end_range(range_tuple):
#
# Path: hamster_lib/helpers/time.py
# def get_day_end(config):
# def end_day_to_datetime(end_day, config):
# def extract_time_info(text):
# def get_time(time, seconds=None):
# def get_date(date):
# def date_time_from_groupdict(groupdict):
# def complete_timeframe(timeframe, config, partial=False):
# def complete_start_date(date):
# def complete_start_time(time, day_start):
# def complete_start(date, time, config):
# def complete_end_date(date):
# def complete_end(date, time, config):
# def parse_time(time):
# def validate_start_end_range(range_tuple):
, which may contain function names, class names, or code. Output only the next line. | def test_various_day_start_times(self, base_config, day_start, expectation): |
Given snippet: <|code_start|>from __future__ import annotations
_TEnum = TypeVar('_TEnum', bound=Enum)
class _FlavourKeyedEnum(Protocol[_TEnum]):
retail: _TEnum
vanilla_classic: _TEnum
burning_crusade_classic: _TEnum
def __getitem__(self, __key: str) -> _TEnum:
...
class Flavour(StrEnum):
# The latest Classic version is always aliased to "classic".
# The logic here is that should Classic not be discontinued
# it will continue to be updated in place so that new Classic versions
# will inherit the "_classic_" folder. This means we won't have to
# migrate Classic profiles either automatically or by requiring user
# intervention for new Classic releases.
retail = 'retail'
vanilla_classic = 'vanilla_classic'
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from enum import Enum
from typing import TypeVar
from typing_extensions import Protocol
from .utils import StrEnum
and context:
# Path: src/instawow/utils.py
# class StrEnum(str, enum.Enum):
# pass
which might include code, classes, or functions. Output only the next line. | burning_crusade_classic = 'classic' |
Given the code snippet: <|code_start|>def _encode_reveal_secret_str(value: object):
if isinstance(value, BaseModel):
return value.dict()
elif isinstance(value, SecretStr):
return value.get_secret_value()
raise TypeError('Unencodable value', value)
class GlobalConfig(_BaseSettings):
config_dir: Path = Field(default_factory=lambda: Path(click.get_app_dir('instawow')))
temp_dir: Path = Field(default_factory=lambda: Path(gettempdir(), 'instawow'))
auto_update_check: bool = True
access_tokens: _AccessTokens = _AccessTokens()
@validator('config_dir', 'temp_dir')
def _expand_path(cls, value: Path) -> Path:
return _expand_path(value)
def list_profiles(self) -> list[str]:
"Get the names of the profiles contained in ``config_dir``."
profiles = [c.parent.name for c in self.config_dir.glob('profiles/*/config.json')]
return profiles
@classmethod
def read(cls) -> GlobalConfig:
dummy_config = cls()
maybe_config_values = _read_config(dummy_config, missing_ok=True)
return cls(**maybe_config_values) if maybe_config_values is not None else dummy_config
def ensure_dirs(self) -> GlobalConfig:
<|code_end|>
, generate the next line using the imports in this file:
from collections.abc import Iterable, Set
from pathlib import Path, PurePath
from tempfile import gettempdir
from typing import Any
from loguru import logger
from pydantic import BaseModel, BaseSettings, Field, PydanticValueError, SecretStr, validator
from pydantic.env_settings import SettingsSourceCallable
from .common import Flavour
from .utils import trash
from types import SimpleNamespace
import json
import os
import sys
import typing
import click
import queue
import threading
import loguru._handler
import logging
and context (functions, classes, or occasionally code) from other files:
# Path: src/instawow/common.py
# class Flavour(StrEnum):
# # The latest Classic version is always aliased to "classic".
# # The logic here is that should Classic not be discontinued
# # it will continue to be updated in place so that new Classic versions
# # will inherit the "_classic_" folder. This means we won't have to
# # migrate Classic profiles either automatically or by requiring user
# # intervention for new Classic releases.
# retail = 'retail'
# vanilla_classic = 'vanilla_classic'
# burning_crusade_classic = 'classic'
#
# @classmethod
# def from_flavour_keyed_enum(cls, enum: Enum) -> Flavour:
# return cls[enum.name]
#
# @classmethod
# def to_flavour_keyed_enum(cls, enum: _FlavourKeyedEnum[_TEnum], flavour: Flavour) -> _TEnum:
# return enum[flavour.name]
#
# Path: src/instawow/utils.py
# def trash(paths: Sequence[PurePath], *, dest: PurePath, missing_ok: bool = False) -> None:
# if not paths:
# return
#
# parent_folder = mkdtemp(dir=dest, prefix=f'deleted-{paths[0].name}-')
# for path in paths:
# try:
# move(path, dest=parent_folder)
# except (FileNotFoundError if missing_ok else ()):
# pass
. Output only the next line. | _ensure_dirs( |
Next line prediction: <|code_start|>from __future__ import annotations
class _PathNotWritableDirectoryError(PydanticValueError):
code = 'path.not_writable_directory'
msg_template = '"{path}" is not a writable directory'
def _expand_path(value: Path):
return Path(os.path.abspath(os.path.expanduser(value)))
def _is_writable_dir(value: Path):
return value.is_dir() and os.access(value, os.W_OK)
def _ensure_dirs(dirs: Iterable[Path]):
for dir_ in dirs:
dir_.mkdir(exist_ok=True, parents=True)
def _write_config(config: _BaseSettings, fields: Set[str], **kwargs: object):
json_output = config.json(include=fields, indent=2, **kwargs)
config.config_file.write_text(json_output, encoding='utf-8')
def _read_config(config: _BaseSettings, missing_ok: bool = False):
<|code_end|>
. Use current file imports:
(from collections.abc import Iterable, Set
from pathlib import Path, PurePath
from tempfile import gettempdir
from typing import Any
from loguru import logger
from pydantic import BaseModel, BaseSettings, Field, PydanticValueError, SecretStr, validator
from pydantic.env_settings import SettingsSourceCallable
from .common import Flavour
from .utils import trash
from types import SimpleNamespace
import json
import os
import sys
import typing
import click
import queue
import threading
import loguru._handler
import logging)
and context including class names, function names, or small code snippets from other files:
# Path: src/instawow/common.py
# class Flavour(StrEnum):
# # The latest Classic version is always aliased to "classic".
# # The logic here is that should Classic not be discontinued
# # it will continue to be updated in place so that new Classic versions
# # will inherit the "_classic_" folder. This means we won't have to
# # migrate Classic profiles either automatically or by requiring user
# # intervention for new Classic releases.
# retail = 'retail'
# vanilla_classic = 'vanilla_classic'
# burning_crusade_classic = 'classic'
#
# @classmethod
# def from_flavour_keyed_enum(cls, enum: Enum) -> Flavour:
# return cls[enum.name]
#
# @classmethod
# def to_flavour_keyed_enum(cls, enum: _FlavourKeyedEnum[_TEnum], flavour: Flavour) -> _TEnum:
# return enum[flavour.name]
#
# Path: src/instawow/utils.py
# def trash(paths: Sequence[PurePath], *, dest: PurePath, missing_ok: bool = False) -> None:
# if not paths:
# return
#
# parent_folder = mkdtemp(dir=dest, prefix=f'deleted-{paths[0].name}-')
# for path in paths:
# try:
# move(path, dest=parent_folder)
# except (FileNotFoundError if missing_ok else ()):
# pass
. Output only the next line. | try: |
Using the snippet: <|code_start|> if devStoreKey is None:
if self.request.get('key') != 'kiosk':
logging.error("failed to validate the request parameters")
self.response.headers['Content-Type'] = 'application/javascript'
self.response.out.write(json.dumps(api_utils.buildErrorResponse('-1','Illegal request parameters')))
return
# snare the inputs
stopID = api_utils.conformStopID(self.request.get('stopID'))
routeID = api_utils.conformRouteID(self.request.get('routeID'))
destination = self.request.get('destination')
logging.debug('getstops request parameters... routeID %s destination %s' % (routeID,destination))
if api_utils.afterHours() is True:
# don't run these jobs during "off" hours
json_response = api_utils.buildErrorResponse('-1','The Metro service is not currently running')
elif routeID is not '' and destination is '':
json_response = routeRequest(routeID, None)
api_utils.recordDeveloperRequest(devStoreKey,api_utils.GETSTOPS,self.request.query_string,self.request.remote_addr);
elif routeID is not '' and destination is not '':
json_response = routeRequest(routeID, destination)
api_utils.recordDeveloperRequest(devStoreKey,api_utils.GETSTOPS,self.request.query_string,self.request.remote_addr);
else:
logging.error("API: invalid request")
json_response = api_utils.buildErrorResponse('-1','Invalid Request parameters. Did you forget to include a routeID?')
api_utils.recordDeveloperRequest(devStoreKey,api_utils.GETSTOPS,self.request.query_string,self.request.remote_addr,'illegal query string combination');
#logging.debug('API: json response %s' % json_response);
# encapsulate response in json
callback = self.request.get('callback')
<|code_end|>
, determine the next line of code. You have imports:
import os
import wsgiref.handlers
import logging
import webapp2 as webapp
import json
from data_model import StopLocation
from utils.geo import geotypes
from api.v1 import api_utils
from stats_and_maps.stats import stathat
from google.appengine.api import memcache
from google.appengine.ext import db
from google.appengine.ext.webapp.util import run_wsgi_app
from google.appengine.api.labs.taskqueue import Task
and context (class names, function names, or code) available:
# Path: data_model.py
# class StopLocation(GeoModel):
# stopID = db.StringProperty()
# intersection = db.StringProperty()
# direction = db.StringProperty()
# description = db.StringProperty(multiline=True)
#
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
. Output only the next line. | if callback is not '': |
Given the code snippet: <|code_start|> # validate the key
devStoreKey = api_utils.validateDevKey(request.get('key'))
if devStoreKey is None:
logging.debug('... illegal developer key %s' % request.get('key'))
api_utils.recordDeveloperRequest(None,api_utils.GETSTOPS,request.query_string,request.remote_addr,'illegal developer key specified');
return None
if type == api_utils.GETSTOPS:
routeID = api_utils.conformRouteID(request.get('routeID'))
destination = request.get('destination').upper()
# a routeID is required
if routeID is None or routeID is '':
api_utils.recordDeveloperRequest(devStoreKey,type,request.query_string,request.remote_addr,'a routeID must be included');
return None
elif destination is not None and routeID is '':
api_utils.recordDeveloperRequest(devStoreKey,type,request.query_string,request.remote_addr,'if a destination is specified, a routeID must be included');
return None
elif type == api_utils.GETSTOPLOCATION:
stopID = api_utils.conformStopID(request.get('stopID'))
if stopID == '' or stopID == '0' or stopID == '00':
return None
elif type == api_utils.GETNEARBYSTOPS:
lat = request.get('lat')
lon = request.get('lon')
radius = request.get('radius')
# lat/long is required
if lat is None or lon is None:
api_utils.recordDeveloperRequest(devStoreKey,type,request.query_string,request.remote_addr,'both latitude and longitude values must be specified');
return None
<|code_end|>
, generate the next line using the imports in this file:
import os
import wsgiref.handlers
import logging
import webapp2 as webapp
import json
from data_model import StopLocation
from utils.geo import geotypes
from api.v1 import api_utils
from stats_and_maps.stats import stathat
from google.appengine.api import memcache
from google.appengine.ext import db
from google.appengine.ext.webapp.util import run_wsgi_app
from google.appengine.api.labs.taskqueue import Task
and context (functions, classes, or occasionally code) from other files:
# Path: data_model.py
# class StopLocation(GeoModel):
# stopID = db.StringProperty()
# intersection = db.StringProperty()
# direction = db.StringProperty()
# description = db.StringProperty(multiline=True)
#
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
. Output only the next line. | elif radius is not None and radius is not '' and radius > '5000': |
Next line prediction: <|code_start|> stop = memcache.get(key)
if stop is None:
logging.warn('stopLocation cache MISS - going to the datastore (%s)' % stopID)
stop = db.GqlQuery('select * from StopLocation where stopID = :1', stopID).get()
if stop is None:
logging.error('stopLocationRequest :: unable to locate stop %s in the datastore!?' % stopID)
response_dict = {'status':'0',
'info':('Stop %s not found' % stopID)
}
return response_dict
else:
#logging.debug('shoving stop %s entity into memcache' % stopID)
memcache.set(key,stop)
return {'status':'0',
'stopID':stopID,
'intersection':stop.intersection,
'latitude':stop.location.lat,
'longitude':stop.location.lon,
}
## end stopLocationRequest()
def validateRequest(request,type):
# validate the key
devStoreKey = api_utils.validateDevKey(request.get('key'))
if devStoreKey is None:
logging.debug('... illegal developer key %s' % request.get('key'))
api_utils.recordDeveloperRequest(None,api_utils.GETSTOPS,request.query_string,request.remote_addr,'illegal developer key specified');
<|code_end|>
. Use current file imports:
(import os
import wsgiref.handlers
import logging
import webapp2 as webapp
import json
from data_model import StopLocation
from utils.geo import geotypes
from api.v1 import api_utils
from stats_and_maps.stats import stathat
from google.appengine.api import memcache
from google.appengine.ext import db
from google.appengine.ext.webapp.util import run_wsgi_app
from google.appengine.api.labs.taskqueue import Task)
and context including class names, function names, or small code snippets from other files:
# Path: data_model.py
# class StopLocation(GeoModel):
# stopID = db.StringProperty()
# intersection = db.StringProperty()
# direction = db.StringProperty()
# description = db.StringProperty(multiline=True)
#
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
. Output only the next line. | return None |
Next line prediction: <|code_start|> else:
self.response.headers['Content-Type'] = 'application/json'
response = json.dumps(json_response)
stathat.apiStatCount()
self.response.out.write(response)
## end RequestHandler
def getLots(soup, response, class_name):
results = []
for lot in soup.html.body.findAll("div",{"class":class_name}):
#logging.debug('lot... %s' % lot);
#logging.debug('lot.div.a ... %s' % lot.div.a.string)
for detail in lot:
if detail.string is not None and detail.string.isdigit():
#logging.debug('DIGIT %s' % detail.string)
lot_spots = detail.string
lot_details = {
'name' : lot.div.a.string,
'open_spots' : lot_spots
}
response.append(lot_details)
## end
def getParkingSpecialEvents():
loop = 0
done = False
<|code_end|>
. Use current file imports:
(import logging
import time
import datetime
import webapp2 as webapp
import json
from google.appengine.api import memcache
from google.appengine.api import urlfetch
from google.appengine.ext.webapp.util import run_wsgi_app
from api.v1 import api_utils
from stats_and_maps.stats import stathat)
and context including class names, function names, or small code snippets from other files:
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
. Output only the next line. | result = None |
Given snippet: <|code_start|>
class MainHandler(webapp.RequestHandler):
# POST not support by the API
def post(self):
self.response.headers['Content-Type'] = 'application/javascript'
self.response.out.write(json.dumps(api_utils.buildErrorResponse('-1','The API does not support POST requests')))
return
def get(self):
events = {}
loop = 0
done = False
result = None
while not done and loop < 3:
try:
result = urlfetch.fetch('http://www.cityofmadison.com/parkingUtility/garagesLots/availability/')
done = True;
except urlfetch.DownloadError:
logging.error("Error loading page (%s)... sleeping" % loop)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import logging
import time
import datetime
import webapp2 as webapp
import json
from google.appengine.api import memcache
from google.appengine.api import urlfetch
from google.appengine.ext.webapp.util import run_wsgi_app
from api.v1 import api_utils
from stats_and_maps.stats import stathat
and context:
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
which might include code, classes, or functions. Output only the next line. | if result: |
Based on the snippet: <|code_start|> self.response.out.write(response)
except DeadlineExceededError:
self.response.clear()
self.response.set_status(500)
self.response.out.write("This operation could not be completed in time...")
# persist some statistics
# stathat:
#if api_utils.afterHours() is False and dev_key != 'uwkiosk9':
#stathat.apiTimeStat(config.STATHAT_API_GETARRIVALS_TIME_KEY,((time.time()-start)*1000))
#stathat.apiStatCount()
# disabling stats
# if( "kiosk" not in dev_key and "willycoop" not in dev_key ):
# task = Task(url='/stats/stop', params={'apikey':dev_key,'stop':stopID})
# task.add('stats')
## end RequestHandler
def validateRequest(request):
# validate the key
devStoreKey = api_utils.validateDevKey(request.get('key'))
if devStoreKey is None:
#api_utils.recordDeveloperRequest(None,api_utils.GETARRIVALS,request.query_string,request.remote_addr,'illegal developer key specified');
return None
stopID = api_utils.conformStopID(request.get('stopID'))
routeID = api_utils.conformRouteID(request.get('routeID'))
vehicleID = request.get('vehicleID')
<|code_end|>
, predict the immediate next line with the help of imports:
import logging
import time
import webapp2 as webapp
import json
from google.appengine.api import memcache
from google.appengine.ext.webapp.util import run_wsgi_app
from google.appengine.api.labs.taskqueue import Task
from google.appengine.runtime import DeadlineExceededError
from api.v1 import api_utils
from api import asynch
from stats_and_maps.stats import stathat
and context (classes, functions, sometimes code) from other files:
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: api/asynch.py
# def email_missing_stop(stopID, routeID, sid):
# def aggregateBusesAsynch(sid, stopID, routeID=None):
# def handle_result(rpc,stopID,routeID,sid,directionID):
# def insert_result(sid,stop):
# def create_callback(rpc,stopID,routeID,sid,directionID):
# def getRouteListing(stopID=None,routeID=None):
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
. Output only the next line. | logging.debug('validating stopID %s routeID %s' % (stopID,routeID)); |
Based on the snippet: <|code_start|> dev_key = self.request.get('key')
stopID = api_utils.conformStopID(self.request.get('stopID'))
routeID = api_utils.conformRouteID(self.request.get('routeID'))
vehicleID = self.request.get('vehicleID')
logging.debug('getarrivals request parameters... stopID %s routeID %s vehicleID %s' % (stopID,routeID,vehicleID))
self.request.registry['aggregated_results'] = []
try:
if api_utils.afterHours() is False: # and dev_key != 'uwkiosk9':
# validate the request parameters
devStoreKey = validateRequest(self.request)
if devStoreKey is None:
# filter out the kiosk errors from the log
if dev_key != 'kiosk' :
logging.error("failed to validate the request parameters")
self.response.headers['Content-Type'] = 'application/javascript'
self.response.out.write(json.dumps(api_utils.buildErrorResponse('-1','Unable to validate the request. There may be an illegal developer key.')))
return
if stopID is not '' and routeID is '':
json_response = stopRequest(stopID, dev_key)
#api_utils.recordDeveloperRequest(devStoreKey,api_utils.GETARRIVALS,self.request.query_string,self.request.remote_addr);
elif stopID is not '' and routeID is not '':
json_response = stopRouteRequest(stopID, routeID, devStoreKey)
#api_utils.recordDeveloperRequest(devStoreKey,api_utils.GETARRIVALS,self.request.query_string,self.request.remote_addr);
elif routeID is not '' and vehicleID is not '':
json_response = routeVehicleRequest(routeID, vehicleID, devStoreKey)
#api_utils.recordDeveloperRequest(devStoreKey,api_utils.GETVEHICLE,self.request.query_string,self.request.remote_addr);
<|code_end|>
, predict the immediate next line with the help of imports:
import logging
import time
import webapp2 as webapp
import json
from google.appengine.api import memcache
from google.appengine.ext.webapp.util import run_wsgi_app
from google.appengine.api.labs.taskqueue import Task
from google.appengine.runtime import DeadlineExceededError
from api.v1 import api_utils
from api import asynch
from stats_and_maps.stats import stathat
and context (classes, functions, sometimes code) from other files:
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: api/asynch.py
# def email_missing_stop(stopID, routeID, sid):
# def aggregateBusesAsynch(sid, stopID, routeID=None):
# def handle_result(rpc,stopID,routeID,sid,directionID):
# def insert_result(sid,stop):
# def create_callback(rpc,stopID,routeID,sid,directionID):
# def getRouteListing(stopID=None,routeID=None):
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
. Output only the next line. | else: |
Given the code snippet: <|code_start|>
GETARRIVALS = "get arrivals"
GETVEHICLES = "get vehicles"
GETSTOPS = "get stops"
GETROUTES = "get routes"
GETNEARBYSTOPS = "get nearby stops"
GETSTOPLOCATION = "get stop location"
def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# this is too damn expensive to store all of these on app engine
# so we're going to ignore these requests
if False:
req = DeveloperRequest()
req.developer = devKey
req.type = type
req.error = error
req.requestTerms = terms
req.remoteAddr = ipaddr
req.put()
## end recordDeveloperRequest()
def serialize_entities(models):
if models is None:
return None
elif isinstance(models, db.Model):
# Just one instance
<|code_end|>
, generate the next line using the imports in this file:
import logging
import re
import datetime
import json
from pytz.gae import pytz
from google.appengine.api import memcache
from google.appengine.ext import db
from google.appengine.datastore import entity_pb
from data_model import DeveloperRequest
and context (functions, classes, or occasionally code) from other files:
# Path: data_model.py
# class DeveloperRequest(db.Model):
# developer = db.ReferenceProperty()
# date = db.DateTimeProperty(auto_now_add=True)
# type = db.StringProperty()
# error = db.StringProperty()
# requestTerms = db.StringProperty()
# remoteAddr = db.StringProperty()
. Output only the next line. | return db.model_to_protobuf(models).Encode() |
Predict the next line after this snippet: <|code_start|>
# review the results for popular stops
reqs = getRequestedStops();
stops_stats = []
keyLookup = []
totalReqs = 0
for key,value in reqs.items():
stops_stats.append({'stopID':key,
'count':value,
})
totalReqs += value
keyLookup.append(key+':loc')
# do we have the stop locations?
stopLocations = memcache.get_multi(keyLookup) #reqs.keys())
if stopLocations is None or len(stopLocations) == 0:
logging.error("unable to find stop locations!?")
# create an event to go get this data
task = Task(url='/labs/maptask', params={'clean':'1',})
task.add('crawler')
msg = "no data"
else:
logging.debug('yes... found cached copies of the stop locations!')
msg = "your data"
locations = []
median = 2.5
logging.debug('found a total of %s requests with a median %s' % (str(totalReqs),str(median)))
for key,value in stopLocations.items():
if value is None:
<|code_end|>
using the current file's imports:
import os
import wsgiref.handlers
import logging
from operator import itemgetter
from google.appengine.api import memcache
from google.appengine.ext import webapp
from google.appengine.ext import db
from google.appengine.ext.db import GeoPt
from google.appengine.ext.webapp import template
from google.appengine.api.labs.taskqueue import Task
from google.appengine.runtime import apiproxy_errors
from data_model import PhoneLog
from data_model import StopLocation
from data_model import RouteListing
and any relevant context from other files:
# Path: data_model.py
# class StopLocation(GeoModel):
# class StopLocationLoader(db.Model):
# class RouteListing(db.Model):
# class RouteListingLoader(db.Model):
# class DestinationListing(db.Model):
# class DeveloperKeys(db.Model):
# class DeveloperRequest(db.Model):
# class ParseErrors(db.Model):
# class BusStopAggregation(db.Model):
# class StopStat(db.Model):
#
# Path: data_model.py
# class StopLocation(GeoModel):
# stopID = db.StringProperty()
# intersection = db.StringProperty()
# direction = db.StringProperty()
# description = db.StringProperty(multiline=True)
#
# Path: data_model.py
# class RouteListing(db.Model):
# route = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
# scheduleURL = db.StringProperty(indexed=False)
# stopLocation = db.ReferenceProperty(StopLocation,collection_name="stops")
. Output only the next line. | continue; |
Based on the snippet: <|code_start|> for r in routes:
logging.debug('updating route %s with new location' % r.route)
r.stopLocation = stop
r.put()
self.redirect('https://smsmybus.com/labs/displaystops')
## end FixStop
class CollectorHandler(webapp.RequestHandler):
def post(self):
self.get()
def get(self):
# do some analysis on the request history...
reqs = getRequestedStops()
# find that lat/longs for all the stops
validStops = reqs.keys()
stopLocs = memcache.get_multi(validStops)
if self.request.get('clean') or stopLocs is None:
memcache.delete_multi(validStops)
logging.debug("logging stop locations!")
locations = dict()
cursor = None
# Start a query for all stop locations
q = StopLocation.all()
while q is not None:
# If the app stored a cursor during a previous request, use it.
if cursor:
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import wsgiref.handlers
import logging
from operator import itemgetter
from google.appengine.api import memcache
from google.appengine.ext import webapp
from google.appengine.ext import db
from google.appengine.ext.db import GeoPt
from google.appengine.ext.webapp import template
from google.appengine.api.labs.taskqueue import Task
from google.appengine.runtime import apiproxy_errors
from data_model import PhoneLog
from data_model import StopLocation
from data_model import RouteListing
and context (classes, functions, sometimes code) from other files:
# Path: data_model.py
# class StopLocation(GeoModel):
# class StopLocationLoader(db.Model):
# class RouteListing(db.Model):
# class RouteListingLoader(db.Model):
# class DestinationListing(db.Model):
# class DeveloperKeys(db.Model):
# class DeveloperRequest(db.Model):
# class ParseErrors(db.Model):
# class BusStopAggregation(db.Model):
# class StopStat(db.Model):
#
# Path: data_model.py
# class StopLocation(GeoModel):
# stopID = db.StringProperty()
# intersection = db.StringProperty()
# direction = db.StringProperty()
# description = db.StringProperty(multiline=True)
#
# Path: data_model.py
# class RouteListing(db.Model):
# route = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
# scheduleURL = db.StringProperty(indexed=False)
# stopLocation = db.ReferenceProperty(StopLocation,collection_name="stops")
. Output only the next line. | q.with_cursor(cursor) |
Next line prediction: <|code_start|> stops = StopLocationLoader.all()
for s in stops:
# create a new task for each stop
task = Task(url='/gtfs/port/stop/task/',
params={'stopID':s.stopID,
'name':s.name,
'description':s.description,
'lat':str(s.lat),
'lon':str(s.lon),
'direction':s.direction,
})
task.add('crawler')
logging.debug('Finished spawning StopLocationLoader tasks!')
self.response.out.write('done spawning porting tasks!')
## end PortStopsHandler
#
# This handler is the task handler for porting an individual GTFS stop
#
class PortStopTask(webapp.RequestHandler):
def post(self):
stop_list = []
stopID = self.request.get('stopID')
if len(stopID) == 1:
stopID = "000" + stopID
if len(stopID) == 2:
stopID = "00" + stopID
<|code_end|>
. Use current file imports:
(import logging
from google.appengine.api.taskqueue import Task
from google.appengine.ext import webapp
from google.appengine.ext import db
from google.appengine.ext.db import GeoPt
from google.appengine.ext.db import TransactionFailedError
from google.appengine.ext.db import Timeout
from google.appengine.runtime import DeadlineExceededError
from data_model import StopLocation
from data_model import StopLocationLoader
from data_model import RouteListing
from data_model import RouteListingLoader
from data_model import DestinationListing)
and context including class names, function names, or small code snippets from other files:
# Path: data_model.py
# class StopLocation(GeoModel):
# stopID = db.StringProperty()
# intersection = db.StringProperty()
# direction = db.StringProperty()
# description = db.StringProperty(multiline=True)
#
# Path: data_model.py
# class StopLocationLoader(db.Model):
# stopID = db.StringProperty()
# name = db.StringProperty()
# description = db.StringProperty(multiline=True)
# lat = db.FloatProperty()
# lon = db.FloatProperty()
# direction = db.StringProperty()
#
# Path: data_model.py
# class RouteListing(db.Model):
# route = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
# scheduleURL = db.StringProperty(indexed=False)
# stopLocation = db.ReferenceProperty(StopLocation,collection_name="stops")
#
# Path: data_model.py
# class RouteListingLoader(db.Model):
# routeID = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# directionCode = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
#
# Path: data_model.py
# class DestinationListing(db.Model):
# id = db.StringProperty()
# label = db.StringProperty()
. Output only the next line. | if len(stopID) == 3: |
Predict the next line after this snippet: <|code_start|> lat = self.request.get('lat')
lon = self.request.get('lon')
direction = self.request.get('direction')
s = StopLocation()
s.stopID = stopID
s.intersection = name.split('(')[0].rstrip()
s.direction = direction
s.description = description
s.location = GeoPt(lat,lon)
s.update_location()
stop_list.append(s)
# put the new stop in the datastore
db.put(stop_list)
logging.info('done updating stop locations for stopID %s' % stopID)
self.response.set_status(200)
## end PortStopTask
application = webapp.WSGIApplication([('/gtfs/port/stops', PortStopsHandler),
('/gtfs/port/stop/task/', PortStopTask),
('/gtfs/port/routes', RouteTransformationStart),
('/gtfs/port/routes/task', RouteTransformationTask),
('/gtfs/port/routes/transform/task', RouteTransformationChildTask)
],
debug=True)
<|code_end|>
using the current file's imports:
import logging
from google.appengine.api.taskqueue import Task
from google.appengine.ext import webapp
from google.appengine.ext import db
from google.appengine.ext.db import GeoPt
from google.appengine.ext.db import TransactionFailedError
from google.appengine.ext.db import Timeout
from google.appengine.runtime import DeadlineExceededError
from data_model import StopLocation
from data_model import StopLocationLoader
from data_model import RouteListing
from data_model import RouteListingLoader
from data_model import DestinationListing
and any relevant context from other files:
# Path: data_model.py
# class StopLocation(GeoModel):
# stopID = db.StringProperty()
# intersection = db.StringProperty()
# direction = db.StringProperty()
# description = db.StringProperty(multiline=True)
#
# Path: data_model.py
# class StopLocationLoader(db.Model):
# stopID = db.StringProperty()
# name = db.StringProperty()
# description = db.StringProperty(multiline=True)
# lat = db.FloatProperty()
# lon = db.FloatProperty()
# direction = db.StringProperty()
#
# Path: data_model.py
# class RouteListing(db.Model):
# route = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
# scheduleURL = db.StringProperty(indexed=False)
# stopLocation = db.ReferenceProperty(StopLocation,collection_name="stops")
#
# Path: data_model.py
# class RouteListingLoader(db.Model):
# routeID = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# directionCode = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
#
# Path: data_model.py
# class DestinationListing(db.Model):
# id = db.StringProperty()
# label = db.StringProperty()
. Output only the next line. | def main(): |
Predict the next line after this snippet: <|code_start|> lon = self.request.get('lon')
direction = self.request.get('direction')
s = StopLocation()
s.stopID = stopID
s.intersection = name.split('(')[0].rstrip()
s.direction = direction
s.description = description
s.location = GeoPt(lat,lon)
s.update_location()
stop_list.append(s)
# put the new stop in the datastore
db.put(stop_list)
logging.info('done updating stop locations for stopID %s' % stopID)
self.response.set_status(200)
## end PortStopTask
application = webapp.WSGIApplication([('/gtfs/port/stops', PortStopsHandler),
('/gtfs/port/stop/task/', PortStopTask),
('/gtfs/port/routes', RouteTransformationStart),
('/gtfs/port/routes/task', RouteTransformationTask),
('/gtfs/port/routes/transform/task', RouteTransformationChildTask)
],
debug=True)
def main():
<|code_end|>
using the current file's imports:
import logging
from google.appengine.api.taskqueue import Task
from google.appengine.ext import webapp
from google.appengine.ext import db
from google.appengine.ext.db import GeoPt
from google.appengine.ext.db import TransactionFailedError
from google.appengine.ext.db import Timeout
from google.appengine.runtime import DeadlineExceededError
from data_model import StopLocation
from data_model import StopLocationLoader
from data_model import RouteListing
from data_model import RouteListingLoader
from data_model import DestinationListing
and any relevant context from other files:
# Path: data_model.py
# class StopLocation(GeoModel):
# stopID = db.StringProperty()
# intersection = db.StringProperty()
# direction = db.StringProperty()
# description = db.StringProperty(multiline=True)
#
# Path: data_model.py
# class StopLocationLoader(db.Model):
# stopID = db.StringProperty()
# name = db.StringProperty()
# description = db.StringProperty(multiline=True)
# lat = db.FloatProperty()
# lon = db.FloatProperty()
# direction = db.StringProperty()
#
# Path: data_model.py
# class RouteListing(db.Model):
# route = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
# scheduleURL = db.StringProperty(indexed=False)
# stopLocation = db.ReferenceProperty(StopLocation,collection_name="stops")
#
# Path: data_model.py
# class RouteListingLoader(db.Model):
# routeID = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# directionCode = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
#
# Path: data_model.py
# class DestinationListing(db.Model):
# id = db.StringProperty()
# label = db.StringProperty()
. Output only the next line. | logging.getLogger().setLevel(logging.DEBUG) |
Next line prediction: <|code_start|># into routes and destinations
#
# note that order matters. the Stop transformation has to happen first.
#
class RouteTransformationStart(webapp.RequestHandler):
def get(self) :
# shove a task in the queue because we need more time then
# we may be able to get in the browser
for route in range(1, 100):
task = Task(url="/gtfs/port/routes/task",params={'route':route})
task.add('crawler')
self.response.out.write('done. spawned a task to go do the route transformations')
## end RouteTransformationStart
class RouteTransformationTask(webapp.RequestHandler):
def post(self):
try:
routeID = self.request.get('route')
if len(routeID) == 1:
routeID = '0' + routeID
q = RouteListingLoader.all()
q.filter("routeID = ", routeID)
for r in q.run(keys_only=True):
logging.debug('launch key query %s', r)
task = Task(url="/gtfs/port/routes/transform/task",params={'rll_key':r})
task.add('crawler')
self.response.set_status(200)
<|code_end|>
. Use current file imports:
(import logging
from google.appengine.api.taskqueue import Task
from google.appengine.ext import webapp
from google.appengine.ext import db
from google.appengine.ext.db import GeoPt
from google.appengine.ext.db import TransactionFailedError
from google.appengine.ext.db import Timeout
from google.appengine.runtime import DeadlineExceededError
from data_model import StopLocation
from data_model import StopLocationLoader
from data_model import RouteListing
from data_model import RouteListingLoader
from data_model import DestinationListing)
and context including class names, function names, or small code snippets from other files:
# Path: data_model.py
# class StopLocation(GeoModel):
# stopID = db.StringProperty()
# intersection = db.StringProperty()
# direction = db.StringProperty()
# description = db.StringProperty(multiline=True)
#
# Path: data_model.py
# class StopLocationLoader(db.Model):
# stopID = db.StringProperty()
# name = db.StringProperty()
# description = db.StringProperty(multiline=True)
# lat = db.FloatProperty()
# lon = db.FloatProperty()
# direction = db.StringProperty()
#
# Path: data_model.py
# class RouteListing(db.Model):
# route = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
# scheduleURL = db.StringProperty(indexed=False)
# stopLocation = db.ReferenceProperty(StopLocation,collection_name="stops")
#
# Path: data_model.py
# class RouteListingLoader(db.Model):
# routeID = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# directionCode = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
#
# Path: data_model.py
# class DestinationListing(db.Model):
# id = db.StringProperty()
# label = db.StringProperty()
. Output only the next line. | except Timeout: |
Continue the code snippet: <|code_start|> for s in stops:
# create a new task for each stop
task = Task(url='/gtfs/port/stop/task/',
params={'stopID':s.stopID,
'name':s.name,
'description':s.description,
'lat':str(s.lat),
'lon':str(s.lon),
'direction':s.direction,
})
task.add('crawler')
logging.debug('Finished spawning StopLocationLoader tasks!')
self.response.out.write('done spawning porting tasks!')
## end PortStopsHandler
#
# This handler is the task handler for porting an individual GTFS stop
#
class PortStopTask(webapp.RequestHandler):
def post(self):
stop_list = []
stopID = self.request.get('stopID')
if len(stopID) == 1:
stopID = "000" + stopID
if len(stopID) == 2:
stopID = "00" + stopID
if len(stopID) == 3:
<|code_end|>
. Use current file imports:
import logging
from google.appengine.api.taskqueue import Task
from google.appengine.ext import webapp
from google.appengine.ext import db
from google.appengine.ext.db import GeoPt
from google.appengine.ext.db import TransactionFailedError
from google.appengine.ext.db import Timeout
from google.appengine.runtime import DeadlineExceededError
from data_model import StopLocation
from data_model import StopLocationLoader
from data_model import RouteListing
from data_model import RouteListingLoader
from data_model import DestinationListing
and context (classes, functions, or code) from other files:
# Path: data_model.py
# class StopLocation(GeoModel):
# stopID = db.StringProperty()
# intersection = db.StringProperty()
# direction = db.StringProperty()
# description = db.StringProperty(multiline=True)
#
# Path: data_model.py
# class StopLocationLoader(db.Model):
# stopID = db.StringProperty()
# name = db.StringProperty()
# description = db.StringProperty(multiline=True)
# lat = db.FloatProperty()
# lon = db.FloatProperty()
# direction = db.StringProperty()
#
# Path: data_model.py
# class RouteListing(db.Model):
# route = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
# scheduleURL = db.StringProperty(indexed=False)
# stopLocation = db.ReferenceProperty(StopLocation,collection_name="stops")
#
# Path: data_model.py
# class RouteListingLoader(db.Model):
# routeID = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# directionCode = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
#
# Path: data_model.py
# class DestinationListing(db.Model):
# id = db.StringProperty()
# label = db.StringProperty()
. Output only the next line. | stopID = "0" + stopID |
Next line prediction: <|code_start|> method='POST'
)
return({'status':'async'})
def http_post(self, path, data):
pdata = urllib.urlencode(data)
req = urllib2.Request(self.URL_BASE + path, pdata)
resp = urllib2.urlopen(req)
return resp.read()
def post_value(self, user_key, stat_key, value, callback=None):
if( callback is None ):
return self.http_post_async('/v', {'key': stat_key, 'ukey': user_key, 'value': value})
else:
return self.http_post('/v', {'key': stat_key, 'ukey': user_key, 'value': value})
def post_count(self, user_key, stat_key, count, callback=None):
if( callback is None ):
return self.http_post('/c', {'key': stat_key, 'ukey': user_key, 'count': count})
else:
return self.http_post_async('/c', {'key': stat_key, 'ukey': user_key, 'count': count})
def ez_post_value(self, ezkey, stat_name, value):
return self.http_post('/ez', {'ezkey': ezkey, 'stat': stat_name, 'value': value})
def ez_post_count(self, ezkey, stat_name, count):
return self.http_post('/ez', {'ezkey': ezkey, 'stat': stat_name, 'count': count})
def apiStatCount():
<|code_end|>
. Use current file imports:
(import logging
import urllib
import urllib2
import webapp2 as webapp
import config
from google.appengine.api import urlfetch
from google.appengine.api.labs.taskqueue import Task
from google.appengine.api import memcache
from data_model import StopStat)
and context including class names, function names, or small code snippets from other files:
# Path: data_model.py
# class StopStat(db.Model):
# dateAdded = db.DateTimeProperty(auto_now_add=True)
# stopID = db.StringProperty()
# apiKey = db.StringProperty()
. Output only the next line. | memcache.incr(STATHAT_MEMCACHE_REQ_COUNT, 1, None, 0) |
Given the following code snippet before the placeholder: <|code_start|>
def validateDevKey(devKey):
if devKey is None:
return None
else:
devKey = devKey.lower()
storeKey = memcache.get(devKey)
<|code_end|>
, predict the next line using imports from the current file:
import logging
import re
import datetime
from pytz.gae import pytz
from google.appengine.api import memcache
from google.appengine.ext import db
from google.appengine.datastore import entity_pb
from data_model import DeveloperRequest
and context including class names, function names, and sometimes code from other files:
# Path: data_model.py
# class DeveloperRequest(db.Model):
# developer = db.ReferenceProperty()
# date = db.DateTimeProperty(auto_now_add=True)
# type = db.StringProperty()
# error = db.StringProperty()
# requestTerms = db.StringProperty()
# remoteAddr = db.StringProperty()
. Output only the next line. | if storeKey is None: |
Next line prediction: <|code_start|> self.assertEqual(response.content_type, 'application/json')
data = response.json['lots']
hit = False
for lot in data:
if len(lot['specialEvents']) > 0:
hit = True
self.assertTrue(hit)
def test_parking_valid_uw_special_event(self):
response = self.testapp.get('/parking/v2/lots?expand=specialevents')
self.assertEqual(response.status_int, 200)
self.assertEqual(response.content_type, 'application/json')
data = response.json['lots']
hitRecord = False
for lot in data:
if len(lot['specialEvents']) > 0 and lot['operatedBy'] == 'uw':
hitRecord = lot
break
thedatetime = datetime.datetime.strptime(hitRecord['specialEvents'][0]['eventDatetime'],'%Y-%m-%dT%H:%M:%S')
self.assertIsInstance(thedatetime,datetime.datetime)
def test_parking_valid_city_special_event(self):
response = self.testapp.get('/parking/v2/lots?expand=specialevents')
self.assertEqual(response.status_int, 200)
self.assertEqual(response.content_type, 'application/json')
data = response.json['lots']
hitRecord = False
for lot in data:
if len(lot['specialEvents']) > 0 and lot['operatedBy'] == 'city':
<|code_end|>
. Use current file imports:
(import sys
import os
import webapp2
import webtest
import unittest
import datetime
from google.appengine.ext import testbed
from api.v2.parking.parking import ParkingHandler)
and context including class names, function names, or small code snippets from other files:
# Path: api/v2/parking/parking.py
# class ParkingHandler(webapp.RequestHandler):
# def post(self):
# self.response.headers['Content-Type'] = 'application/javascript'
# self.response.headers['Allow'] = 'GET'
# self.response.status = 405 # method not allowed
# self.response.out.write(
# json.dumps(
# api_utils.buildErrorResponse('-1', 'The API does not support POST requests')
# )
# )
#
# def get(self):
# lot_results = {'lots': []}
# city_lots = []
# campus_lots = []
# include_special_events = False
#
# # always include these headers
# self.response.headers['Content-Type'] = 'application/javascript'
# self.response.headers['Allow'] = 'GET'
#
# if self.request.get('expand') == 'specialevents':
# include_special_events = True
#
# logging.info(include_special_events)
# logging.info(city_lots)
#
# try:
# city_lots = CityParkingService().get_data(include_special_events)
# logging.debug('API: city_lots json response %s' % city_lots)
#
# except (ValueError, urlfetch.DownloadError, AttributeError) as e:
# logging.error('Failed to retrieve city data', str(e))
# self.response.status = 500
# self.response.out.write(
# json.dumps(
# api_utils.buildErrorResponse('-1',
# 'There was a problem retrieving the city parking data')
# )
# )
#
# try:
# campus_lots = CampusParkingService().get_data(include_special_events)
# logging.debug('API: campus lots added, json response %s' % campus_lots)
# except (ValueError, urlfetch.DownloadError, AttributeError) as e:
# logging.error('Failed to retrieve campus data', str(e))
# self.response.status = 500
# self.response.out.write(
# json.dumps(
# api_utils.buildErrorResponse('-1',
# 'There was a problem retrieving the campus parking data')
# )
# )
#
# lot_results['lots'] = city_lots + campus_lots
#
# # encapsulate response in json or jsonp
# callback = self.request.get('callback')
# if callback is not '':
# self.response.headers['Content-Type'] = 'application/javascript'
# self.response.headers['Access-Control-Allow-Origin'] = '*'
# self.response.headers['Access-Control-Allow-Methods'] = 'GET'
# response_payload = callback + '(' + json.dumps(lot_results) + ');'
# else:
# self.response.headers['Content-Type'] = 'application/json'
# response_payload = json.dumps(lot_results)
#
# stathat.apiStatCount()
# self.response.out.write(response_payload)
. Output only the next line. | hitRecord = lot |
Given the following code snippet before the placeholder: <|code_start|> msg_body += dk.developerName + '(%s) : ' % dk.developerKey
msg_body += str(dk.requestCounter)
msg_body += '\n'
# post counter to google doc
updateField(dk.developerKey,dk.requestCounter)
# reset the daily counter
if dk.requestCounter > 0:
dk.requestCounter = 0
devkeys_to_save.append(dk)
# save the modified developer keys
if len(devkeys_to_save) > 0:
db.put(devkeys_to_save)
## end
class GDocHandler(webapp.RequestHandler):
def get(self):
devkeys = db.GqlQuery("SELECT * FROM DeveloperKeys").fetch(100)
for dk in devkeys:
logging.debug('updating gdoc for %s with %s' % (dk.developerKey,str(dk.requestCounter)))
updateField(dk.developerKey,dk.requestCounter)
## end
class ResetChannelsHandler(webapp.RequestHandler):
def get(self):
now = datetime.now()
<|code_end|>
, predict the next line using imports from the current file:
import os
import wsgiref.handlers
import logging
import webapp2 as webapp
import json
import gdata.docs.service
import gdata.spreadsheet.service
import gdata.spreadsheet.text_db
import config
from operator import itemgetter
from datetime import datetime
from datetime import date
from datetime import timedelta
from google.appengine.api import channel
from google.appengine.api import mail
from google.appengine.api import memcache
from google.appengine.api import users
from google.appengine.api.labs.taskqueue import Task
from google.appengine.ext import db
from google.appengine.ext.webapp.util import run_wsgi_app
from google.appengine.ext.webapp import template
from google.appengine.runtime import apiproxy_errors
from data_model import DeveloperKeys
and context including class names, function names, and sometimes code from other files:
# Path: data_model.py
# class DeveloperKeys(db.Model):
# dateAdded = db.DateTimeProperty(auto_now_add=True)
# developerName = db.StringProperty()
# developerKey = db.StringProperty()
# developerEmail = db.EmailProperty()
# requestCounter = db.IntegerProperty()
# errorCounter = db.IntegerProperty()
. Output only the next line. | channels = json.loads(memcache.get('channels') or '{}') |
Given the code snippet: <|code_start|>
class MainHandler(webapp.RequestHandler):
def get(self):
# validate the request parameters
devStoreKey = validateRequest(self.request)
if devStoreKey is None:
logging.debug("unable to validate the request parameters")
self.response.headers['Content-Type'] = 'application/javascript'
self.response.out.write(json.dumps(api_utils.buildErrorResponse('-1','Illegal request parameters')))
<|code_end|>
, generate the next line using the imports in this file:
import logging
import re
import webapp2 as webapp
import json
import urllib
from google.appengine.api import urlfetch
from google.appengine.ext.webapp.util import run_wsgi_app
from api import asynch
from api.v1 import api_utils
from stats_and_maps.stats import stathat
and context (functions, classes, or occasionally code) from other files:
# Path: api/asynch.py
# def email_missing_stop(stopID, routeID, sid):
# def aggregateBusesAsynch(sid, stopID, routeID=None):
# def handle_result(rpc,stopID,routeID,sid,directionID):
# def insert_result(sid,stop):
# def create_callback(rpc,stopID,routeID,sid,directionID):
# def getRouteListing(stopID=None,routeID=None):
#
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
. Output only the next line. | return |
Predict the next line after this snippet: <|code_start|> json_response = routeRequest(routeID)
api_utils.recordDeveloperRequest(devStoreKey, api_utils.GETVEHICLES, self.request.query_string, self.request.remote_addr);
else:
logging.error("API: invalid request")
json_response = api_utils.buildErrorResponse('-1','Invalid Request parameters. Did you forget to include a routeID?')
api_utils.recordDeveloperRequest(devStoreKey, api_utils.GETVEHICLES, self.request.query_string, self.request.remote_addr,'illegal query string combination');
#logging.debug('API: json response %s' % json_response);
# encapsulate response in json
callback = self.request.get('callback')
if callback is not '':
self.response.headers['Content-Type'] = 'application/javascript'
self.response.headers['Access-Control-Allow-Origin'] = '*'
self.response.headers['Access-Control-Allow-Methods'] = 'GET'
response = callback + '(' + json.dumps(json_response) + ');'
else:
self.response.headers['Content-Type'] = 'application/json'
response = json.dumps(json_response)
self.response.out.write(response)
stathat.apiStatCount()
def post(self):
self.response.headers['Content-Type'] = 'application/javascript'
self.response.out.write(json.dumps(api_utils.buildErrorResponse('-1','The API does not support POST requests')))
return
## end MainHandler
VEHICLE_URL_BASE = "http://webwatch.cityofmadison.com/TMWebWatch/GoogleMap.aspx/getVehicles"
<|code_end|>
using the current file's imports:
import logging
import re
import webapp2 as webapp
import json
import urllib
from google.appengine.api import urlfetch
from google.appengine.ext.webapp.util import run_wsgi_app
from api import asynch
from api.v1 import api_utils
from stats_and_maps.stats import stathat
and any relevant context from other files:
# Path: api/asynch.py
# def email_missing_stop(stopID, routeID, sid):
# def aggregateBusesAsynch(sid, stopID, routeID=None):
# def handle_result(rpc,stopID,routeID,sid,directionID):
# def insert_result(sid,stop):
# def create_callback(rpc,stopID,routeID,sid,directionID):
# def getRouteListing(stopID=None,routeID=None):
#
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
. Output only the next line. | def routeRequest(routeID): |
Given the following code snippet before the placeholder: <|code_start|> rpc.callback = create_callback(rpc,stopID,r.route,sid,r.direction)
urlfetch.make_fetch_call(rpc, r.scheduleURL)
rpcs.append(rpc)
# all of the schedule URLs have been fetched. now wait for them to finish
for rpc in rpcs:
rpc.wait()
# all calls should be complete at this point
while memcache.get(sid) > 0 :
#logging.info('API: ERROR : uh-oh. in waiting loop... %s' % memcache.get(sid))
rpc.wait()
memcache.delete(sid)
return webapp2.get_request().registry['aggregated_results']
## end aggregateBusesAsynch()
#
# This function handles the callback of a single fetch request.
# If all requests for this sid are services, aggregate the results
#
def handle_result(rpc,stopID,routeID,sid,directionID):
result = None
try:
# go fetch the webpage for this route/stop!
result = rpc.get_result()
except urlfetch.DownloadError:
stathat.apiErrorCount()
<|code_end|>
, predict the next line using imports from the current file:
import logging
import webapp2
import config
from google.appengine.api import mail
from google.appengine.api import urlfetch
from google.appengine.api import memcache
from google.appengine.ext import db
from BeautifulSoup import BeautifulSoup
from data_model import BusStopAggregation
from api.v1 import api_utils
from stats_and_maps.stats import stathat
and context including class names, function names, and sometimes code from other files:
# Path: data_model.py
# class BusStopAggregation(db.Model):
# dateAdded = db.DateTimeProperty(auto_now_add=True)
# routeID = db.StringProperty(indexed=False)
# stopID = db.StringProperty(indexed=False)
# destination = db.StringProperty(indexed=False)
# arrivalTime = db.StringProperty(indexed=False)
# time = db.IntegerProperty()
# text = db.StringProperty(multiline=True,indexed=False)
# sid = db.StringProperty()
#
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
. Output only the next line. | logging.error("API: Error loading page. route %s, stop %s" % (routeID,stopID)) |
Using the snippet: <|code_start|> # instead of shoving this in the datastore, we're going to shove
# it in a local variable and retrieve it with the sid later
# old implementation --> stop.put()
insert_result(sid,stop)
# create the task that glues all the messages together when
# we've finished the fetch tasks
memcache.decr(sid)
return
## end
# insert a BusAggregation result into the results array for this SID
# we'll scan the current list and insert it into the array based
# on the time-to-arrival
#
def insert_result(sid,stop):
aggregated_results = webapp2.get_request().registry['aggregated_results']
if len(aggregated_results) == 0:
aggregated_results = [stop]
else:
done = False
for i, s in enumerate(aggregated_results):
if stop.time <= s.time:
aggregated_results.insert(i,stop)
done = True
break
if not done:
<|code_end|>
, determine the next line of code. You have imports:
import logging
import webapp2
import config
from google.appengine.api import mail
from google.appengine.api import urlfetch
from google.appengine.api import memcache
from google.appengine.ext import db
from BeautifulSoup import BeautifulSoup
from data_model import BusStopAggregation
from api.v1 import api_utils
from stats_and_maps.stats import stathat
and context (class names, function names, or code) available:
# Path: data_model.py
# class BusStopAggregation(db.Model):
# dateAdded = db.DateTimeProperty(auto_now_add=True)
# routeID = db.StringProperty(indexed=False)
# stopID = db.StringProperty(indexed=False)
# destination = db.StringProperty(indexed=False)
# arrivalTime = db.StringProperty(indexed=False)
# time = db.IntegerProperty()
# text = db.StringProperty(multiline=True,indexed=False)
# sid = db.StringProperty()
#
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
. Output only the next line. | aggregated_results.append(stop) |
Given snippet: <|code_start|> # <td><a class="adatime" title="12:12 pm">12:12 pm</a></td>
# <td><a class="adatext" title="NTP">NTP</a></td>
# </tr><tr>
# <td><p class="stopLabel">Scheduled time shown</p></td>
# </tr><tr>
# <td><a class="ada" title="Times last updated 10:54:01 AM 10/16/2016">Times last updated 10:54:01 AM 10/16/2016</a></td>
# </tr>
# </tbody>
soup = BeautifulSoup(result.content)
for slot in soup.html.body.findAll("a","adatime"):
arrival = slot.string
direction = slot.parent.nextSibling.a.string
# ... correct the transfer point acronym we broke in the title() call above
direction = direction.replace('Tp','TP')
# the original implementaiton leveraged the datastore to store and
# ultimately sort the results when we got all of the routes back.
# we'll continute to use the model definition, but never actually store
# # the results in the datastore.
stop = BusStopAggregation()
stop.stopID = stopID
stop.routeID = routeID
stop.sid = sid
stop.arrivalTime = arrival
stop.destination = direction
# turn the arrival time into absolute minutes
hours = int(arrival.split(':')[0])
if arrival.find('pm') > 0 and int(hours) < 12:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import logging
import webapp2
import config
from google.appengine.api import mail
from google.appengine.api import urlfetch
from google.appengine.api import memcache
from google.appengine.ext import db
from BeautifulSoup import BeautifulSoup
from data_model import BusStopAggregation
from api.v1 import api_utils
from stats_and_maps.stats import stathat
and context:
# Path: data_model.py
# class BusStopAggregation(db.Model):
# dateAdded = db.DateTimeProperty(auto_now_add=True)
# routeID = db.StringProperty(indexed=False)
# stopID = db.StringProperty(indexed=False)
# destination = db.StringProperty(indexed=False)
# arrivalTime = db.StringProperty(indexed=False)
# time = db.IntegerProperty()
# text = db.StringProperty(multiline=True,indexed=False)
# sid = db.StringProperty()
#
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
which might include code, classes, or functions. Output only the next line. | hours += 12 |
Predict the next line after this snippet: <|code_start|> else:
if refresh is True:
json_response = getRoutes(refresh)
# drop it into the memcache again
memcache.set(api_utils.GETROUTES, json_response)
logging.debug('---> storing in memcache');
else:
logging.debug('---> memcache hit');
json_response = memcache.get(api_utils.GETROUTES)
if json_response is None:
json_response = getRoutes(refresh)
# drop it into the memcache again
memcache.set(api_utils.GETROUTES, json_response)
logging.debug('---> storing in memcache');
# record the API call for this devkey
api_utils.recordDeveloperRequest(devStoreKey,api_utils.GETROUTES,self.request.query_string,self.request.remote_addr);
#logging.debug('API: json response %s' % json_response);
callback = self.request.get('callback')
if callback is not '':
self.response.headers['Content-Type'] = 'application/javascript'
self.response.headers['Access-Control-Allow-Origin'] = '*'
self.response.headers['Access-Control-Allow-Methods'] = 'GET'
response = callback + '(' + json.dumps(json_response) + ');'
else:
self.response.headers['Content-Type'] = 'application/json'
<|code_end|>
using the current file's imports:
import logging
import webapp2 as webapp
import json
from google.appengine.api import memcache
from google.appengine.ext import db
from google.appengine.ext.webapp.util import run_wsgi_app
from api.v1 import api_utils
from stats_and_maps.stats import stathat
from data_model import RouteListing
and any relevant context from other files:
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
#
# Path: data_model.py
# class RouteListing(db.Model):
# route = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
# scheduleURL = db.StringProperty(indexed=False)
# stopLocation = db.ReferenceProperty(StopLocation,collection_name="stops")
. Output only the next line. | response = json_response |
Given the following code snippet before the placeholder: <|code_start|> # don't run these jobs during "off" hours
json_response = api_utils.buildErrorResponse('-1','The Metro service is not currently running')
else:
if refresh is True:
json_response = getRoutes(refresh)
# drop it into the memcache again
memcache.set(api_utils.GETROUTES, json_response)
logging.debug('---> storing in memcache');
else:
logging.debug('---> memcache hit');
json_response = memcache.get(api_utils.GETROUTES)
if json_response is None:
json_response = getRoutes(refresh)
# drop it into the memcache again
memcache.set(api_utils.GETROUTES, json_response)
logging.debug('---> storing in memcache');
# record the API call for this devkey
api_utils.recordDeveloperRequest(devStoreKey,api_utils.GETROUTES,self.request.query_string,self.request.remote_addr);
#logging.debug('API: json response %s' % json_response);
callback = self.request.get('callback')
if callback is not '':
self.response.headers['Content-Type'] = 'application/javascript'
self.response.headers['Access-Control-Allow-Origin'] = '*'
self.response.headers['Access-Control-Allow-Methods'] = 'GET'
response = callback + '(' + json.dumps(json_response) + ');'
<|code_end|>
, predict the next line using imports from the current file:
import logging
import webapp2 as webapp
import json
from google.appengine.api import memcache
from google.appengine.ext import db
from google.appengine.ext.webapp.util import run_wsgi_app
from api.v1 import api_utils
from stats_and_maps.stats import stathat
from data_model import RouteListing
and context including class names, function names, and sometimes code from other files:
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
#
# Path: data_model.py
# class RouteListing(db.Model):
# route = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
# scheduleURL = db.StringProperty(indexed=False)
# stopLocation = db.ReferenceProperty(StopLocation,collection_name="stops")
. Output only the next line. | else: |
Given the following code snippet before the placeholder: <|code_start|>
logging.debug('---> datastore lookup starting!')
offset = 0
q = RouteListing.all()
routes = q.fetch(1000)
hits = {}
response_dict = {'status':0,'timestamp':api_utils.getLocalTimestamp()}
while len(routes) > 0:
offset += len(routes)
## stopped here trying to create a map of unique routes and endpoints
##
for r in routes:
# are we tracking this route/direction pair?
key = r.route + ':' + r.direction
hits[key] = hits.get(key,0) + 1
# get more routes
routes = q.fetch(1000,offset)
routeMap = {}
for k,v in hits.iteritems():
key = k.split(':')
routeID = key[0]
direction = key[1]
directionLabel = api_utils.getDirectionLabel(direction)
logging.debug('adding direction %s to route %s' % (directionLabel,routeID))
if routeID in routeMap:
<|code_end|>
, predict the next line using imports from the current file:
import logging
import webapp2 as webapp
import json
from google.appengine.api import memcache
from google.appengine.ext import db
from google.appengine.ext.webapp.util import run_wsgi_app
from api.v1 import api_utils
from stats_and_maps.stats import stathat
from data_model import RouteListing
and context including class names, function names, and sometimes code from other files:
# Path: api/v1/api_utils.py
# def validateDevKey(devKey):
# def conformStopID(stopID):
# def conformRouteID(routeID):
# def inthepast(time):
# def getLocalDatetime():
# def getLocalTimestamp():
# def computeCountdownMinutes(arrivalTime):
# def afterHours():
# def buildErrorResponse(error,description):
# def getDirectionLabel(directionID):
# def handle_500(request, response, exception):
# def recordDeveloperRequest(devKey,type,terms,ipaddr,error='success'):
# def serialize_entities(models):
# def deserialize_entities(data):
# def get_time_from_text(text_with_time, findPos=0):
# GETARRIVALS = "get arrivals"
# GETVEHICLES = "get vehicles"
# GETSTOPS = "get stops"
# GETROUTES = "get routes"
# GETNEARBYSTOPS = "get nearby stops"
# GETSTOPLOCATION = "get stop location"
#
# Path: stats_and_maps/stats/stathat.py
# STATHAT_MEMCACHE_ERROR_COUNT = 'stathat_error_count'
# STATHAT_MEMCACHE_REQ_COUNT = 'stathat_req_count'
# URL_BASE = 'https://api.stathat.com'
# class StatHat:
# class StatValueTaskHandler(webapp.RequestHandler):
# class StatFlushHandler(webapp.RequestHandler):
# class StatStopsCollectHandler(webapp.RequestHandler):
# def http_post_async(self, path, data):
# def http_post(self, path, data):
# def post_value(self, user_key, stat_key, value, callback=None):
# def post_count(self, user_key, stat_key, count, callback=None):
# def ez_post_value(self, ezkey, stat_name, value):
# def ez_post_count(self, ezkey, stat_name, count):
# def apiStatCount():
# def apiErrorCount():
# def apiTimeStat(stat_key,value):
# def noop():
# def post(self):
# def get(self):
# def post(self):
# def main():
#
# Path: data_model.py
# class RouteListing(db.Model):
# route = db.StringProperty()
# routeCode = db.StringProperty()
# direction = db.StringProperty()
# stopID = db.StringProperty()
# stopCode = db.StringProperty()
# scheduleURL = db.StringProperty(indexed=False)
# stopLocation = db.ReferenceProperty(StopLocation,collection_name="stops")
. Output only the next line. | routeMap[routeID].append(directionLabel) |
Using the snippet: <|code_start|>
class CartSerializerDefault(serializers.ModelSerializer):
class Meta:
model = Cart
fields = '__all__'
<|code_end|>
, determine the next line of code. You have imports:
from rest_framework import serializers
from .models import (
Cart,
Item
)
and context (class names, function names, or code) available:
# Path: cart/models.py
# class Cart(models.Model):
# creation_date = models.DateTimeField(default=datetime.now,
# verbose_name=_('creation date'))
# checked_out = models.BooleanField(default=False,
# verbose_name=_('checked out'))
#
# class Meta:
# verbose_name = _('cart')
# verbose_name_plural = _('carts')
# ordering = ('-creation_date',)
#
# def __str__(self):
# return str(self.creation_date)
#
# class Item(models.Model):
# cart = models.ForeignKey(Cart, verbose_name=_('cart'))
# quantity = models.PositiveIntegerField(verbose_name=_('quantity'))
# unit_price = models.DecimalField(max_digits=18, decimal_places=2,
# verbose_name=_('unit price'))
#
# content_type = models.ForeignKey(ContentType)
# object_id = models.PositiveIntegerField()
#
# objects = ItemManager()
#
# class Meta:
# verbose_name = _('item')
# verbose_name_plural = _('items')
# ordering = ('cart',)
#
# def __unicode__(self):
# return u'%d units of %s' % (self.quantity,
# self.product.__class__.__name__)
#
# def total_price(self):
# return self.quantity * self.unit_price
# total_price = property(total_price)
#
# def get_product(self):
# return self.content_type.get_object_for_this_type(pk=self.object_id)
#
# def set_product(self, product):
# self.content_type = ContentType.objects.get_for_model(type(product))
# self.object_id = product.pk
#
# product = property(get_product, set_product)
. Output only the next line. | class CartSerializerPOST(serializers.ModelSerializer): |
Given the code snippet: <|code_start|>
extra_kwargs = {
'password': {'write_only': True},
}
def create(self, validated_data):
user = CustomerUser(**validated_data)
password = validated_data['password']
user.set_password(password)
user.save()
token = Token.objects.create(user=user)
token.save()
return user
class CreditCardSerializerDefault(serializers.ModelSerializer):
class Meta:
model = CreditCard
fields = '__all__'
class CreditCardSerializerPOST(serializers.ModelSerializer):
class Meta:
model = CreditCard
fields = ('pk', 'owner_name', 'card_number', 'security_code',
'expire_date', 'provider', 'user')
def create(self, validated_data):
credit_card = CreditCard(**validated_data)
credit_card.save()
<|code_end|>
, generate the next line using the imports in this file:
from rest_framework.authtoken.models import Token
from rest_framework import serializers
from .models import (
CustomerUser,
CreditCard,
ShippingAddress
)
and context (functions, classes, or occasionally code) from other files:
# Path: users/models.py
# class CustomerUser(User):
# """docstring for CustomerUser"""
# cellphone = models.CharField(
# help_text=_("Número de telefone. Preencha apenas com númreos."),
# verbose_name=_("Telefone Celular"),
# max_length=15, null=False, blank=False)
#
# phone_number = models.CharField(
# help_text=_("Número de telefone. Preencha apenas com númreos."),
# verbose_name=_("Teledone Fixo"),
# max_length=15, null=True, blank=False)
#
# class Meta:
# verbose_name = _('Cliente')
# verbose_name_plural = _('Clientes')
#
# def __str__(self):
# return (self.first_name + " " + self.last_name)
#
# class CreditCard(models.Model):
# """docstring for CreditCard"""
# user = models.ForeignKey(CustomerUser)
# owner_name = models.CharField(
# help_text=_("Preencha como está no " + credit_card_verbose_name),
# verbose_name=_("Nome do Titular do " + credit_card_verbose_name),
# max_length=256)
# card_number = models.CharField(
# verbose_name=_("Número do " + credit_card_verbose_name),
# max_length=16)
# security_code = models.CharField(
# verbose_name=_("Código de Segurança do " + credit_card_verbose_name),
# max_length=3)
# expire_date = models.DateField(
# verbose_name=_("Validade do " + credit_card_verbose_name))
# provider = models.CharField(
# verbose_name=_("Bandeira do " + credit_card_verbose_name),
# max_length=20)
#
# class Meta:
# verbose_name = _(credit_card_verbose_name)
# verbose_name_plural = _(credit_card_verbose_name_plural)
#
# def __str__(self):
# return ("************" + self.card_number[-4:])
#
# class ShippingAddress(models.Model):
# """docstring for ShippingAddress"""
# customer = models.ForeignKey(CustomerUser)
# country = models.CharField(
# help_text=_(
# "Preencha com o nome completo do país"
# " onde esse endereço se encontra."),
# verbose_name=_("País"),
# max_length=50)
# state = models.CharField(
# help_text=_("Estado ou província onde esse estado se encontra."),
# verbose_name=_("Estado"),
# max_length=50)
# city = models.CharField(
# help_text=_("Cidade onde esse endereço se encontra."),
# verbose_name=_("Cidade"),
# max_length=50)
# zip_code = models.CharField(
# help_text=_("Código de Endereço Postal"),
# verbose_name=_("CEP"),
# max_length=10, null=True, blank=True)
# address = models.CharField(
# help_text=_("Endereço Postal"),
# verbose_name=_("Endereço"),
# max_length=256)
# reference = models.CharField(
# help_text=_(
# "Ponto de Referência nas redondezas."
# " Ex: 'Ao lado da Farmécia'"),
# verbose_name=_("Ponto de Referência."),
# max_length=256, null=True, blank=True)
#
# class Meta:
# verbose_name = _('Endereço para Envio')
# verbose_name_plural = _('Endereços para Envio')
# ordering = ('country', 'state', 'city', 'zip_code')
#
# def __str__(self):
# return self.zip_code + ' - ' + self.address
. Output only the next line. | token = Token.objects.create(credit_card=credit_card) |
Here is a snippet: <|code_start|>class CustomerUserSerializerPOST(serializers.ModelSerializer):
class Meta:
model = CustomerUser
fields = ('pk', 'username', 'first_name', 'last_name',
'email', 'password', 'cellphone', 'phone_number')
extra_kwargs = {
'password': {'write_only': True},
}
def create(self, validated_data):
user = CustomerUser(**validated_data)
password = validated_data['password']
user.set_password(password)
user.save()
token = Token.objects.create(user=user)
token.save()
return user
class CreditCardSerializerDefault(serializers.ModelSerializer):
class Meta:
model = CreditCard
fields = '__all__'
class CreditCardSerializerPOST(serializers.ModelSerializer):
class Meta:
model = CreditCard
fields = ('pk', 'owner_name', 'card_number', 'security_code',
<|code_end|>
. Write the next line using the current file imports:
from rest_framework.authtoken.models import Token
from rest_framework import serializers
from .models import (
CustomerUser,
CreditCard,
ShippingAddress
)
and context from other files:
# Path: users/models.py
# class CustomerUser(User):
# """docstring for CustomerUser"""
# cellphone = models.CharField(
# help_text=_("Número de telefone. Preencha apenas com númreos."),
# verbose_name=_("Telefone Celular"),
# max_length=15, null=False, blank=False)
#
# phone_number = models.CharField(
# help_text=_("Número de telefone. Preencha apenas com númreos."),
# verbose_name=_("Teledone Fixo"),
# max_length=15, null=True, blank=False)
#
# class Meta:
# verbose_name = _('Cliente')
# verbose_name_plural = _('Clientes')
#
# def __str__(self):
# return (self.first_name + " " + self.last_name)
#
# class CreditCard(models.Model):
# """docstring for CreditCard"""
# user = models.ForeignKey(CustomerUser)
# owner_name = models.CharField(
# help_text=_("Preencha como está no " + credit_card_verbose_name),
# verbose_name=_("Nome do Titular do " + credit_card_verbose_name),
# max_length=256)
# card_number = models.CharField(
# verbose_name=_("Número do " + credit_card_verbose_name),
# max_length=16)
# security_code = models.CharField(
# verbose_name=_("Código de Segurança do " + credit_card_verbose_name),
# max_length=3)
# expire_date = models.DateField(
# verbose_name=_("Validade do " + credit_card_verbose_name))
# provider = models.CharField(
# verbose_name=_("Bandeira do " + credit_card_verbose_name),
# max_length=20)
#
# class Meta:
# verbose_name = _(credit_card_verbose_name)
# verbose_name_plural = _(credit_card_verbose_name_plural)
#
# def __str__(self):
# return ("************" + self.card_number[-4:])
#
# class ShippingAddress(models.Model):
# """docstring for ShippingAddress"""
# customer = models.ForeignKey(CustomerUser)
# country = models.CharField(
# help_text=_(
# "Preencha com o nome completo do país"
# " onde esse endereço se encontra."),
# verbose_name=_("País"),
# max_length=50)
# state = models.CharField(
# help_text=_("Estado ou província onde esse estado se encontra."),
# verbose_name=_("Estado"),
# max_length=50)
# city = models.CharField(
# help_text=_("Cidade onde esse endereço se encontra."),
# verbose_name=_("Cidade"),
# max_length=50)
# zip_code = models.CharField(
# help_text=_("Código de Endereço Postal"),
# verbose_name=_("CEP"),
# max_length=10, null=True, blank=True)
# address = models.CharField(
# help_text=_("Endereço Postal"),
# verbose_name=_("Endereço"),
# max_length=256)
# reference = models.CharField(
# help_text=_(
# "Ponto de Referência nas redondezas."
# " Ex: 'Ao lado da Farmécia'"),
# verbose_name=_("Ponto de Referência."),
# max_length=256, null=True, blank=True)
#
# class Meta:
# verbose_name = _('Endereço para Envio')
# verbose_name_plural = _('Endereços para Envio')
# ordering = ('country', 'state', 'city', 'zip_code')
#
# def __str__(self):
# return self.zip_code + ' - ' + self.address
, which may include functions, classes, or code. Output only the next line. | 'expire_date', 'provider', 'user') |
Using the snippet: <|code_start|>
urlpatterns = [
url(r'^index/', productIndexView, name='productIndexView'),
url(r'^(?P<product_id>[0-9]+)/details/$', productDetailView,
name='productDetailView'),
url(r'^productFilter/', productFilterView, name='productFilterView'),
url(r'^list/', categoryIndexView, name='categoryIndexView'),
url(r'^(?P<category_id>[0-9]+)/products_list/$', categoryDetailView,
name='productDetailView'),
<|code_end|>
, determine the next line of code. You have imports:
from django.conf import settings
from django.conf.urls import url
from django.conf.urls.static import static
from django.contrib.auth.decorators import login_required
from products.views import (
productIndexView,
productDetailView,
categoryIndexView,
categoryDetailView,
addProductToCartView,
productFilterView,
)
and context (class names, function names, or code) available:
# Path: products/views.py
# def productIndexView(request):
#
# queryset = Product.objects.all()
# context = {
# "products": queryset,
# }
#
# return render(request, "productIndex.html", context)
#
# def productDetailView(request, product_id):
# try:
# product = Product.objects.get(pk=product_id)
# except Product.DoesNotExist:
# raise Http404("The product does not exist")
# return render(request, "productDetail.html", {'product': product})
#
# def categoryIndexView(request):
#
# queryset = ProductCategory.objects.all()
# context = {
# "categories": queryset,
# }
#
# return render(request, "categoryIndex.html", context)
#
# def categoryDetailView(request, category_id):
#
# category = ProductCategory.objects.get(pk=category_id)
# queryset = Product.objects.filter(category_id=category_id)
# context = {
# "products": queryset,
# "category": category,
# }
#
# return render(request, "categoryDetail.html", context)
#
# def addProductToCartView(request, product_id):
#
# quantity = request.POST['quantity']
# CartManagement.addToCart(request, product_id, quantity)
#
# return redirect('/cart/cart_detail')
#
# def productFilterView(request):
# products = Product.objects.all()
# var_get_search = request.GET.get('search_product')
# if var_get_search is not None:
# products = products.filter(product_name__contains=var_get_search)
#
# return render(request, 'productFilter.html', {'products': products})
. Output only the next line. | url(r'^(?P<product_id>[0-9]+)/add_to_cart/$', |
Based on the snippet: <|code_start|>
urlpatterns = [
url(r'^index/', productIndexView, name='productIndexView'),
url(r'^(?P<product_id>[0-9]+)/details/$', productDetailView,
name='productDetailView'),
url(r'^productFilter/', productFilterView, name='productFilterView'),
url(r'^list/', categoryIndexView, name='categoryIndexView'),
url(r'^(?P<category_id>[0-9]+)/products_list/$', categoryDetailView,
name='productDetailView'),
url(r'^(?P<product_id>[0-9]+)/add_to_cart/$',
login_required(addProductToCartView),
<|code_end|>
, predict the immediate next line with the help of imports:
from django.conf import settings
from django.conf.urls import url
from django.conf.urls.static import static
from django.contrib.auth.decorators import login_required
from products.views import (
productIndexView,
productDetailView,
categoryIndexView,
categoryDetailView,
addProductToCartView,
productFilterView,
)
and context (classes, functions, sometimes code) from other files:
# Path: products/views.py
# def productIndexView(request):
#
# queryset = Product.objects.all()
# context = {
# "products": queryset,
# }
#
# return render(request, "productIndex.html", context)
#
# def productDetailView(request, product_id):
# try:
# product = Product.objects.get(pk=product_id)
# except Product.DoesNotExist:
# raise Http404("The product does not exist")
# return render(request, "productDetail.html", {'product': product})
#
# def categoryIndexView(request):
#
# queryset = ProductCategory.objects.all()
# context = {
# "categories": queryset,
# }
#
# return render(request, "categoryIndex.html", context)
#
# def categoryDetailView(request, category_id):
#
# category = ProductCategory.objects.get(pk=category_id)
# queryset = Product.objects.filter(category_id=category_id)
# context = {
# "products": queryset,
# "category": category,
# }
#
# return render(request, "categoryDetail.html", context)
#
# def addProductToCartView(request, product_id):
#
# quantity = request.POST['quantity']
# CartManagement.addToCart(request, product_id, quantity)
#
# return redirect('/cart/cart_detail')
#
# def productFilterView(request):
# products = Product.objects.all()
# var_get_search = request.GET.get('search_product')
# if var_get_search is not None:
# products = products.filter(product_name__contains=var_get_search)
#
# return render(request, 'productFilter.html', {'products': products})
. Output only the next line. | name='addProductToCart') |
Given the following code snippet before the placeholder: <|code_start|>
urlpatterns = [
url(r'^index/', productIndexView, name='productIndexView'),
url(r'^(?P<product_id>[0-9]+)/details/$', productDetailView,
name='productDetailView'),
url(r'^productFilter/', productFilterView, name='productFilterView'),
url(r'^list/', categoryIndexView, name='categoryIndexView'),
url(r'^(?P<category_id>[0-9]+)/products_list/$', categoryDetailView,
name='productDetailView'),
url(r'^(?P<product_id>[0-9]+)/add_to_cart/$',
login_required(addProductToCartView),
name='addProductToCart')
]
<|code_end|>
, predict the next line using imports from the current file:
from django.conf import settings
from django.conf.urls import url
from django.conf.urls.static import static
from django.contrib.auth.decorators import login_required
from products.views import (
productIndexView,
productDetailView,
categoryIndexView,
categoryDetailView,
addProductToCartView,
productFilterView,
)
and context including class names, function names, and sometimes code from other files:
# Path: products/views.py
# def productIndexView(request):
#
# queryset = Product.objects.all()
# context = {
# "products": queryset,
# }
#
# return render(request, "productIndex.html", context)
#
# def productDetailView(request, product_id):
# try:
# product = Product.objects.get(pk=product_id)
# except Product.DoesNotExist:
# raise Http404("The product does not exist")
# return render(request, "productDetail.html", {'product': product})
#
# def categoryIndexView(request):
#
# queryset = ProductCategory.objects.all()
# context = {
# "categories": queryset,
# }
#
# return render(request, "categoryIndex.html", context)
#
# def categoryDetailView(request, category_id):
#
# category = ProductCategory.objects.get(pk=category_id)
# queryset = Product.objects.filter(category_id=category_id)
# context = {
# "products": queryset,
# "category": category,
# }
#
# return render(request, "categoryDetail.html", context)
#
# def addProductToCartView(request, product_id):
#
# quantity = request.POST['quantity']
# CartManagement.addToCart(request, product_id, quantity)
#
# return redirect('/cart/cart_detail')
#
# def productFilterView(request):
# products = Product.objects.all()
# var_get_search = request.GET.get('search_product')
# if var_get_search is not None:
# products = products.filter(product_name__contains=var_get_search)
#
# return render(request, 'productFilter.html', {'products': products})
. Output only the next line. | if settings.DEBUG: |
Using the snippet: <|code_start|>
urlpatterns = [
url(r'^index/', productIndexView, name='productIndexView'),
url(r'^(?P<product_id>[0-9]+)/details/$', productDetailView,
name='productDetailView'),
url(r'^productFilter/', productFilterView, name='productFilterView'),
url(r'^list/', categoryIndexView, name='categoryIndexView'),
url(r'^(?P<category_id>[0-9]+)/products_list/$', categoryDetailView,
name='productDetailView'),
url(r'^(?P<product_id>[0-9]+)/add_to_cart/$',
login_required(addProductToCartView),
name='addProductToCart')
]
<|code_end|>
, determine the next line of code. You have imports:
from django.conf import settings
from django.conf.urls import url
from django.conf.urls.static import static
from django.contrib.auth.decorators import login_required
from products.views import (
productIndexView,
productDetailView,
categoryIndexView,
categoryDetailView,
addProductToCartView,
productFilterView,
)
and context (class names, function names, or code) available:
# Path: products/views.py
# def productIndexView(request):
#
# queryset = Product.objects.all()
# context = {
# "products": queryset,
# }
#
# return render(request, "productIndex.html", context)
#
# def productDetailView(request, product_id):
# try:
# product = Product.objects.get(pk=product_id)
# except Product.DoesNotExist:
# raise Http404("The product does not exist")
# return render(request, "productDetail.html", {'product': product})
#
# def categoryIndexView(request):
#
# queryset = ProductCategory.objects.all()
# context = {
# "categories": queryset,
# }
#
# return render(request, "categoryIndex.html", context)
#
# def categoryDetailView(request, category_id):
#
# category = ProductCategory.objects.get(pk=category_id)
# queryset = Product.objects.filter(category_id=category_id)
# context = {
# "products": queryset,
# "category": category,
# }
#
# return render(request, "categoryDetail.html", context)
#
# def addProductToCartView(request, product_id):
#
# quantity = request.POST['quantity']
# CartManagement.addToCart(request, product_id, quantity)
#
# return redirect('/cart/cart_detail')
#
# def productFilterView(request):
# products = Product.objects.all()
# var_get_search = request.GET.get('search_product')
# if var_get_search is not None:
# products = products.filter(product_name__contains=var_get_search)
#
# return render(request, 'productFilter.html', {'products': products})
. Output only the next line. | if settings.DEBUG: |
Next line prediction: <|code_start|>
urlpatterns = [
url(r'^index/', productIndexView, name='productIndexView'),
url(r'^(?P<product_id>[0-9]+)/details/$', productDetailView,
name='productDetailView'),
url(r'^productFilter/', productFilterView, name='productFilterView'),
url(r'^list/', categoryIndexView, name='categoryIndexView'),
url(r'^(?P<category_id>[0-9]+)/products_list/$', categoryDetailView,
name='productDetailView'),
url(r'^(?P<product_id>[0-9]+)/add_to_cart/$',
login_required(addProductToCartView),
<|code_end|>
. Use current file imports:
(from django.conf import settings
from django.conf.urls import url
from django.conf.urls.static import static
from django.contrib.auth.decorators import login_required
from products.views import (
productIndexView,
productDetailView,
categoryIndexView,
categoryDetailView,
addProductToCartView,
productFilterView,
))
and context including class names, function names, or small code snippets from other files:
# Path: products/views.py
# def productIndexView(request):
#
# queryset = Product.objects.all()
# context = {
# "products": queryset,
# }
#
# return render(request, "productIndex.html", context)
#
# def productDetailView(request, product_id):
# try:
# product = Product.objects.get(pk=product_id)
# except Product.DoesNotExist:
# raise Http404("The product does not exist")
# return render(request, "productDetail.html", {'product': product})
#
# def categoryIndexView(request):
#
# queryset = ProductCategory.objects.all()
# context = {
# "categories": queryset,
# }
#
# return render(request, "categoryIndex.html", context)
#
# def categoryDetailView(request, category_id):
#
# category = ProductCategory.objects.get(pk=category_id)
# queryset = Product.objects.filter(category_id=category_id)
# context = {
# "products": queryset,
# "category": category,
# }
#
# return render(request, "categoryDetail.html", context)
#
# def addProductToCartView(request, product_id):
#
# quantity = request.POST['quantity']
# CartManagement.addToCart(request, product_id, quantity)
#
# return redirect('/cart/cart_detail')
#
# def productFilterView(request):
# products = Product.objects.all()
# var_get_search = request.GET.get('search_product')
# if var_get_search is not None:
# products = products.filter(product_name__contains=var_get_search)
#
# return render(request, 'productFilter.html', {'products': products})
. Output only the next line. | name='addProductToCart') |
Given the following code snippet before the placeholder: <|code_start|>
urlpatterns = [
url(r'^index/', productIndexView, name='productIndexView'),
url(r'^(?P<product_id>[0-9]+)/details/$', productDetailView,
name='productDetailView'),
url(r'^productFilter/', productFilterView, name='productFilterView'),
url(r'^list/', categoryIndexView, name='categoryIndexView'),
url(r'^(?P<category_id>[0-9]+)/products_list/$', categoryDetailView,
name='productDetailView'),
url(r'^(?P<product_id>[0-9]+)/add_to_cart/$',
login_required(addProductToCartView),
<|code_end|>
, predict the next line using imports from the current file:
from django.conf import settings
from django.conf.urls import url
from django.conf.urls.static import static
from django.contrib.auth.decorators import login_required
from products.views import (
productIndexView,
productDetailView,
categoryIndexView,
categoryDetailView,
addProductToCartView,
productFilterView,
)
and context including class names, function names, and sometimes code from other files:
# Path: products/views.py
# def productIndexView(request):
#
# queryset = Product.objects.all()
# context = {
# "products": queryset,
# }
#
# return render(request, "productIndex.html", context)
#
# def productDetailView(request, product_id):
# try:
# product = Product.objects.get(pk=product_id)
# except Product.DoesNotExist:
# raise Http404("The product does not exist")
# return render(request, "productDetail.html", {'product': product})
#
# def categoryIndexView(request):
#
# queryset = ProductCategory.objects.all()
# context = {
# "categories": queryset,
# }
#
# return render(request, "categoryIndex.html", context)
#
# def categoryDetailView(request, category_id):
#
# category = ProductCategory.objects.get(pk=category_id)
# queryset = Product.objects.filter(category_id=category_id)
# context = {
# "products": queryset,
# "category": category,
# }
#
# return render(request, "categoryDetail.html", context)
#
# def addProductToCartView(request, product_id):
#
# quantity = request.POST['quantity']
# CartManagement.addToCart(request, product_id, quantity)
#
# return redirect('/cart/cart_detail')
#
# def productFilterView(request):
# products = Product.objects.all()
# var_get_search = request.GET.get('search_product')
# if var_get_search is not None:
# products = products.filter(product_name__contains=var_get_search)
#
# return render(request, 'productFilter.html', {'products': products})
. Output only the next line. | name='addProductToCart') |
Given snippet: <|code_start|>
urlpatterns = [
url(r'^cart_detail/', login_required(cartDetailView),
name='cartDetailView'),
url(r'^(?P<product_id>[0-9]+)/remove_from_cart/$',
login_required(removeFromCartView),
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from cart.views import cartDetailView, removeFromCartView
from django.conf.urls import url
from django.contrib.auth.decorators import login_required
and context:
# Path: cart/views.py
# def cartDetailView(request):
# return render_to_response('cartDetail.html', dict(cart=Cart(request)))
#
# @csrf_exempt
# def removeFromCartView(request, product_id):
#
# CartManagement.removeFromCart(request, product_id)
#
# return redirect('/cart/cart_detail')
which might include code, classes, or functions. Output only the next line. | name='removeProductFromCart') |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.