Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Here is a snippet: <|code_start|> files[k] = val
return files
def get_headers(request, hide_env=True):
"""Returns headers dict from request context."""
headers = dict(request.headers.items())
if hide_env and ('show_env' not in request.args):
for key in ENV_HEADERS:
try:
del headers[key]
except KeyError:
pass
return CaseInsensitiveDict(headers.items())
def semiflatten(multi):
"""Convert a MutiDict into a regular dict. If there are more than one value
for a key, the result will have a list of values for the key. Otherwise it
will have the plain value."""
if multi:
result = multi.to_dict()
for k, v in result.items():
if len(v) == 1:
result[k] = v[0]
return result
<|code_end|>
. Write the next line using the current file imports:
import json
import base64
from hashlib import md5
from werkzeug.http import parse_authorization_header
from bustard.http import Response
from six.moves.urllib.parse import urlparse, urlunparse
from .structures import CaseInsensitiveDict
and context from other files:
# Path: bustard/http.py
# class Response:
#
# def __init__(self, content=b'', status_code=200,
# content_type='text/html; charset=utf-8',
# headers=None):
# self._content = content
# self._status_code = status_code
# _headers = headers or {}
# _headers.setdefault('Content-Type', content_type)
# if isinstance(_headers, Headers):
# self._headers = _headers
# else:
# self._headers = Headers(_headers)
# self._cookies = SimpleCookie()
# self._load_cookies_from_headers()
#
# def _load_cookies_from_headers(self):
# cookies = self._headers.to_dict().pop('Set-Cookie', [])
# for cookie in cookies:
# self._cookies.load(cookie)
#
# @property
# def content(self):
# return self._content
#
# @content.setter
# def content(self, value):
# if isinstance(value, str):
# value = value.encode('utf-8')
# self._content = value
# body = data = content
#
# def get_data(self):
# return self._content
#
# @property
# def content_type(self, value):
# return self.headers.get('Content-Type', '')
#
# @content_type.setter
# def content_type(self, value):
# self.headers['Content-Type'] = value
#
# @property
# def content_length(self):
# return int(self.headers.get('Content-Length', '0'))
#
# @property
# def status_code(self):
# return self._status_code
#
# @status_code.setter
# def status_code(self, value):
# self._status_code = value
#
# @property
# def status(self):
# code = self._status_code
# return response_status_string(code)
#
# @property
# def headers(self):
# return self._headers
#
# @headers.setter
# def headers(self, value):
# self._headers = Headers(value)
#
# @property
# def content_type(self):
# return self._headers.get('Content-Type', '')
#
# @content_type.setter
# def content_type(self, value):
# self._headers['Content-Type'] = value
#
# @property
# def cookies(self):
# return self._cookies
#
# def set_cookie(self, key, value='', max_age=None, expires=None, path='/',
# domain=None, secure=False, httponly=False):
# cookie = cookie_dump(
# key, value=value, max_age=max_age, expires=expires, path=path,
# domain=domain, secure=secure, httponly=httponly
# )
# self._cookies.load(cookie)
#
# def delete_cookie(self, key, max_age=0,
# expires='Thu, 01-Jan-1970 00:00:00 GMT'):
# self.set_cookie(key, value='', max_age=max_age, expires=expires)
#
# @property
# def headers_list(self):
# # normal headers
# headers_list = list(self.headers.to_list())
#
# # set-cookies
# headers_list.extend(
# ('Set-Cookie', value.OutputString())
# for value in self.cookies.values()
# )
# return headers_list
#
# def json(self):
# return json.loads(to_text(self.data))
#
# def __repr__(self):
# return '<{} [{}]>'.format(self.__class__.__name__, self.status_code)
, which may include functions, classes, or code. Output only the next line. | else: |
Given the following code snippet before the placeholder: <|code_start|># -*- coding: utf-8 -*-
def test_multidict():
d = MultiDict({'a': 1, 'b': 'a'})
assert d['a'] == 1
assert d['b'] == 'a'
d['a'] = 2
assert d['a'] == 2
assert d.getlist('a') == [2]
d['a'] = [1, 2]
assert d['a'] == 2
assert d.getlist('a') == [1, 2]
assert d.to_dict() == {'a': [1, 2], 'b': ['a']}
def test_json_dumps_default():
d = MultiDict({'a': 1})
assert json.dumps(d, default=json_dumps_default) == json.dumps({'a': [1]})
<|code_end|>
, predict the next line using imports from the current file:
import base64
import json
import pytest
from bustard.utils import (
MultiDict, parse_query_string, parse_basic_auth_header,
to_header_key, to_text, to_bytes, json_dumps_default,
Authorization
)
and context including class names, function names, and sometimes code from other files:
# Path: bustard/utils.py
# class MultiDict(collections.UserDict):
#
# def getlist(self, key):
# return self.data[key]
#
# def to_dict(self):
# return self.data
#
# def __getitem__(self, key):
# return self.data[key][-1]
#
# def __setitem__(self, key, value):
# if isinstance(value, (list, tuple)):
# self.data[key] = list(value)
# else:
# self.data[key] = [value]
#
# def __repr__(self):
# return '{}({})'.format(self.__class__.__name__, self.data)
#
# def parse_query_string(query_string, encoding='utf-8'):
# query_dict = collections.defaultdict(list)
# for query_item in query_string.split('&'):
# if '=' not in query_item:
# continue
# keyword, value = query_item.split('=', 1)
# value = urllib.parse.unquote_plus(value)
# query_dict[keyword].append(to_text(value, encoding=encoding))
# return query_dict
#
# def parse_basic_auth_header(value):
# try:
# auth_type, auth_info = to_bytes(value).split(None, 1)
# except ValueError:
# return
# auth_type = auth_type.lower()
#
# if auth_type == b'basic':
# try:
# username, password = base64.b64decode(auth_info).split(b':', 1)
# except (binascii.Error, ValueError):
# return
#
# return Authorization(
# to_text(auth_type),
# username=to_text(username),
# password=to_text(password)
# )
#
# def to_header_key(key):
# return '-'.join(x.capitalize() for x in key.split('-'))
#
# def to_text(st, encoding='utf-8'):
# if isinstance(st, str):
# return st
# elif isinstance(st, collections.ByteString):
# return st.decode(encoding)
# else:
# return str(st)
#
# def to_bytes(bt, encoding='utf-8'):
# if isinstance(bt, collections.ByteString):
# return bt
# elif isinstance(bt, str):
# return bt.encode(encoding)
# else:
# return bytes(bt)
#
# def json_dumps_default(obj):
# if isinstance(obj, collections.UserDict):
# return obj.to_dict()
# return obj
#
# class Authorization:
#
# def __init__(self, _type, username, password):
# self.type = _type
# self.username = username
# self.password = password
#
# def __eq__(self, other):
# return (
# self.type == other.type and
# self.username == other.username and
# self.password == other.password
# )
#
# __hash__ = object.__hash__
#
# def __repr__(self):
# return '{}(type:{}, username:{})'.format(
# self.__class__.__name__, self.type, self.username
# )
. Output only the next line. | d['b'] = [1, 2, 3] |
Based on the snippet: <|code_start|> assert parse_query_string(qs) == expect
@pytest.mark.parametrize('key, expect', [
('abc', 'Abc'),
('abc_name', 'Abc_name'),
('UserAgent', 'Useragent'),
('user-Agent', 'User-Agent'),
('x-rage', 'X-Rage'),
])
def test_to_header_key(key, expect):
assert to_header_key(key) == expect
@pytest.mark.parametrize('st, expect', [
(b'abc', 'abc'),
('你好'.encode('utf8'), '你好'),
])
def test_to_text(st, expect):
assert to_text(st) == expect
@pytest.mark.parametrize('bt, expect', [
('abc', b'abc'),
('你好', '你好'.encode('utf8')),
])
def test_to_bytes(bt, expect):
assert to_bytes(bt) == expect
<|code_end|>
, predict the immediate next line with the help of imports:
import base64
import json
import pytest
from bustard.utils import (
MultiDict, parse_query_string, parse_basic_auth_header,
to_header_key, to_text, to_bytes, json_dumps_default,
Authorization
)
and context (classes, functions, sometimes code) from other files:
# Path: bustard/utils.py
# class MultiDict(collections.UserDict):
#
# def getlist(self, key):
# return self.data[key]
#
# def to_dict(self):
# return self.data
#
# def __getitem__(self, key):
# return self.data[key][-1]
#
# def __setitem__(self, key, value):
# if isinstance(value, (list, tuple)):
# self.data[key] = list(value)
# else:
# self.data[key] = [value]
#
# def __repr__(self):
# return '{}({})'.format(self.__class__.__name__, self.data)
#
# def parse_query_string(query_string, encoding='utf-8'):
# query_dict = collections.defaultdict(list)
# for query_item in query_string.split('&'):
# if '=' not in query_item:
# continue
# keyword, value = query_item.split('=', 1)
# value = urllib.parse.unquote_plus(value)
# query_dict[keyword].append(to_text(value, encoding=encoding))
# return query_dict
#
# def parse_basic_auth_header(value):
# try:
# auth_type, auth_info = to_bytes(value).split(None, 1)
# except ValueError:
# return
# auth_type = auth_type.lower()
#
# if auth_type == b'basic':
# try:
# username, password = base64.b64decode(auth_info).split(b':', 1)
# except (binascii.Error, ValueError):
# return
#
# return Authorization(
# to_text(auth_type),
# username=to_text(username),
# password=to_text(password)
# )
#
# def to_header_key(key):
# return '-'.join(x.capitalize() for x in key.split('-'))
#
# def to_text(st, encoding='utf-8'):
# if isinstance(st, str):
# return st
# elif isinstance(st, collections.ByteString):
# return st.decode(encoding)
# else:
# return str(st)
#
# def to_bytes(bt, encoding='utf-8'):
# if isinstance(bt, collections.ByteString):
# return bt
# elif isinstance(bt, str):
# return bt.encode(encoding)
# else:
# return bytes(bt)
#
# def json_dumps_default(obj):
# if isinstance(obj, collections.UserDict):
# return obj.to_dict()
# return obj
#
# class Authorization:
#
# def __init__(self, _type, username, password):
# self.type = _type
# self.username = username
# self.password = password
#
# def __eq__(self, other):
# return (
# self.type == other.type and
# self.username == other.username and
# self.password == other.password
# )
#
# __hash__ = object.__hash__
#
# def __repr__(self):
# return '{}(type:{}, username:{})'.format(
# self.__class__.__name__, self.type, self.username
# )
. Output only the next line. | @pytest.mark.parametrize('value, expect', [ |
Continue the code snippet: <|code_start|># -*- coding: utf-8 -*-
def test_multidict():
d = MultiDict({'a': 1, 'b': 'a'})
assert d['a'] == 1
assert d['b'] == 'a'
d['a'] = 2
assert d['a'] == 2
assert d.getlist('a') == [2]
d['a'] = [1, 2]
assert d['a'] == 2
<|code_end|>
. Use current file imports:
import base64
import json
import pytest
from bustard.utils import (
MultiDict, parse_query_string, parse_basic_auth_header,
to_header_key, to_text, to_bytes, json_dumps_default,
Authorization
)
and context (classes, functions, or code) from other files:
# Path: bustard/utils.py
# class MultiDict(collections.UserDict):
#
# def getlist(self, key):
# return self.data[key]
#
# def to_dict(self):
# return self.data
#
# def __getitem__(self, key):
# return self.data[key][-1]
#
# def __setitem__(self, key, value):
# if isinstance(value, (list, tuple)):
# self.data[key] = list(value)
# else:
# self.data[key] = [value]
#
# def __repr__(self):
# return '{}({})'.format(self.__class__.__name__, self.data)
#
# def parse_query_string(query_string, encoding='utf-8'):
# query_dict = collections.defaultdict(list)
# for query_item in query_string.split('&'):
# if '=' not in query_item:
# continue
# keyword, value = query_item.split('=', 1)
# value = urllib.parse.unquote_plus(value)
# query_dict[keyword].append(to_text(value, encoding=encoding))
# return query_dict
#
# def parse_basic_auth_header(value):
# try:
# auth_type, auth_info = to_bytes(value).split(None, 1)
# except ValueError:
# return
# auth_type = auth_type.lower()
#
# if auth_type == b'basic':
# try:
# username, password = base64.b64decode(auth_info).split(b':', 1)
# except (binascii.Error, ValueError):
# return
#
# return Authorization(
# to_text(auth_type),
# username=to_text(username),
# password=to_text(password)
# )
#
# def to_header_key(key):
# return '-'.join(x.capitalize() for x in key.split('-'))
#
# def to_text(st, encoding='utf-8'):
# if isinstance(st, str):
# return st
# elif isinstance(st, collections.ByteString):
# return st.decode(encoding)
# else:
# return str(st)
#
# def to_bytes(bt, encoding='utf-8'):
# if isinstance(bt, collections.ByteString):
# return bt
# elif isinstance(bt, str):
# return bt.encode(encoding)
# else:
# return bytes(bt)
#
# def json_dumps_default(obj):
# if isinstance(obj, collections.UserDict):
# return obj.to_dict()
# return obj
#
# class Authorization:
#
# def __init__(self, _type, username, password):
# self.type = _type
# self.username = username
# self.password = password
#
# def __eq__(self, other):
# return (
# self.type == other.type and
# self.username == other.username and
# self.password == other.password
# )
#
# __hash__ = object.__hash__
#
# def __repr__(self):
# return '{}(type:{}, username:{})'.format(
# self.__class__.__name__, self.type, self.username
# )
. Output only the next line. | assert d.getlist('a') == [1, 2] |
Using the snippet: <|code_start|># -*- coding: utf-8 -*-
def test_multidict():
d = MultiDict({'a': 1, 'b': 'a'})
assert d['a'] == 1
assert d['b'] == 'a'
d['a'] = 2
assert d['a'] == 2
assert d.getlist('a') == [2]
d['a'] = [1, 2]
<|code_end|>
, determine the next line of code. You have imports:
import base64
import json
import pytest
from bustard.utils import (
MultiDict, parse_query_string, parse_basic_auth_header,
to_header_key, to_text, to_bytes, json_dumps_default,
Authorization
)
and context (class names, function names, or code) available:
# Path: bustard/utils.py
# class MultiDict(collections.UserDict):
#
# def getlist(self, key):
# return self.data[key]
#
# def to_dict(self):
# return self.data
#
# def __getitem__(self, key):
# return self.data[key][-1]
#
# def __setitem__(self, key, value):
# if isinstance(value, (list, tuple)):
# self.data[key] = list(value)
# else:
# self.data[key] = [value]
#
# def __repr__(self):
# return '{}({})'.format(self.__class__.__name__, self.data)
#
# def parse_query_string(query_string, encoding='utf-8'):
# query_dict = collections.defaultdict(list)
# for query_item in query_string.split('&'):
# if '=' not in query_item:
# continue
# keyword, value = query_item.split('=', 1)
# value = urllib.parse.unquote_plus(value)
# query_dict[keyword].append(to_text(value, encoding=encoding))
# return query_dict
#
# def parse_basic_auth_header(value):
# try:
# auth_type, auth_info = to_bytes(value).split(None, 1)
# except ValueError:
# return
# auth_type = auth_type.lower()
#
# if auth_type == b'basic':
# try:
# username, password = base64.b64decode(auth_info).split(b':', 1)
# except (binascii.Error, ValueError):
# return
#
# return Authorization(
# to_text(auth_type),
# username=to_text(username),
# password=to_text(password)
# )
#
# def to_header_key(key):
# return '-'.join(x.capitalize() for x in key.split('-'))
#
# def to_text(st, encoding='utf-8'):
# if isinstance(st, str):
# return st
# elif isinstance(st, collections.ByteString):
# return st.decode(encoding)
# else:
# return str(st)
#
# def to_bytes(bt, encoding='utf-8'):
# if isinstance(bt, collections.ByteString):
# return bt
# elif isinstance(bt, str):
# return bt.encode(encoding)
# else:
# return bytes(bt)
#
# def json_dumps_default(obj):
# if isinstance(obj, collections.UserDict):
# return obj.to_dict()
# return obj
#
# class Authorization:
#
# def __init__(self, _type, username, password):
# self.type = _type
# self.username = username
# self.password = password
#
# def __eq__(self, other):
# return (
# self.type == other.type and
# self.username == other.username and
# self.password == other.password
# )
#
# __hash__ = object.__hash__
#
# def __repr__(self):
# return '{}(type:{}, username:{})'.format(
# self.__class__.__name__, self.type, self.username
# )
. Output only the next line. | assert d['a'] == 2 |
Predict the next line after this snippet: <|code_start|>@pytest.mark.parametrize('key, expect', [
('abc', 'Abc'),
('abc_name', 'Abc_name'),
('UserAgent', 'Useragent'),
('user-Agent', 'User-Agent'),
('x-rage', 'X-Rage'),
])
def test_to_header_key(key, expect):
assert to_header_key(key) == expect
@pytest.mark.parametrize('st, expect', [
(b'abc', 'abc'),
('你好'.encode('utf8'), '你好'),
])
def test_to_text(st, expect):
assert to_text(st) == expect
@pytest.mark.parametrize('bt, expect', [
('abc', b'abc'),
('你好', '你好'.encode('utf8')),
])
def test_to_bytes(bt, expect):
assert to_bytes(bt) == expect
@pytest.mark.parametrize('value, expect', [
('', None),
('basic user:passwd', None),
<|code_end|>
using the current file's imports:
import base64
import json
import pytest
from bustard.utils import (
MultiDict, parse_query_string, parse_basic_auth_header,
to_header_key, to_text, to_bytes, json_dumps_default,
Authorization
)
and any relevant context from other files:
# Path: bustard/utils.py
# class MultiDict(collections.UserDict):
#
# def getlist(self, key):
# return self.data[key]
#
# def to_dict(self):
# return self.data
#
# def __getitem__(self, key):
# return self.data[key][-1]
#
# def __setitem__(self, key, value):
# if isinstance(value, (list, tuple)):
# self.data[key] = list(value)
# else:
# self.data[key] = [value]
#
# def __repr__(self):
# return '{}({})'.format(self.__class__.__name__, self.data)
#
# def parse_query_string(query_string, encoding='utf-8'):
# query_dict = collections.defaultdict(list)
# for query_item in query_string.split('&'):
# if '=' not in query_item:
# continue
# keyword, value = query_item.split('=', 1)
# value = urllib.parse.unquote_plus(value)
# query_dict[keyword].append(to_text(value, encoding=encoding))
# return query_dict
#
# def parse_basic_auth_header(value):
# try:
# auth_type, auth_info = to_bytes(value).split(None, 1)
# except ValueError:
# return
# auth_type = auth_type.lower()
#
# if auth_type == b'basic':
# try:
# username, password = base64.b64decode(auth_info).split(b':', 1)
# except (binascii.Error, ValueError):
# return
#
# return Authorization(
# to_text(auth_type),
# username=to_text(username),
# password=to_text(password)
# )
#
# def to_header_key(key):
# return '-'.join(x.capitalize() for x in key.split('-'))
#
# def to_text(st, encoding='utf-8'):
# if isinstance(st, str):
# return st
# elif isinstance(st, collections.ByteString):
# return st.decode(encoding)
# else:
# return str(st)
#
# def to_bytes(bt, encoding='utf-8'):
# if isinstance(bt, collections.ByteString):
# return bt
# elif isinstance(bt, str):
# return bt.encode(encoding)
# else:
# return bytes(bt)
#
# def json_dumps_default(obj):
# if isinstance(obj, collections.UserDict):
# return obj.to_dict()
# return obj
#
# class Authorization:
#
# def __init__(self, _type, username, password):
# self.type = _type
# self.username = username
# self.password = password
#
# def __eq__(self, other):
# return (
# self.type == other.type and
# self.username == other.username and
# self.password == other.password
# )
#
# __hash__ = object.__hash__
#
# def __repr__(self):
# return '{}(type:{}, username:{})'.format(
# self.__class__.__name__, self.type, self.username
# )
. Output only the next line. | ('Basic user:passwd', None), |
Here is a snippet: <|code_start|>@pytest.mark.parametrize('qs, expect', [
('a=b', {'a': ['b']}),
('a=b&a=c', {'a': ['b', 'c']}),
('a=b&d&a=c', {'a': ['b', 'c']}),
('a=b&d=abc&a=c', {'a': ['b', 'c'], 'd': ['abc']}),
])
def test_parse_query_string(qs, expect):
assert parse_query_string(qs) == expect
@pytest.mark.parametrize('key, expect', [
('abc', 'Abc'),
('abc_name', 'Abc_name'),
('UserAgent', 'Useragent'),
('user-Agent', 'User-Agent'),
('x-rage', 'X-Rage'),
])
def test_to_header_key(key, expect):
assert to_header_key(key) == expect
@pytest.mark.parametrize('st, expect', [
(b'abc', 'abc'),
('你好'.encode('utf8'), '你好'),
])
def test_to_text(st, expect):
assert to_text(st) == expect
@pytest.mark.parametrize('bt, expect', [
<|code_end|>
. Write the next line using the current file imports:
import base64
import json
import pytest
from bustard.utils import (
MultiDict, parse_query_string, parse_basic_auth_header,
to_header_key, to_text, to_bytes, json_dumps_default,
Authorization
)
and context from other files:
# Path: bustard/utils.py
# class MultiDict(collections.UserDict):
#
# def getlist(self, key):
# return self.data[key]
#
# def to_dict(self):
# return self.data
#
# def __getitem__(self, key):
# return self.data[key][-1]
#
# def __setitem__(self, key, value):
# if isinstance(value, (list, tuple)):
# self.data[key] = list(value)
# else:
# self.data[key] = [value]
#
# def __repr__(self):
# return '{}({})'.format(self.__class__.__name__, self.data)
#
# def parse_query_string(query_string, encoding='utf-8'):
# query_dict = collections.defaultdict(list)
# for query_item in query_string.split('&'):
# if '=' not in query_item:
# continue
# keyword, value = query_item.split('=', 1)
# value = urllib.parse.unquote_plus(value)
# query_dict[keyword].append(to_text(value, encoding=encoding))
# return query_dict
#
# def parse_basic_auth_header(value):
# try:
# auth_type, auth_info = to_bytes(value).split(None, 1)
# except ValueError:
# return
# auth_type = auth_type.lower()
#
# if auth_type == b'basic':
# try:
# username, password = base64.b64decode(auth_info).split(b':', 1)
# except (binascii.Error, ValueError):
# return
#
# return Authorization(
# to_text(auth_type),
# username=to_text(username),
# password=to_text(password)
# )
#
# def to_header_key(key):
# return '-'.join(x.capitalize() for x in key.split('-'))
#
# def to_text(st, encoding='utf-8'):
# if isinstance(st, str):
# return st
# elif isinstance(st, collections.ByteString):
# return st.decode(encoding)
# else:
# return str(st)
#
# def to_bytes(bt, encoding='utf-8'):
# if isinstance(bt, collections.ByteString):
# return bt
# elif isinstance(bt, str):
# return bt.encode(encoding)
# else:
# return bytes(bt)
#
# def json_dumps_default(obj):
# if isinstance(obj, collections.UserDict):
# return obj.to_dict()
# return obj
#
# class Authorization:
#
# def __init__(self, _type, username, password):
# self.type = _type
# self.username = username
# self.password = password
#
# def __eq__(self, other):
# return (
# self.type == other.type and
# self.username == other.username and
# self.password == other.password
# )
#
# __hash__ = object.__hash__
#
# def __repr__(self):
# return '{}(type:{}, username:{})'.format(
# self.__class__.__name__, self.type, self.username
# )
, which may include functions, classes, or code. Output only the next line. | ('abc', b'abc'), |
Continue the code snippet: <|code_start|>
@pytest.mark.parametrize('key, expect', [
('abc', 'Abc'),
('abc_name', 'Abc_name'),
('UserAgent', 'Useragent'),
('user-Agent', 'User-Agent'),
('x-rage', 'X-Rage'),
])
def test_to_header_key(key, expect):
assert to_header_key(key) == expect
@pytest.mark.parametrize('st, expect', [
(b'abc', 'abc'),
('你好'.encode('utf8'), '你好'),
])
def test_to_text(st, expect):
assert to_text(st) == expect
@pytest.mark.parametrize('bt, expect', [
('abc', b'abc'),
('你好', '你好'.encode('utf8')),
])
def test_to_bytes(bt, expect):
assert to_bytes(bt) == expect
@pytest.mark.parametrize('value, expect', [
<|code_end|>
. Use current file imports:
import base64
import json
import pytest
from bustard.utils import (
MultiDict, parse_query_string, parse_basic_auth_header,
to_header_key, to_text, to_bytes, json_dumps_default,
Authorization
)
and context (classes, functions, or code) from other files:
# Path: bustard/utils.py
# class MultiDict(collections.UserDict):
#
# def getlist(self, key):
# return self.data[key]
#
# def to_dict(self):
# return self.data
#
# def __getitem__(self, key):
# return self.data[key][-1]
#
# def __setitem__(self, key, value):
# if isinstance(value, (list, tuple)):
# self.data[key] = list(value)
# else:
# self.data[key] = [value]
#
# def __repr__(self):
# return '{}({})'.format(self.__class__.__name__, self.data)
#
# def parse_query_string(query_string, encoding='utf-8'):
# query_dict = collections.defaultdict(list)
# for query_item in query_string.split('&'):
# if '=' not in query_item:
# continue
# keyword, value = query_item.split('=', 1)
# value = urllib.parse.unquote_plus(value)
# query_dict[keyword].append(to_text(value, encoding=encoding))
# return query_dict
#
# def parse_basic_auth_header(value):
# try:
# auth_type, auth_info = to_bytes(value).split(None, 1)
# except ValueError:
# return
# auth_type = auth_type.lower()
#
# if auth_type == b'basic':
# try:
# username, password = base64.b64decode(auth_info).split(b':', 1)
# except (binascii.Error, ValueError):
# return
#
# return Authorization(
# to_text(auth_type),
# username=to_text(username),
# password=to_text(password)
# )
#
# def to_header_key(key):
# return '-'.join(x.capitalize() for x in key.split('-'))
#
# def to_text(st, encoding='utf-8'):
# if isinstance(st, str):
# return st
# elif isinstance(st, collections.ByteString):
# return st.decode(encoding)
# else:
# return str(st)
#
# def to_bytes(bt, encoding='utf-8'):
# if isinstance(bt, collections.ByteString):
# return bt
# elif isinstance(bt, str):
# return bt.encode(encoding)
# else:
# return bytes(bt)
#
# def json_dumps_default(obj):
# if isinstance(obj, collections.UserDict):
# return obj.to_dict()
# return obj
#
# class Authorization:
#
# def __init__(self, _type, username, password):
# self.type = _type
# self.username = username
# self.password = password
#
# def __eq__(self, other):
# return (
# self.type == other.type and
# self.username == other.username and
# self.password == other.password
# )
#
# __hash__ = object.__hash__
#
# def __repr__(self):
# return '{}(type:{}, username:{})'.format(
# self.__class__.__name__, self.type, self.username
# )
. Output only the next line. | ('', None), |
Predict the next line after this snippet: <|code_start|>
@pytest.mark.parametrize('st, expect', [
(b'abc', 'abc'),
('你好'.encode('utf8'), '你好'),
])
def test_to_text(st, expect):
assert to_text(st) == expect
@pytest.mark.parametrize('bt, expect', [
('abc', b'abc'),
('你好', '你好'.encode('utf8')),
])
def test_to_bytes(bt, expect):
assert to_bytes(bt) == expect
@pytest.mark.parametrize('value, expect', [
('', None),
('basic user:passwd', None),
('Basic user:passwd', None),
('basic user:{}'.format(base64.b64encode(b'passwd').decode()), None),
('basic {}'.format(base64.b64encode(b'user:passwd').decode()),
Authorization('basic', 'user', 'passwd')
),
('Basic {}'.format(base64.b64encode(b'user:passwd').decode()),
Authorization('basic', 'user', 'passwd')
),
])
<|code_end|>
using the current file's imports:
import base64
import json
import pytest
from bustard.utils import (
MultiDict, parse_query_string, parse_basic_auth_header,
to_header_key, to_text, to_bytes, json_dumps_default,
Authorization
)
and any relevant context from other files:
# Path: bustard/utils.py
# class MultiDict(collections.UserDict):
#
# def getlist(self, key):
# return self.data[key]
#
# def to_dict(self):
# return self.data
#
# def __getitem__(self, key):
# return self.data[key][-1]
#
# def __setitem__(self, key, value):
# if isinstance(value, (list, tuple)):
# self.data[key] = list(value)
# else:
# self.data[key] = [value]
#
# def __repr__(self):
# return '{}({})'.format(self.__class__.__name__, self.data)
#
# def parse_query_string(query_string, encoding='utf-8'):
# query_dict = collections.defaultdict(list)
# for query_item in query_string.split('&'):
# if '=' not in query_item:
# continue
# keyword, value = query_item.split('=', 1)
# value = urllib.parse.unquote_plus(value)
# query_dict[keyword].append(to_text(value, encoding=encoding))
# return query_dict
#
# def parse_basic_auth_header(value):
# try:
# auth_type, auth_info = to_bytes(value).split(None, 1)
# except ValueError:
# return
# auth_type = auth_type.lower()
#
# if auth_type == b'basic':
# try:
# username, password = base64.b64decode(auth_info).split(b':', 1)
# except (binascii.Error, ValueError):
# return
#
# return Authorization(
# to_text(auth_type),
# username=to_text(username),
# password=to_text(password)
# )
#
# def to_header_key(key):
# return '-'.join(x.capitalize() for x in key.split('-'))
#
# def to_text(st, encoding='utf-8'):
# if isinstance(st, str):
# return st
# elif isinstance(st, collections.ByteString):
# return st.decode(encoding)
# else:
# return str(st)
#
# def to_bytes(bt, encoding='utf-8'):
# if isinstance(bt, collections.ByteString):
# return bt
# elif isinstance(bt, str):
# return bt.encode(encoding)
# else:
# return bytes(bt)
#
# def json_dumps_default(obj):
# if isinstance(obj, collections.UserDict):
# return obj.to_dict()
# return obj
#
# class Authorization:
#
# def __init__(self, _type, username, password):
# self.type = _type
# self.username = username
# self.password = password
#
# def __eq__(self, other):
# return (
# self.type == other.type and
# self.username == other.username and
# self.password == other.password
# )
#
# __hash__ = object.__hash__
#
# def __repr__(self):
# return '{}(type:{}, username:{})'.format(
# self.__class__.__name__, self.type, self.username
# )
. Output only the next line. | def test_parse_basic_auth_header(value, expect): |
Predict the next line for this snippet: <|code_start|># You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#
with open(os.path.join(os.path.dirname(__file__), 'sampleresult.json')) as f:
SAMPLE_RESULT = json.loads(f.read())
@Vows.batch
class TheDetailedResponseMapper(Vows.Context):
def topic(self):
return (SAMPLE_RESULT, detailed_response_mapper(SAMPLE_RESULT))
def shouldReturnTheListOfDocuments(self, (solr, result)):
expect(result['docs']).to_equal(solr['response']['docs'])
class shouldContainTheFieldFacet(Vows.Context):
<|code_end|>
with the help of current file imports:
import os.path
import json
from pyvows import Vows, expect
from dopplr.solr.responsemapper import detailed_response_mapper
and context from other files:
# Path: dopplr/solr/responsemapper.py
# def detailed_response_mapper(solr_response):
# """
# Response mapper that also extracts the returned facets into a dict. In
# order to keep the sort order, a separate list contains the keys for the
# facet dictionary in sorted order.
# """
# result = {
# 'docs': [],
# 'numFound': 0
# }
#
# if 'response' in solr_response:
# result['numFound'] = solr_response['response']['numFound']
# result['docs'] = solr_response['response']['docs']
#
# if 'facet_counts' in solr_response:
#
# result['facet'] = {}
# facets = solr_response['facet_counts']
#
# if 'facet_fields' in facets:
# result['facet']['field'] = rf = {}
# for field in facets['facet_fields']:
# rf[field] = _flatten_to_dict(facets['facet_fields'][field])
#
# if 'facet_queries' in facets:
# result['facet']['query'] = rq = {}
# for query in facets['facet_queries']:
# rq[query] = _flatten_to_dict(facets['facet_queries'][query])
#
# if 'facet_ranges' in facets:
# result['facet']['range'] = rr = {}
# for frange in facets['facet_ranges']:
# rr[frange] = \
# _flatten_to_dict(facets['facet_ranges'][frange]['counts'])
# rr[frange]['start'] = facets['facet_ranges'][frange]['start']
# rr[frange]['end'] = facets['facet_ranges'][frange]['end']
# rr[frange]['gap'] = facets['facet_ranges'][frange]['gap']
#
# return result
, which may contain function names, class names, or code. Output only the next line. | def topic(self, (solr, result)): |
Continue the code snippet: <|code_start|># http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#
@Vows.batch
class AHighlightingQuery(Vows.Context):
class WithRequiredParams(Vows.Context):
def topic(self):
return Highlighting(['title']).get_params()
def mustActivateHighlighting(self, topic):
expect(topic).to_include(('hl', 'true'))
def mustIncludeTheHighlightingFields(self, topic):
expect(topic).to_include(('hl.fl', 'title'))
def mustIncludeThePreTag(self, topic):
expect(topic).to_include(('hl.simple.pre', '<em>'))
def mustIncludeThePostTag(self, topic):
<|code_end|>
. Use current file imports:
from pyvows import Vows, expect
from dopplr.solr.query import Highlighting
and context (classes, functions, or code) from other files:
# Path: dopplr/solr/query/highlighting.py
# class Highlighting(BaseQuery):
# """
# Highlighting with solr.
# """
#
# def __init__(self, fields, fragsize=100, pre='<em>', post='</em>'):
# """
# Initialize the query value.
# """
# self.__fields = fields
# self.__pre = pre
# self.__post = post
# self.__fragsize = fragsize
#
# def get_params(self):
# """
# Return the list of query params.
# """
# result_list = list()
# result_list.append(('hl', 'true'))
# result_list.append(('hl.fl', ",".join(self.__fields)))
# result_list.append(('hl.simple.pre', self.__pre))
# result_list.append(('hl.simple.post', self.__post))
# result_list.append(('hl.fragsize', self.__fragsize))
# return result_list
. Output only the next line. | expect(topic).to_include(('hl.simple.post', '</em>')) |
Predict the next line for this snippet: <|code_start|># distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#
@Vows.batch
class SimpleQueries(Vows.Context):
def topic(self):
return Query('content:(foo OR bar)').get_params()
def mustMatch(self, topic):
expect(topic).to_include(('q', 'content:(foo OR bar)'))
def mustHaveNoOtherQueries(self, topic):
expect(topic).to_length(1)
@Vows.batch
class SimpleFilterQueries(Vows.Context):
class MustBeSimple(Vows.Context):
def topic(self):
return FilterQuery('category:Test').get_params()
<|code_end|>
with the help of current file imports:
from pyvows import Vows, expect
from dopplr.solr.query.query import Query
from dopplr.solr.query.query import FilterQuery
and context from other files:
# Path: dopplr/solr/query/query.py
# class Query(BaseQuery):
# """
# The most simple Solr query: `q`.
# """
#
# def __init__(self, query):
# """
# Initialize the query value.
# """
# self.__query = query
#
# def get_params(self):
# """
# Return the list of query params.
# """
# return [('q', self.__query)]
#
# Path: dopplr/solr/query/query.py
# class FilterQuery(BaseQuery):
# """
# A `FilterQuery`.
# """
#
# def __init__(self, query, tag=None):
# """
# Set the query value.
# """
# self.__query = query
# self.__tag = tag
#
# def get_params(self):
# """
# Return the list of query params.
# """
# if self.__tag:
# return [('fq', '{!tag=%s}%s' % (self.__tag, self.__query))]
# return [('fq', self.__query)]
, which may contain function names, class names, or code. Output only the next line. | def mustMatch(self, topic): |
Predict the next line after this snippet: <|code_start|> 'maxwl',
'maxqt',
'maxntp',
'boost',
'qf',
'count']
for v in valid_params:
kwargs = {v: 'a'}
q = MoreLikeThisQuery(['content'], **kwargs)
yield (v, q.get_params())
def mltOnMustBePresent(self, (field, params)):
expect(params).to_include(('mlt', 'true'))
def mltFieldsMustBeCorrect(self, (field, params)):
expect(params).to_include(('mlt.fl', 'content'))
def theNumberOfParamsMatches(self, (field, params)):
expect(params).to_length(3)
def theQueryMustMatch(self, (field, params)):
expect(params).to_include(('mlt.%s' % field, 'a'))
class WithAStreamBody(Vows.Context):
def topic(self):
return MoreLikeThisQuery(['content'], stream_body="b").get_params()
def mltOnMustBePresent(self, topic):
<|code_end|>
using the current file's imports:
from pyvows import Vows, expect
from dopplr.solr.query.mlt import MoreLikeThisQuery
and any relevant context from other files:
# Path: dopplr/solr/query/mlt.py
# class MoreLikeThisQuery(BaseQuery):
# """
# The `MoreLikeThisQuery` queries for similiar items. It can be used in
# addition to a `/select` query, or with a configured `MoreLikeThisHandler`.
# """
#
# def __init__(self, fields, mintf=None, mindf=None, minwl=None, maxwl=None,
# maxqt=None, maxntp=None, boost=False, qf=None, count=None,
# stream_body=None):
# """
# `fields` is a list of field names the mlt is based on.
# """
# if not isinstance(fields, types.ListType):
# raise TypeError('fields must be a list')
# self._fields = fields
# self._optional_params = {}
# self._optional_params['mintf'] = mintf
# self._optional_params['mindf'] = mindf
# self._optional_params['minwl'] = minwl
# self._optional_params['maxwl'] = maxwl
# self._optional_params['maxqt'] = maxqt
# self._optional_params['maxntp'] = maxntp
# self._optional_params['boost'] = boost
# self._optional_params['qf'] = qf
# self._optional_params['count'] = count
# self.stream_body = stream_body
#
# def get_params(self):
# """
# Return the list of query params for the mlt query.
# """
# params = []
# params.append(('mlt', 'true'))
# params.append(('mlt.fl', ','.join(self._fields)))
#
# for optional in self._optional_params:
# if self._optional_params[optional]:
# params.append(('mlt.%s' % optional,
# self._optional_params[optional]))
#
# if self.stream_body:
# params.append(('stream.body', self.stream_body))
#
# return params
. Output only the next line. | expect(topic).to_include(('mlt', 'true')) |
Using the snippet: <|code_start|> return SpatialQuery(lat, lon, sfield).get_params()
def mustIncludeFunctionTypeParameter(self, topic):
expect(topic).to_include(('fq', '{!geofilt}'))
def mustIncludeCorrectlyFormattedPoint(self, topic):
expect(topic).to_include(('pt', '0.0,0.0'))
def mustIncludeDistanceParameter(self, topic):
expect(topic).to_include(('d', 5))
def mustIncludeSpatialFieldParameter(self, topic):
expect(topic).to_include(('sfield', 'my_field'))
class WithBboxSpatialQuery(WithDefaultParams):
def topic(self):
lat = 0.0
lon = 0.0
sfield = "my_field"
return BoundingBoxSpatialQuery(lat, lon, sfield).get_params()
def mustIncludeFunctionTypeParameter(self, topic):
expect(topic).to_include(('fq', '{!bbox}'))
class WithCustomDistanceParameter(WithDefaultParams):
def topic(self):
lat = 0.0
lon = 0.0
<|code_end|>
, determine the next line of code. You have imports:
from pyvows import Vows, expect
from dopplr.solr.query import BoundingBoxSpatialQuery
from dopplr.solr.query import GeofiltSpatialQuery
from dopplr.solr.query import SpatialQuery
and context (class names, function names, or code) available:
# Path: dopplr/solr/query/spatial.py
# class BoundingBoxSpatialQuery(SpatialQuery):
# """
# `BoundingBoxSpatialQuery` to search with bbox functionality
# param lat the latitute point part
# param lon the lontitude point part
# param sfield the location type field
# param distance the radius around the given location
# """
# def __init__(self, lat, lon, sfield, distance=5):
# super(BoundingBoxSpatialQuery, self).__init__(lat, lon, sfield,
# function_type='bbox', distance=distance)
#
# Path: dopplr/solr/query/spatial.py
# class GeofiltSpatialQuery(SpatialQuery):
# """
# `GeofiltSpatialQuery` to search with geofilt functionality
# param lat the latitute point part
# param lon the lontitude point part
# param sfield the location type field
# param distance the radius around the given location
# """
# def __init__(self, lat, lon, sfield, distance=5):
# super(GeofiltSpatialQuery, self).__init__(lat, lon, sfield,
# function_type='geofilt', distance=distance)
#
# Path: dopplr/solr/query/spatial.py
# class SpatialQuery(BaseQuery):
# """
# `SpatialQuery` to search with geolocations
# param lat the latitute point part
# param lon the lontitude point part
# param sfield the location type field
# param function_type is one of {geofilt, bbox}
# param distance the radius around the given location
# """
# def __init__(self, lat, lon, sfield, function_type='geofilt', distance=5):
# super(SpatialQuery, self).__init__()
# self.__lat = lat
# self.__lon = lon
# self.__sfield = sfield
# self.__function_type = function_type
# self.__distance = distance
#
# def get_params(self):
# params = []
# params.append(('fq', '{!%s}' % (self.__function_type)))
# params.append(('sfield', self.__sfield))
# params.append(('pt', '%s,%s' % (self.__lat, self.__lon)))
# params.append(('d', self.__distance))
# return params
. Output only the next line. | sfield = "my_field" |
Using the snippet: <|code_start|> sfield = "my_field"
return SpatialQuery(lat, lon, sfield).get_params()
def mustIncludeFunctionTypeParameter(self, topic):
expect(topic).to_include(('fq', '{!geofilt}'))
def mustIncludeCorrectlyFormattedPoint(self, topic):
expect(topic).to_include(('pt', '0.0,0.0'))
def mustIncludeDistanceParameter(self, topic):
expect(topic).to_include(('d', 5))
def mustIncludeSpatialFieldParameter(self, topic):
expect(topic).to_include(('sfield', 'my_field'))
class WithBboxSpatialQuery(WithDefaultParams):
def topic(self):
lat = 0.0
lon = 0.0
sfield = "my_field"
return BoundingBoxSpatialQuery(lat, lon, sfield).get_params()
def mustIncludeFunctionTypeParameter(self, topic):
expect(topic).to_include(('fq', '{!bbox}'))
class WithCustomDistanceParameter(WithDefaultParams):
def topic(self):
lat = 0.0
<|code_end|>
, determine the next line of code. You have imports:
from pyvows import Vows, expect
from dopplr.solr.query import BoundingBoxSpatialQuery
from dopplr.solr.query import GeofiltSpatialQuery
from dopplr.solr.query import SpatialQuery
and context (class names, function names, or code) available:
# Path: dopplr/solr/query/spatial.py
# class BoundingBoxSpatialQuery(SpatialQuery):
# """
# `BoundingBoxSpatialQuery` to search with bbox functionality
# param lat the latitute point part
# param lon the lontitude point part
# param sfield the location type field
# param distance the radius around the given location
# """
# def __init__(self, lat, lon, sfield, distance=5):
# super(BoundingBoxSpatialQuery, self).__init__(lat, lon, sfield,
# function_type='bbox', distance=distance)
#
# Path: dopplr/solr/query/spatial.py
# class GeofiltSpatialQuery(SpatialQuery):
# """
# `GeofiltSpatialQuery` to search with geofilt functionality
# param lat the latitute point part
# param lon the lontitude point part
# param sfield the location type field
# param distance the radius around the given location
# """
# def __init__(self, lat, lon, sfield, distance=5):
# super(GeofiltSpatialQuery, self).__init__(lat, lon, sfield,
# function_type='geofilt', distance=distance)
#
# Path: dopplr/solr/query/spatial.py
# class SpatialQuery(BaseQuery):
# """
# `SpatialQuery` to search with geolocations
# param lat the latitute point part
# param lon the lontitude point part
# param sfield the location type field
# param function_type is one of {geofilt, bbox}
# param distance the radius around the given location
# """
# def __init__(self, lat, lon, sfield, function_type='geofilt', distance=5):
# super(SpatialQuery, self).__init__()
# self.__lat = lat
# self.__lon = lon
# self.__sfield = sfield
# self.__function_type = function_type
# self.__distance = distance
#
# def get_params(self):
# params = []
# params.append(('fq', '{!%s}' % (self.__function_type)))
# params.append(('sfield', self.__sfield))
# params.append(('pt', '%s,%s' % (self.__lat, self.__lon)))
# params.append(('d', self.__distance))
# return params
. Output only the next line. | lon = 0.0 |
Given snippet: <|code_start|>#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#
@Vows.batch
class TheSpatialQuery(Vows.Context):
class WithDefaultParams(Vows.Context):
def topic(self):
lat = 0.0
lon = 0.0
sfield = "my_field"
return SpatialQuery(lat, lon, sfield).get_params()
def mustIncludeFunctionTypeParameter(self, topic):
expect(topic).to_include(('fq', '{!geofilt}'))
def mustIncludeCorrectlyFormattedPoint(self, topic):
expect(topic).to_include(('pt', '0.0,0.0'))
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from pyvows import Vows, expect
from dopplr.solr.query import BoundingBoxSpatialQuery
from dopplr.solr.query import GeofiltSpatialQuery
from dopplr.solr.query import SpatialQuery
and context:
# Path: dopplr/solr/query/spatial.py
# class BoundingBoxSpatialQuery(SpatialQuery):
# """
# `BoundingBoxSpatialQuery` to search with bbox functionality
# param lat the latitute point part
# param lon the lontitude point part
# param sfield the location type field
# param distance the radius around the given location
# """
# def __init__(self, lat, lon, sfield, distance=5):
# super(BoundingBoxSpatialQuery, self).__init__(lat, lon, sfield,
# function_type='bbox', distance=distance)
#
# Path: dopplr/solr/query/spatial.py
# class GeofiltSpatialQuery(SpatialQuery):
# """
# `GeofiltSpatialQuery` to search with geofilt functionality
# param lat the latitute point part
# param lon the lontitude point part
# param sfield the location type field
# param distance the radius around the given location
# """
# def __init__(self, lat, lon, sfield, distance=5):
# super(GeofiltSpatialQuery, self).__init__(lat, lon, sfield,
# function_type='geofilt', distance=distance)
#
# Path: dopplr/solr/query/spatial.py
# class SpatialQuery(BaseQuery):
# """
# `SpatialQuery` to search with geolocations
# param lat the latitute point part
# param lon the lontitude point part
# param sfield the location type field
# param function_type is one of {geofilt, bbox}
# param distance the radius around the given location
# """
# def __init__(self, lat, lon, sfield, function_type='geofilt', distance=5):
# super(SpatialQuery, self).__init__()
# self.__lat = lat
# self.__lon = lon
# self.__sfield = sfield
# self.__function_type = function_type
# self.__distance = distance
#
# def get_params(self):
# params = []
# params.append(('fq', '{!%s}' % (self.__function_type)))
# params.append(('sfield', self.__sfield))
# params.append(('pt', '%s,%s' % (self.__lat, self.__lon)))
# params.append(('d', self.__distance))
# return params
which might include code, classes, or functions. Output only the next line. | def mustIncludeDistanceParameter(self, topic): |
Predict the next line after this snippet: <|code_start|>
@Vows.batch
class TheSimpleBoostQuery(Vows.Context):
def topic(self):
return BoostQuery('test:Title').get_params()
def shouldContainTheBqParameter(self, topic):
expect(topic).to_include(('bq', 'test:Title'))
@Vows.batch
class TheBoostFunctionQuery(Vows.Context):
class WithRequiredParams(Vows.Context):
def topic(self):
return BoostFunctionQuery('test:This').get_params()
def shouldIncludeTheBfParameter(self, topic):
expect(topic).to_include(('bf', 'test:This'))
class WithAnExternalBoostingParameter(Vows.Context):
def topic(self):
q = BoostFunctionQuery('test:This + $date', date='123')
return q.get_params()
def shouldIncludeTheBfParameter(self, topic):
<|code_end|>
using the current file's imports:
from pyvows import Vows, expect
from dopplr.solr.query import BoostQuery
from dopplr.solr.query import BoostFunctionQuery
and any relevant context from other files:
# Path: dopplr/solr/query/boostquery.py
# class BoostQuery(BaseQuery):
# """
# A boosting query.
# """
#
# def __init__(self, boostquery):
# """
# Add `boostqueries`.
# """
# self.__boostquery = boostquery
#
# def get_params(self):
# """
# Return the list of query params for the `BoostQuery`.
# """
# params = []
# params.append(('bq', self.__boostquery))
#
# return params
#
# Path: dopplr/solr/query/boostquery.py
# class BoostFunctionQuery(BaseQuery):
# """
# A boosting function query.
# """
#
# def __init__(self, boostfunction, **kwargs):
# """
# Add `boostfunctions` and possible external boosting parameters.
# """
# self.__boostfunction = boostfunction
# self.__external_boost_params = []
# for arg in kwargs:
# if "$" + arg in self.__boostfunction:
# self.__external_boost_params.append((arg, kwargs[arg]))
#
# def get_params(self):
# """
# Return the list of query params for the `BoostFunctionQuery`.
# """
# params = []
# params.append(('bf', self.__boostfunction))
# params.extend(self.__external_boost_params)
#
# return params
. Output only the next line. | expect(topic).to_include(('bf', 'test:This + $date')) |
Based on the snippet: <|code_start|>
@Vows.batch
class TheBoostFunctionQuery(Vows.Context):
class WithRequiredParams(Vows.Context):
def topic(self):
return BoostFunctionQuery('test:This').get_params()
def shouldIncludeTheBfParameter(self, topic):
expect(topic).to_include(('bf', 'test:This'))
class WithAnExternalBoostingParameter(Vows.Context):
def topic(self):
q = BoostFunctionQuery('test:This + $date', date='123')
return q.get_params()
def shouldIncludeTheBfParameter(self, topic):
expect(topic).to_include(('bf', 'test:This + $date'))
def shouldInlcudeTheExternalParameter(self, topic):
expect(topic).to_include(('date', '123'))
class WithAnExternalButUnreferencedParameter(WithRequiredParams):
def topic(self):
q = BoostFunctionQuery('test:This', date='123')
return q.get_params()
<|code_end|>
, predict the immediate next line with the help of imports:
from pyvows import Vows, expect
from dopplr.solr.query import BoostQuery
from dopplr.solr.query import BoostFunctionQuery
and context (classes, functions, sometimes code) from other files:
# Path: dopplr/solr/query/boostquery.py
# class BoostQuery(BaseQuery):
# """
# A boosting query.
# """
#
# def __init__(self, boostquery):
# """
# Add `boostqueries`.
# """
# self.__boostquery = boostquery
#
# def get_params(self):
# """
# Return the list of query params for the `BoostQuery`.
# """
# params = []
# params.append(('bq', self.__boostquery))
#
# return params
#
# Path: dopplr/solr/query/boostquery.py
# class BoostFunctionQuery(BaseQuery):
# """
# A boosting function query.
# """
#
# def __init__(self, boostfunction, **kwargs):
# """
# Add `boostfunctions` and possible external boosting parameters.
# """
# self.__boostfunction = boostfunction
# self.__external_boost_params = []
# for arg in kwargs:
# if "$" + arg in self.__boostfunction:
# self.__external_boost_params.append((arg, kwargs[arg]))
#
# def get_params(self):
# """
# Return the list of query params for the `BoostFunctionQuery`.
# """
# params = []
# params.append(('bf', self.__boostfunction))
# params.extend(self.__external_boost_params)
#
# return params
. Output only the next line. | def shouldNotIncludeTheExternalParam(self, topic): |
Next line prediction: <|code_start|># Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#
@Vows.batch
class TheSpellcheckQuery(Vows.Context):
class WithDefaultParams(Vows.Context):
def topic(self):
return Spellcheck().get_params()
def mustActivateSpellchecking(self, topic):
expect(topic).to_include(('spellcheck', 'true'))
def mustIncludeTheCollateParam(self, topic):
expect(topic).to_include(('spellcheck.collate', 'true'))
<|code_end|>
. Use current file imports:
(from pyvows import Vows, expect
from dopplr.solr.query import Spellcheck)
and context including class names, function names, or small code snippets from other files:
# Path: dopplr/solr/query/spellcheck.py
# class Spellcheck(BaseQuery):
# """
# `Did you mean`?
#
# See: http://wiki.apache.org/solr/SpellCheckComponent
# """
#
# def __init__(self, count=None, collate=True, onlyMorePopular=True,
# dictionary=None):
# """
# Initialize the query value.
# """
# self.__count = count
# self.__collate = collate
# self.__onlyMorePopular = onlyMorePopular
# self.__dictionary = dictionary
#
# def get_params(self):
# """
# Return the list of query params.
# """
# params = []
# params.append(('spellcheck', 'true'))
#
# if self.__count:
# params.append(('spellcheck.count', str(self.__count)))
#
# if self.__collate:
# params.append(('spellcheck.collate', 'true'))
# else:
# params.append(('spellcheck.collate', 'false'))
#
# if self.__onlyMorePopular:
# params.append(('spellcheck.onlyMorePopular', 'true'))
# else:
# params.append(('spellcheck.onlyMorePopular', 'false'))
#
# if self.__dictionary:
# params.append(('spellcheck.dictionary', self.__dictionary))
#
# return params
. Output only the next line. | def mustIncludeTheOnlyMorePopularParam(self, topic): |
Based on the snippet: <|code_start|># See the License for the specific language governing permissions and
# limitations under the License.
#
#
@Vows.batch
class WhenDoingJoins(Vows.Context):
class WithinTheQuery(Vows.Context):
def topic(self):
from_field = "from_field"
to_field = "to_field"
query = "*:*"
return JoinQuery(query, from_field, to_field).get_params()
def mustIncludeJoinParameter(self, topic):
expect(topic).to_include(('q', '{!join}*:*'))
def mustIncludeFromParameter(self, topic):
expect(topic).to_include(('from', 'from_field'))
def mustIncludeToParameter(self, topic):
expect(topic).to_include(('to', 'to_field'))
class WithinTheFilterQuery(Vows.Context):
def topic(self):
<|code_end|>
, predict the immediate next line with the help of imports:
from pyvows import Vows, expect
from dopplr.solr.query import JoinQuery
from dopplr.solr.query import JoinFilterQuery
and context (classes, functions, sometimes code) from other files:
# Path: dopplr/solr/query/join.py
# class JoinQuery(JoinBaseQuery):
# """
# A join query.
# """
#
# def __init__(self, query, from_field, to_field):
# super(JoinQuery, self).__init__(query, from_field, to_field)
#
# def get_params(self):
# """
# Return the list of query params for the `JoinQuery`.
# """
# params = super(JoinQuery, self).get_params()
# params.append(('q', self._query))
#
# return params
#
# Path: dopplr/solr/query/join.py
# class JoinFilterQuery(JoinBaseQuery):
# """
# A join filter query.
# """
#
# def __init__(self, query, from_field, to_field):
# super(JoinFilterQuery, self).__init__(query, from_field, to_field)
#
# def get_params(self):
# """
# Return the list of query params for the `JoinFilterQuery`.
# """
# params = super(JoinFilterQuery, self).get_params()
# params.append(('fq', self._query))
#
# return params
. Output only the next line. | from_field = "from_field" |
Predict the next line for this snippet: <|code_start|># Copyright (c) 2011 Daniel Truemper <truemped at googlemail.com>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#
@Vows.batch
class PagingQueries(Vows.Context):
class MustBeCalculatedCorrectly(Vows.Context):
def topic(self):
test_data = [
{'rows': 10, 'page': 2, 'expected':{'rows': '10', 'start': '10'}},
{'rows': 20, 'page': 2, 'expected':{'rows': '20', 'start': '20'}},
{'rows': 30, 'page': 4, 'expected':{'rows': '30', 'start': '90'}},
{'rows': 8, 'page': 4, 'expected':{'rows': '8', 'start': '24'}},
]
<|code_end|>
with the help of current file imports:
from pyvows import Vows, expect
from dopplr.solr.query.paging import Paging
and context from other files:
# Path: dopplr/solr/query/paging.py
# class Paging(BaseQuery):
# """
# Query implementing search result paging. Paging is implemented `1` based,
# i.e. the first page is `1` not `0`!
# """
# def __init__(self, page, rows=10):
# self._page = page
# self._rows = rows
#
# def get_params(self):
# """
# Compute the `start` and `rows` parameter.
# """
# params = []
# params.append(('rows', str(self._rows)))
# if self._page > 1:
# params.append(('start', str((self._page - 1) * self._rows)))
#
# return params
, which may contain function names, class names, or code. Output only the next line. | for data in test_data: |
Predict the next line for this snippet: <|code_start|>#
#
@Vows.batch
class WhenGroupingResults(Vows.Context):
class WithNoParametersExceptTheField(Vows.Context):
def topic(self):
field = "my_field"
return ResultGrouping(field).get_params()
def mustIncludeGroupingParameter(self, topic):
expect(topic).to_include(('group', 'true'))
def mustIncludeTheCorrectField(self, topic):
expect(topic).to_include(('group.field', 'my_field'))
class WithManyAdditionalParameters(WithNoParametersExceptTheField):
def topic(self):
field = "my_field"
return ResultGrouping(field, limit=10, offset=20,
query="field:value").get_params()
def mustIncludeTheCorrectParameters(self, topic):
expect(topic).to_include(('group.limit', '10'))
expect(topic).to_include(('group.offset', '20'))
<|code_end|>
with the help of current file imports:
from pyvows import Vows, expect
from dopplr.solr.query import ResultGrouping
and context from other files:
# Path: dopplr/solr/query/grouping.py
# class ResultGrouping(BaseQuery):
# """
# Enable result grouping for a Solr query
# """
#
# def __init__(self, field, func=None, query=None, limit=None, offset=None,
# sort=None, format=None, main=None, ngroups=None, truncate=None,
# facet=None, cache_percent=None):
# self._params = []
# local_vars = locals()
# # the Solr parameter syntax is always the same: prepend "group." to the
# # variable name if it is set and add it to the parameter list
# for name in filter(lambda x: x != 'self' and local_vars[x] is not None,
# local_vars):
# self._params.append(('group.' + name.replace("_", "."),
# str(local_vars[name])))
#
# def get_params(self):
# """
# Return the list of query params for `ResultGrouping`.
# """
# return [('group', 'true')] + self._params
, which may contain function names, class names, or code. Output only the next line. | expect(topic).to_include(('group.query', 'field:value')) |
Given the code snippet: <|code_start|>
def noUnexpectedArgs(self, topic):
expect(topic).to_length(2)
class WithOptionalParameters(WithDefaultParams):
def topic(self):
valid_params = [
'alt',
'mm',
'pf',
'ps',
'qs',
'tie',
'bq',
'bf'
]
for v in valid_params:
kwargs = {v: 'a'}
q = DisMax('title^2 body^1', edismax=False, **kwargs)
yield (v, q.get_params())
def theDefTypeMustMatch(self, (field, params)):
expect(params).to_include(('defType', 'dismax'))
def theQueryFieldsMatch(self, (field, params)):
expect(params).to_include(('qf', 'title^2 body^1'))
def noUnexpectedArgs(self, (field, params)):
<|code_end|>
, generate the next line using the imports in this file:
from pyvows import Vows, expect
from dopplr.solr.query.dismax import DisMax
and context (functions, classes, or occasionally code) from other files:
# Path: dopplr/solr/query/dismax.py
# class DisMax(BaseQuery):
# """
# The dismax query.
# """
#
# def __init__(self, qf, alt=None, mm=None, pf=None, ps=None, qs=None,
# tie=None, bq=None, bf=None, edismax=True):
# """
# Initialize the query values.
# """
# self.__qf = qf
# if edismax:
# self.__deftype = 'edismax'
# else:
# self.__deftype = 'dismax'
# self.__optional_params = {
# 'q.alt': alt,
# 'mm': mm,
# 'pf': pf,
# 'ps': ps,
# 'qs': qs,
# 'tie': tie,
# 'bq': bq,
# 'bf': bf
# }
#
# def get_params(self):
# """
# Return the list of query params.
# """
# params = []
# params.append(('defType', self.__deftype))
# params.append(('qf', self.__qf))
#
# for p in self.__optional_params:
# if self.__optional_params[p]:
# params.append((p, self.__optional_params[p]))
#
# return params
. Output only the next line. | expect(params).to_length(3) |
Predict the next line for this snippet: <|code_start|>
if __name__ == "__main__":
app = create_qapp()
database = get_database()
<|code_end|>
with the help of current file imports:
from datetime import datetime
from vnpy.trader.ui import create_qapp, QtCore
from vnpy.trader.constant import Exchange, Interval
from vnpy.trader.database import get_database
from vnpy.chart import ChartWidget, VolumeItem, CandleItem
and context from other files:
# Path: vnpy/trader/ui/qt.py
# def create_qapp(app_name: str = "Veighna Trader") -> QtWidgets.QApplication:
# def excepthook(exctype: type, value: Exception, tb: types.TracebackType) -> None:
# def __init__(self, parent: QtWidgets.QWidget = None):
# def init_ui(self) -> None:
# def show_exception(self, msg: str) -> None:
# def _copy_text(self) -> None:
# def _open_community(self) -> None:
# class ExceptionWidget(QtWidgets.QWidget):
#
# Path: vnpy/trader/constant.py
# class Exchange(Enum):
# """
# Exchange.
# """
# # Chinese
# CFFEX = "CFFEX" # China Financial Futures Exchange
# SHFE = "SHFE" # Shanghai Futures Exchange
# CZCE = "CZCE" # Zhengzhou Commodity Exchange
# DCE = "DCE" # Dalian Commodity Exchange
# INE = "INE" # Shanghai International Energy Exchange
# SSE = "SSE" # Shanghai Stock Exchange
# SZSE = "SZSE" # Shenzhen Stock Exchange
# BSE = "BSE" # Beijing Stock Exchange
# SGE = "SGE" # Shanghai Gold Exchange
# WXE = "WXE" # Wuxi Steel Exchange
# CFETS = "CFETS" # CFETS Bond Market Maker Trading System
# XBOND = "XBOND" # CFETS X-Bond Anonymous Trading System
#
# # Global
# SMART = "SMART" # Smart Router for US stocks
# NYSE = "NYSE" # New York Stock Exchnage
# NASDAQ = "NASDAQ" # Nasdaq Exchange
# ARCA = "ARCA" # ARCA Exchange
# EDGEA = "EDGEA" # Direct Edge Exchange
# ISLAND = "ISLAND" # Nasdaq Island ECN
# BATS = "BATS" # Bats Global Markets
# IEX = "IEX" # The Investors Exchange
# NYMEX = "NYMEX" # New York Mercantile Exchange
# COMEX = "COMEX" # COMEX of CME
# GLOBEX = "GLOBEX" # Globex of CME
# IDEALPRO = "IDEALPRO" # Forex ECN of Interactive Brokers
# CME = "CME" # Chicago Mercantile Exchange
# ICE = "ICE" # Intercontinental Exchange
# SEHK = "SEHK" # Stock Exchange of Hong Kong
# HKFE = "HKFE" # Hong Kong Futures Exchange
# SGX = "SGX" # Singapore Global Exchange
# CBOT = "CBT" # Chicago Board of Trade
# CBOE = "CBOE" # Chicago Board Options Exchange
# CFE = "CFE" # CBOE Futures Exchange
# DME = "DME" # Dubai Mercantile Exchange
# EUREX = "EUX" # Eurex Exchange
# APEX = "APEX" # Asia Pacific Exchange
# LME = "LME" # London Metal Exchange
# BMD = "BMD" # Bursa Malaysia Derivatives
# TOCOM = "TOCOM" # Tokyo Commodity Exchange
# EUNX = "EUNX" # Euronext Exchange
# KRX = "KRX" # Korean Exchange
# OTC = "OTC" # OTC Product (Forex/CFD/Pink Sheet Equity)
# IBKRATS = "IBKRATS" # Paper Trading Exchange of IB
#
# # Special Function
# LOCAL = "LOCAL" # For local generated data
#
# class Interval(Enum):
# """
# Interval of bar data.
# """
# MINUTE = "1m"
# HOUR = "1h"
# DAILY = "d"
# WEEKLY = "w"
# TICK = "tick"
#
# Path: vnpy/trader/database.py
# def get_database() -> BaseDatabase:
# """"""
# # Return database object if already inited
# global database
# if database:
# return database
#
# # Read database related global setting
# database_name: str = SETTINGS["database.name"]
# module_name: str = f"vnpy_{database_name}"
#
# # Try to import database module
# try:
# module = import_module(module_name)
# except ModuleNotFoundError:
# print(f"找不到数据库驱动{module_name}，使用默认的SQLite数据库")
# module = import_module("vnpy_sqlite")
#
# # Create database object from module
# database = module.Database()
# return database
, which may contain function names, class names, or code. Output only the next line. | bars = database.load_bar_data( |
Based on the snippet: <|code_start|>
if __name__ == "__main__":
app = create_qapp()
database = get_database()
bars = database.load_bar_data(
<|code_end|>
, predict the immediate next line with the help of imports:
from datetime import datetime
from vnpy.trader.ui import create_qapp, QtCore
from vnpy.trader.constant import Exchange, Interval
from vnpy.trader.database import get_database
from vnpy.chart import ChartWidget, VolumeItem, CandleItem
and context (classes, functions, sometimes code) from other files:
# Path: vnpy/trader/ui/qt.py
# def create_qapp(app_name: str = "Veighna Trader") -> QtWidgets.QApplication:
# def excepthook(exctype: type, value: Exception, tb: types.TracebackType) -> None:
# def __init__(self, parent: QtWidgets.QWidget = None):
# def init_ui(self) -> None:
# def show_exception(self, msg: str) -> None:
# def _copy_text(self) -> None:
# def _open_community(self) -> None:
# class ExceptionWidget(QtWidgets.QWidget):
#
# Path: vnpy/trader/constant.py
# class Exchange(Enum):
# """
# Exchange.
# """
# # Chinese
# CFFEX = "CFFEX" # China Financial Futures Exchange
# SHFE = "SHFE" # Shanghai Futures Exchange
# CZCE = "CZCE" # Zhengzhou Commodity Exchange
# DCE = "DCE" # Dalian Commodity Exchange
# INE = "INE" # Shanghai International Energy Exchange
# SSE = "SSE" # Shanghai Stock Exchange
# SZSE = "SZSE" # Shenzhen Stock Exchange
# BSE = "BSE" # Beijing Stock Exchange
# SGE = "SGE" # Shanghai Gold Exchange
# WXE = "WXE" # Wuxi Steel Exchange
# CFETS = "CFETS" # CFETS Bond Market Maker Trading System
# XBOND = "XBOND" # CFETS X-Bond Anonymous Trading System
#
# # Global
# SMART = "SMART" # Smart Router for US stocks
# NYSE = "NYSE" # New York Stock Exchnage
# NASDAQ = "NASDAQ" # Nasdaq Exchange
# ARCA = "ARCA" # ARCA Exchange
# EDGEA = "EDGEA" # Direct Edge Exchange
# ISLAND = "ISLAND" # Nasdaq Island ECN
# BATS = "BATS" # Bats Global Markets
# IEX = "IEX" # The Investors Exchange
# NYMEX = "NYMEX" # New York Mercantile Exchange
# COMEX = "COMEX" # COMEX of CME
# GLOBEX = "GLOBEX" # Globex of CME
# IDEALPRO = "IDEALPRO" # Forex ECN of Interactive Brokers
# CME = "CME" # Chicago Mercantile Exchange
# ICE = "ICE" # Intercontinental Exchange
# SEHK = "SEHK" # Stock Exchange of Hong Kong
# HKFE = "HKFE" # Hong Kong Futures Exchange
# SGX = "SGX" # Singapore Global Exchange
# CBOT = "CBT" # Chicago Board of Trade
# CBOE = "CBOE" # Chicago Board Options Exchange
# CFE = "CFE" # CBOE Futures Exchange
# DME = "DME" # Dubai Mercantile Exchange
# EUREX = "EUX" # Eurex Exchange
# APEX = "APEX" # Asia Pacific Exchange
# LME = "LME" # London Metal Exchange
# BMD = "BMD" # Bursa Malaysia Derivatives
# TOCOM = "TOCOM" # Tokyo Commodity Exchange
# EUNX = "EUNX" # Euronext Exchange
# KRX = "KRX" # Korean Exchange
# OTC = "OTC" # OTC Product (Forex/CFD/Pink Sheet Equity)
# IBKRATS = "IBKRATS" # Paper Trading Exchange of IB
#
# # Special Function
# LOCAL = "LOCAL" # For local generated data
#
# class Interval(Enum):
# """
# Interval of bar data.
# """
# MINUTE = "1m"
# HOUR = "1h"
# DAILY = "d"
# WEEKLY = "w"
# TICK = "tick"
#
# Path: vnpy/trader/database.py
# def get_database() -> BaseDatabase:
# """"""
# # Return database object if already inited
# global database
# if database:
# return database
#
# # Read database related global setting
# database_name: str = SETTINGS["database.name"]
# module_name: str = f"vnpy_{database_name}"
#
# # Try to import database module
# try:
# module = import_module(module_name)
# except ModuleNotFoundError:
# print(f"找不到数据库驱动{module_name}，使用默认的SQLite数据库")
# module = import_module("vnpy_sqlite")
#
# # Create database object from module
# database = module.Database()
# return database
. Output only the next line. | "IF888", |
Given the following code snippet before the placeholder: <|code_start|>
if __name__ == "__main__":
app = create_qapp()
database = get_database()
bars = database.load_bar_data(
"IF888",
Exchange.CFFEX,
interval=Interval.MINUTE,
start=datetime(2019, 7, 1),
end=datetime(2019, 7, 17)
)
widget = ChartWidget()
widget.add_plot("candle", hide_x_axis=True)
widget.add_plot("volume", maximum_height=200)
widget.add_item(CandleItem, "candle", "candle")
widget.add_item(VolumeItem, "volume", "volume")
widget.add_cursor()
n = 1000
history = bars[:n]
new_data = bars[n:]
widget.update_history(history)
def update_bar():
<|code_end|>
, predict the next line using imports from the current file:
from datetime import datetime
from vnpy.trader.ui import create_qapp, QtCore
from vnpy.trader.constant import Exchange, Interval
from vnpy.trader.database import get_database
from vnpy.chart import ChartWidget, VolumeItem, CandleItem
and context including class names, function names, and sometimes code from other files:
# Path: vnpy/trader/ui/qt.py
# def create_qapp(app_name: str = "Veighna Trader") -> QtWidgets.QApplication:
# def excepthook(exctype: type, value: Exception, tb: types.TracebackType) -> None:
# def __init__(self, parent: QtWidgets.QWidget = None):
# def init_ui(self) -> None:
# def show_exception(self, msg: str) -> None:
# def _copy_text(self) -> None:
# def _open_community(self) -> None:
# class ExceptionWidget(QtWidgets.QWidget):
#
# Path: vnpy/trader/constant.py
# class Exchange(Enum):
# """
# Exchange.
# """
# # Chinese
# CFFEX = "CFFEX" # China Financial Futures Exchange
# SHFE = "SHFE" # Shanghai Futures Exchange
# CZCE = "CZCE" # Zhengzhou Commodity Exchange
# DCE = "DCE" # Dalian Commodity Exchange
# INE = "INE" # Shanghai International Energy Exchange
# SSE = "SSE" # Shanghai Stock Exchange
# SZSE = "SZSE" # Shenzhen Stock Exchange
# BSE = "BSE" # Beijing Stock Exchange
# SGE = "SGE" # Shanghai Gold Exchange
# WXE = "WXE" # Wuxi Steel Exchange
# CFETS = "CFETS" # CFETS Bond Market Maker Trading System
# XBOND = "XBOND" # CFETS X-Bond Anonymous Trading System
#
# # Global
# SMART = "SMART" # Smart Router for US stocks
# NYSE = "NYSE" # New York Stock Exchnage
# NASDAQ = "NASDAQ" # Nasdaq Exchange
# ARCA = "ARCA" # ARCA Exchange
# EDGEA = "EDGEA" # Direct Edge Exchange
# ISLAND = "ISLAND" # Nasdaq Island ECN
# BATS = "BATS" # Bats Global Markets
# IEX = "IEX" # The Investors Exchange
# NYMEX = "NYMEX" # New York Mercantile Exchange
# COMEX = "COMEX" # COMEX of CME
# GLOBEX = "GLOBEX" # Globex of CME
# IDEALPRO = "IDEALPRO" # Forex ECN of Interactive Brokers
# CME = "CME" # Chicago Mercantile Exchange
# ICE = "ICE" # Intercontinental Exchange
# SEHK = "SEHK" # Stock Exchange of Hong Kong
# HKFE = "HKFE" # Hong Kong Futures Exchange
# SGX = "SGX" # Singapore Global Exchange
# CBOT = "CBT" # Chicago Board of Trade
# CBOE = "CBOE" # Chicago Board Options Exchange
# CFE = "CFE" # CBOE Futures Exchange
# DME = "DME" # Dubai Mercantile Exchange
# EUREX = "EUX" # Eurex Exchange
# APEX = "APEX" # Asia Pacific Exchange
# LME = "LME" # London Metal Exchange
# BMD = "BMD" # Bursa Malaysia Derivatives
# TOCOM = "TOCOM" # Tokyo Commodity Exchange
# EUNX = "EUNX" # Euronext Exchange
# KRX = "KRX" # Korean Exchange
# OTC = "OTC" # OTC Product (Forex/CFD/Pink Sheet Equity)
# IBKRATS = "IBKRATS" # Paper Trading Exchange of IB
#
# # Special Function
# LOCAL = "LOCAL" # For local generated data
#
# class Interval(Enum):
# """
# Interval of bar data.
# """
# MINUTE = "1m"
# HOUR = "1h"
# DAILY = "d"
# WEEKLY = "w"
# TICK = "tick"
#
# Path: vnpy/trader/database.py
# def get_database() -> BaseDatabase:
# """"""
# # Return database object if already inited
# global database
# if database:
# return database
#
# # Read database related global setting
# database_name: str = SETTINGS["database.name"]
# module_name: str = f"vnpy_{database_name}"
#
# # Try to import database module
# try:
# module = import_module(module_name)
# except ModuleNotFoundError:
# print(f"找不到数据库驱动{module_name}，使用默认的SQLite数据库")
# module = import_module("vnpy_sqlite")
#
# # Create database object from module
# database = module.Database()
# return database
. Output only the next line. | bar = new_data.pop(0) |
Given the following code snippet before the placeholder: <|code_start|>
if __name__ == "__main__":
app = create_qapp()
database = get_database()
bars = database.load_bar_data(
"IF888",
Exchange.CFFEX,
interval=Interval.MINUTE,
start=datetime(2019, 7, 1),
end=datetime(2019, 7, 17)
)
widget = ChartWidget()
widget.add_plot("candle", hide_x_axis=True)
<|code_end|>
, predict the next line using imports from the current file:
from datetime import datetime
from vnpy.trader.ui import create_qapp, QtCore
from vnpy.trader.constant import Exchange, Interval
from vnpy.trader.database import get_database
from vnpy.chart import ChartWidget, VolumeItem, CandleItem
and context including class names, function names, and sometimes code from other files:
# Path: vnpy/trader/ui/qt.py
# def create_qapp(app_name: str = "Veighna Trader") -> QtWidgets.QApplication:
# def excepthook(exctype: type, value: Exception, tb: types.TracebackType) -> None:
# def __init__(self, parent: QtWidgets.QWidget = None):
# def init_ui(self) -> None:
# def show_exception(self, msg: str) -> None:
# def _copy_text(self) -> None:
# def _open_community(self) -> None:
# class ExceptionWidget(QtWidgets.QWidget):
#
# Path: vnpy/trader/constant.py
# class Exchange(Enum):
# """
# Exchange.
# """
# # Chinese
# CFFEX = "CFFEX" # China Financial Futures Exchange
# SHFE = "SHFE" # Shanghai Futures Exchange
# CZCE = "CZCE" # Zhengzhou Commodity Exchange
# DCE = "DCE" # Dalian Commodity Exchange
# INE = "INE" # Shanghai International Energy Exchange
# SSE = "SSE" # Shanghai Stock Exchange
# SZSE = "SZSE" # Shenzhen Stock Exchange
# BSE = "BSE" # Beijing Stock Exchange
# SGE = "SGE" # Shanghai Gold Exchange
# WXE = "WXE" # Wuxi Steel Exchange
# CFETS = "CFETS" # CFETS Bond Market Maker Trading System
# XBOND = "XBOND" # CFETS X-Bond Anonymous Trading System
#
# # Global
# SMART = "SMART" # Smart Router for US stocks
# NYSE = "NYSE" # New York Stock Exchnage
# NASDAQ = "NASDAQ" # Nasdaq Exchange
# ARCA = "ARCA" # ARCA Exchange
# EDGEA = "EDGEA" # Direct Edge Exchange
# ISLAND = "ISLAND" # Nasdaq Island ECN
# BATS = "BATS" # Bats Global Markets
# IEX = "IEX" # The Investors Exchange
# NYMEX = "NYMEX" # New York Mercantile Exchange
# COMEX = "COMEX" # COMEX of CME
# GLOBEX = "GLOBEX" # Globex of CME
# IDEALPRO = "IDEALPRO" # Forex ECN of Interactive Brokers
# CME = "CME" # Chicago Mercantile Exchange
# ICE = "ICE" # Intercontinental Exchange
# SEHK = "SEHK" # Stock Exchange of Hong Kong
# HKFE = "HKFE" # Hong Kong Futures Exchange
# SGX = "SGX" # Singapore Global Exchange
# CBOT = "CBT" # Chicago Board of Trade
# CBOE = "CBOE" # Chicago Board Options Exchange
# CFE = "CFE" # CBOE Futures Exchange
# DME = "DME" # Dubai Mercantile Exchange
# EUREX = "EUX" # Eurex Exchange
# APEX = "APEX" # Asia Pacific Exchange
# LME = "LME" # London Metal Exchange
# BMD = "BMD" # Bursa Malaysia Derivatives
# TOCOM = "TOCOM" # Tokyo Commodity Exchange
# EUNX = "EUNX" # Euronext Exchange
# KRX = "KRX" # Korean Exchange
# OTC = "OTC" # OTC Product (Forex/CFD/Pink Sheet Equity)
# IBKRATS = "IBKRATS" # Paper Trading Exchange of IB
#
# # Special Function
# LOCAL = "LOCAL" # For local generated data
#
# class Interval(Enum):
# """
# Interval of bar data.
# """
# MINUTE = "1m"
# HOUR = "1h"
# DAILY = "d"
# WEEKLY = "w"
# TICK = "tick"
#
# Path: vnpy/trader/database.py
# def get_database() -> BaseDatabase:
# """"""
# # Return database object if already inited
# global database
# if database:
# return database
#
# # Read database related global setting
# database_name: str = SETTINGS["database.name"]
# module_name: str = f"vnpy_{database_name}"
#
# # Try to import database module
# try:
# module = import_module(module_name)
# except ModuleNotFoundError:
# print(f"找不到数据库驱动{module_name}，使用默认的SQLite数据库")
# module = import_module("vnpy_sqlite")
#
# # Create database object from module
# database = module.Database()
# return database
. Output only the next line. | widget.add_plot("volume", maximum_height=200) |
Given snippet: <|code_start|> except:
exception('Error calculating subitem averages')
return avg_list
def CalculateArrayAverage(self, avg_array, new_array, count):
if len(avg_array) == 0:
return new_array
try:
for key in avg_array:
avg_array[key] = self.CalculateAverage(avg_array[key], new_array[key], count)
except:
exception('Error calculating array averages')
return avg_array
def CalculateNetworkSpeedAverages(self, current_avgs, new_sample, count):
try:
if 'NetworkSpeed' not in current_avgs:
if 'NetworkSpeed' in new_sample:
current_avgs['NetworkSpeed'] = new_sample['NetworkSpeed']
return
if new_sample['NetworkSpeed'] != 'None':
if current_avgs['NetworkSpeed'] == 'None':
current_avgs['NetworkSpeed'] = new_sample['NetworkSpeed']
else:
current_avgs['NetworkSpeed'] = str(self.CalculateAverage(float(current_avgs['NetworkSpeed']), float(new_sample['NetworkSpeed']), count))
except:
exception('Error calculating network speed average')
def CalculateSystemInfoAverages(self, current_avgs, new_sample, count):
try:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from myDevices.utils.logger import exception, info, warn, error, debug, setDebug, logJson
from json import loads, dumps
from time import time
from datetime import datetime, timedelta
from sqlite3 import connect
from operator import itemgetter
from os import rename
from sys import argv
and context:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# def logJson(message, category = ''):
# if debugEnabled() == False:
# return
# if checkFlood(message):
# return
# try:
# if category not in jsonData:
# jsonData[category] = []
# if len(jsonData[category]) > MAX_JSON_ITEMS_PER_CATEGORY:
# del jsonData[category][0]
# #2016-03-23 03:53:16 - myDevices - INFO -
# message = str(datetime.today()) + ' - myDevices - INFO - ' + message
# jsonData[category].append(message)
# rotatorJson()
# except Exception as ex:
# exception("logJson failed")
which might include code, classes, or functions. Output only the next line. | if 'SystemInfo' not in new_sample or new_sample['SystemInfo'] is None: |
Given the code snippet: <|code_start|> averageSensorsDictionary[value['sensor']]['percent'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['percent'], value['percent'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] in ('DigitalSensor', 'DigitalActuator'):
averageSensorsDictionary[value['sensor']]['value'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['value'], value['value'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] == 'AnalogSensor':
averageSensorsDictionary[value['sensor']]['float'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['float'], value['float'], count_sensor['SensorsInfo'][value['sensor']] )
# averageSensorsDictionary[value['sensor']]['integer'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['integer'], value['integer'], count_sensor['SensorsInfo'][value['sensor']] )
# averageSensorsDictionary[value['sensor']]['volt'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['volt'], value['volt'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] == 'ServoMotor':
averageSensorsDictionary[value['sensor']]['angle'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['angle'], value['angle'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] == 'AnalogActuator':
averageSensorsDictionary[value['sensor']]['float'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['float'], value['float'], count_sensor['SensorsInfo'][value['sensor']] )
#else:
# current_avgs['SensorsInfo'].append(value)
# count_sensor['SensorsInfo'][value['sensor']] = 1
except:
exception('Error calculating sensors info averages for: ' + str(value))
else:
current_avgs['SensorsInfo'].append(value)
count_sensor['SensorsInfo'][value['sensor']] = 1
except:
exception('Error calculating sensors info averages: current_avgs {}, new_sample {} '.format(current_avgs, new_sample))
def CalculateAverages(self, current_avgs, new_sample, count, count_sensor):
info('History CalculateAverages increment: ' + str(count))
count += 1
self.CalculateNetworkSpeedAverages(current_avgs, new_sample, count)
self.CalculateSystemInfoAverages(current_avgs, new_sample, count)
self.CalculateSensorsInfoAverages(current_avgs, new_sample, count_sensor)
return count
<|code_end|>
, generate the next line using the imports in this file:
from myDevices.utils.logger import exception, info, warn, error, debug, setDebug, logJson
from json import loads, dumps
from time import time
from datetime import datetime, timedelta
from sqlite3 import connect
from operator import itemgetter
from os import rename
from sys import argv
and context (functions, classes, or occasionally code) from other files:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# def logJson(message, category = ''):
# if debugEnabled() == False:
# return
# if checkFlood(message):
# return
# try:
# if category not in jsonData:
# jsonData[category] = []
# if len(jsonData[category]) > MAX_JSON_ITEMS_PER_CATEGORY:
# del jsonData[category][0]
# #2016-03-23 03:53:16 - myDevices - INFO -
# message = str(datetime.today()) + ' - myDevices - INFO - ' + message
# jsonData[category].append(message)
# rotatorJson()
# except Exception as ex:
# exception("logJson failed")
. Output only the next line. | def SaveAverages(self, data): |
Based on the snippet: <|code_start|> # averageSensorsDictionary[value['sensor']]['all'] = self.CalculateArrayAverage(averageSensorsDictionary[value['sensor']]['all'], value['all'], count_sensor['SensorsInfo'][value['sensor']])
# if value['type'] == 'PiFaceDigital':
# averageSensorsDictionary[value['sensor']]['all'] = self.CalculateArrayAverage(averageSensorsDictionary[value['sensor']]['all'], value['all'], count_sensor['SensorsInfo'][value['sensor']])
############################################################################################################
if value['type'] == 'Humidity':
averageSensorsDictionary[value['sensor']]['float'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['float'], value['float'], count_sensor['SensorsInfo'][value['sensor']] )
averageSensorsDictionary[value['sensor']]['percent'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['percent'], value['percent'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] in ('DigitalSensor', 'DigitalActuator'):
averageSensorsDictionary[value['sensor']]['value'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['value'], value['value'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] == 'AnalogSensor':
averageSensorsDictionary[value['sensor']]['float'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['float'], value['float'], count_sensor['SensorsInfo'][value['sensor']] )
# averageSensorsDictionary[value['sensor']]['integer'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['integer'], value['integer'], count_sensor['SensorsInfo'][value['sensor']] )
# averageSensorsDictionary[value['sensor']]['volt'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['volt'], value['volt'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] == 'ServoMotor':
averageSensorsDictionary[value['sensor']]['angle'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['angle'], value['angle'], count_sensor['SensorsInfo'][value['sensor']] )
if value['type'] == 'AnalogActuator':
averageSensorsDictionary[value['sensor']]['float'] = self.CalculateAverage(averageSensorsDictionary[value['sensor']]['float'], value['float'], count_sensor['SensorsInfo'][value['sensor']] )
#else:
# current_avgs['SensorsInfo'].append(value)
# count_sensor['SensorsInfo'][value['sensor']] = 1
except:
exception('Error calculating sensors info averages for: ' + str(value))
else:
current_avgs['SensorsInfo'].append(value)
count_sensor['SensorsInfo'][value['sensor']] = 1
except:
exception('Error calculating sensors info averages: current_avgs {}, new_sample {} '.format(current_avgs, new_sample))
def CalculateAverages(self, current_avgs, new_sample, count, count_sensor):
info('History CalculateAverages increment: ' + str(count))
<|code_end|>
, predict the immediate next line with the help of imports:
from myDevices.utils.logger import exception, info, warn, error, debug, setDebug, logJson
from json import loads, dumps
from time import time
from datetime import datetime, timedelta
from sqlite3 import connect
from operator import itemgetter
from os import rename
from sys import argv
and context (classes, functions, sometimes code) from other files:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# def logJson(message, category = ''):
# if debugEnabled() == False:
# return
# if checkFlood(message):
# return
# try:
# if category not in jsonData:
# jsonData[category] = []
# if len(jsonData[category]) > MAX_JSON_ITEMS_PER_CATEGORY:
# del jsonData[category][0]
# #2016-03-23 03:53:16 - myDevices - INFO -
# message = str(datetime.today()) + ' - myDevices - INFO - ' + message
# jsonData[category].append(message)
# rotatorJson()
# except Exception as ex:
# exception("logJson failed")
. Output only the next line. | count += 1 |
Given the following code snippet before the placeholder: <|code_start|> self.cursor.execute('INSERT INTO historical_averages VALUES (NULL,?,?,?,?,?,?,?)', (dumps(self.avg_values), self.count, self.start_time, self.end_time, History.RUNNING, History.NOT_READY, dumps(self.count_sensor)))
self.connection.commit()
self.id = self.cursor.lastrowid
else:
self.cursor.execute('REPLACE INTO historical_averages VALUES (?,?,?,?,?,?,?,?)', (self.id, dumps(self.avg_values), self.count, self.start_time, self.end_time, History.RUNNING, History.NOT_READY, dumps(self.count_sensor)))
self.connection.commit()
except:
exception('SaveAverages Update database exception')
#info(self.avg_values)
def SaveIntervalAverage(self, interval, start, end):
sub_interval = self.GetSubInterval(interval)
startTimestamp = (start - datetime(1970, 1, 1)).total_seconds()
endTimestamp = (end - datetime(1970, 1, 1)).total_seconds()
self.cursor.execute('SELECT data, start, end FROM historical_averages WHERE interval = ? AND start >= ? AND end <= ?', (sub_interval, startTimestamp, endTimestamp))
results = self.cursor.fetchall()
avg = {}
count = 0
count_sensor = {}
count_sensor['SensorsInfo'] = {}
for row in results:
count = self.CalculateAverages(avg, loads(row[0]), count, count_sensor)
if avg:
start_time = min(results, key=itemgetter(1))[1]
end_time = max(results, key=itemgetter(2))[2]
self.cursor.execute('INSERT INTO historical_averages VALUES (NULL,?,?,?,?,?,?,?)', (dumps(avg), count, start_time, end_time, interval, History.READY, dumps(count_sensor)))
self.connection.commit()
def GetIntervalAverage(self, interval):
avg = {}
<|code_end|>
, predict the next line using imports from the current file:
from myDevices.utils.logger import exception, info, warn, error, debug, setDebug, logJson
from json import loads, dumps
from time import time
from datetime import datetime, timedelta
from sqlite3 import connect
from operator import itemgetter
from os import rename
from sys import argv
and context including class names, function names, and sometimes code from other files:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# def logJson(message, category = ''):
# if debugEnabled() == False:
# return
# if checkFlood(message):
# return
# try:
# if category not in jsonData:
# jsonData[category] = []
# if len(jsonData[category]) > MAX_JSON_ITEMS_PER_CATEGORY:
# del jsonData[category][0]
# #2016-03-23 03:53:16 - myDevices - INFO -
# message = str(datetime.today()) + ' - myDevices - INFO - ' + message
# jsonData[category].append(message)
# rotatorJson()
# except Exception as ex:
# exception("logJson failed")
. Output only the next line. | self.cursor.execute('SELECT id, data, start, end FROM historical_averages WHERE interval = ? AND send = ? ORDER BY end ASC LIMIT 1', (interval, History.READY)) |
Given the following code snippet before the placeholder: <|code_start|>
class SystemConfigTest(unittest.TestCase):
def testSystemConfig(self):
config = SystemConfig.getConfig()
info(config)
<|code_end|>
, predict the next line using imports from the current file:
import unittest
from myDevices.system.systemconfig import SystemConfig
from myDevices.utils.logger import setInfo, info
and context including class names, function names, and sometimes code from other files:
# Path: myDevices/system/systemconfig.py
# class SystemConfig:
# """Class for modifying configuration settings"""
#
# @staticmethod
# def ExpandRootfs():
# """Expand the filesystem"""
# command = "sudo raspi-config --expand-rootfs"
# debug('ExpandRootfs command:' + command)
# (output, returnCode) = executeCommand(command)
# debug('ExpandRootfs command:' + command + " retCode: " + returnCode)
# output = 'reboot required'
# return (returnCode, output)
#
# @staticmethod
# def ExecuteConfigCommand(config_id, parameters=''):
# """Execute specified command to modify configuration
#
# Args:
# config_id: Id of command to run
# parameters: Parameters to use when executing command
# """
# if not Hardware().isRaspberryPi():
# return (1, 'Not supported')
# debug('SystemConfig::ExecuteConfigCommand')
# if config_id == 0:
# return SystemConfig.ExpandRootfs()
# command = "sudo " + CUSTOM_CONFIG_SCRIPT + " " + str(config_id) + " " + str(parameters)
# (output, returnCode) = executeCommand(command)
# debug('ExecuteConfigCommand '+ str(config_id) + ' args: ' + str(parameters) + ' retCode: ' + str(returnCode) + ' output: ' + output )
# if "reboot required" in output:
# ThreadPool.Submit(SystemConfig.RestartDevice)
# return (returnCode, output)
#
# @staticmethod
# def RestartDevice():
# """Reboot the device"""
# sleep(5)
# command = "sudo shutdown -r now"
# (output, returnCode) = executeCommand(command)
#
# @staticmethod
# def getConfig():
# """Return dict containing configuration settings"""
# config = {}
# if not Hardware().isRaspberryPi():
# return config
# commands = {10: 'DeviceTree', 18: 'Serial', 20: 'OneWire', 21: 'I2C', 22: 'SPI'}
# for command, name in commands.items():
# try:
# (returnCode, output) = SystemConfig.ExecuteConfigCommand(command)
# if output:
# config[name] = 1 - int(output.strip()) #Invert the value since the config script uses 0 for enable and 1 for disable
# except:
# exception('Get config')
# debug('SystemConfig: {}'.format(config))
# return config
#
# Path: myDevices/utils/logger.py
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
. Output only the next line. | if config: |
Using the snippet: <|code_start|>
class SystemConfigTest(unittest.TestCase):
def testSystemConfig(self):
config = SystemConfig.getConfig()
info(config)
<|code_end|>
, determine the next line of code. You have imports:
import unittest
from myDevices.system.systemconfig import SystemConfig
from myDevices.utils.logger import setInfo, info
and context (class names, function names, or code) available:
# Path: myDevices/system/systemconfig.py
# class SystemConfig:
# """Class for modifying configuration settings"""
#
# @staticmethod
# def ExpandRootfs():
# """Expand the filesystem"""
# command = "sudo raspi-config --expand-rootfs"
# debug('ExpandRootfs command:' + command)
# (output, returnCode) = executeCommand(command)
# debug('ExpandRootfs command:' + command + " retCode: " + returnCode)
# output = 'reboot required'
# return (returnCode, output)
#
# @staticmethod
# def ExecuteConfigCommand(config_id, parameters=''):
# """Execute specified command to modify configuration
#
# Args:
# config_id: Id of command to run
# parameters: Parameters to use when executing command
# """
# if not Hardware().isRaspberryPi():
# return (1, 'Not supported')
# debug('SystemConfig::ExecuteConfigCommand')
# if config_id == 0:
# return SystemConfig.ExpandRootfs()
# command = "sudo " + CUSTOM_CONFIG_SCRIPT + " " + str(config_id) + " " + str(parameters)
# (output, returnCode) = executeCommand(command)
# debug('ExecuteConfigCommand '+ str(config_id) + ' args: ' + str(parameters) + ' retCode: ' + str(returnCode) + ' output: ' + output )
# if "reboot required" in output:
# ThreadPool.Submit(SystemConfig.RestartDevice)
# return (returnCode, output)
#
# @staticmethod
# def RestartDevice():
# """Reboot the device"""
# sleep(5)
# command = "sudo shutdown -r now"
# (output, returnCode) = executeCommand(command)
#
# @staticmethod
# def getConfig():
# """Return dict containing configuration settings"""
# config = {}
# if not Hardware().isRaspberryPi():
# return config
# commands = {10: 'DeviceTree', 18: 'Serial', 20: 'OneWire', 21: 'I2C', 22: 'SPI'}
# for command, name in commands.items():
# try:
# (returnCode, output) = SystemConfig.ExecuteConfigCommand(command)
# if output:
# config[name] = 1 - int(output.strip()) #Invert the value since the config script uses 0 for enable and 1 for disable
# except:
# exception('Get config')
# debug('SystemConfig: {}'.format(config))
# return config
#
# Path: myDevices/utils/logger.py
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
. Output only the next line. | if config: |
Continue the code snippet: <|code_start|>
class SystemConfigTest(unittest.TestCase):
def testSystemConfig(self):
config = SystemConfig.getConfig()
info(config)
if config:
for item in ('DeviceTree', 'Serial', 'I2C', 'SPI', 'OneWire'):
<|code_end|>
. Use current file imports:
import unittest
from myDevices.system.systemconfig import SystemConfig
from myDevices.utils.logger import setInfo, info
and context (classes, functions, or code) from other files:
# Path: myDevices/system/systemconfig.py
# class SystemConfig:
# """Class for modifying configuration settings"""
#
# @staticmethod
# def ExpandRootfs():
# """Expand the filesystem"""
# command = "sudo raspi-config --expand-rootfs"
# debug('ExpandRootfs command:' + command)
# (output, returnCode) = executeCommand(command)
# debug('ExpandRootfs command:' + command + " retCode: " + returnCode)
# output = 'reboot required'
# return (returnCode, output)
#
# @staticmethod
# def ExecuteConfigCommand(config_id, parameters=''):
# """Execute specified command to modify configuration
#
# Args:
# config_id: Id of command to run
# parameters: Parameters to use when executing command
# """
# if not Hardware().isRaspberryPi():
# return (1, 'Not supported')
# debug('SystemConfig::ExecuteConfigCommand')
# if config_id == 0:
# return SystemConfig.ExpandRootfs()
# command = "sudo " + CUSTOM_CONFIG_SCRIPT + " " + str(config_id) + " " + str(parameters)
# (output, returnCode) = executeCommand(command)
# debug('ExecuteConfigCommand '+ str(config_id) + ' args: ' + str(parameters) + ' retCode: ' + str(returnCode) + ' output: ' + output )
# if "reboot required" in output:
# ThreadPool.Submit(SystemConfig.RestartDevice)
# return (returnCode, output)
#
# @staticmethod
# def RestartDevice():
# """Reboot the device"""
# sleep(5)
# command = "sudo shutdown -r now"
# (output, returnCode) = executeCommand(command)
#
# @staticmethod
# def getConfig():
# """Return dict containing configuration settings"""
# config = {}
# if not Hardware().isRaspberryPi():
# return config
# commands = {10: 'DeviceTree', 18: 'Serial', 20: 'OneWire', 21: 'I2C', 22: 'SPI'}
# for command, name in commands.items():
# try:
# (returnCode, output) = SystemConfig.ExecuteConfigCommand(command)
# if output:
# config[name] = 1 - int(output.strip()) #Invert the value since the config script uses 0 for enable and 1 for disable
# except:
# exception('Get config')
# debug('SystemConfig: {}'.format(config))
# return config
#
# Path: myDevices/utils/logger.py
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
. Output only the next line. | self.assertIn(item, config) |
Given the code snippet: <|code_start|> self.connection.close()
except:
exception('Error deleting SchedulerEngine')
def load_schedule(self):
"""Load saved scheduler events from the database"""
with self.mutex:
self.cursor.execute('SELECT * FROM scheduled_events')
results = self.cursor.fetchall()
for row in results:
self.add_scheduled_event(loads(row[1]), False)
return True
def add_scheduled_event(self, event, insert = False):
"""Add a scheduled event to run via the scheduler
event: the scheduled event to add
insert: if True add the event to the database, otherwise just add it to the running scheduler"""
debug('Add scheduled event')
result = False
try:
if event['id'] is None:
raise ValueError('No id specified for scheduled event: {}'.format(event))
schedule_item = {'event': event, 'job': None}
with self.mutex:
try:
if event['id'] not in self.schedule_items:
if insert == True:
self.add_database_record(event['id'], event)
result = self.create_job(schedule_item)
<|code_end|>
, generate the next line using the imports in this file:
from datetime import datetime
from json import dumps, loads
from sqlite3 import connect
from threading import RLock, Thread
from time import sleep
from myDevices.requests_futures.sessions import FuturesSession
from myDevices.utils.logger import debug, error, exception, info, logJson, setDebug, warn
import myDevices.schedule as schedule
and context (functions, classes, or occasionally code) from other files:
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def logJson(message, category = ''):
# if debugEnabled() == False:
# return
# if checkFlood(message):
# return
# try:
# if category not in jsonData:
# jsonData[category] = []
# if len(jsonData[category]) > MAX_JSON_ITEMS_PER_CATEGORY:
# del jsonData[category][0]
# #2016-03-23 03:53:16 - myDevices - INFO -
# message = str(datetime.today()) + ' - myDevices - INFO - ' + message
# jsonData[category].append(message)
# rotatorJson()
# except Exception as ex:
# exception("logJson failed")
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
. Output only the next line. | if result == True: |
Given snippet: <|code_start|> self.schedule_items.clear()
self.remove_all_database_records()
except:
exception('Failed to remove scheduled events')
return False
return True
def remove_scheduled_item_by_id(self, remove_id):
"""Remove a scheduled item with the specified id
id: id specifying the item to remove"""
with self.mutex:
if remove_id in self.schedule_items:
try:
schedule_item = self.schedule_items[remove_id]
schedule.cancel_job(schedule_item['job'])
del self.schedule_items[remove_id]
self.remove_database_record(remove_id)
return True
except KeyError:
warn('Key error removing scheduled item: {}'.format(remove_id))
error('Remove id not found: {}'.format(remove_id))
return False
def create_job(self, schedule_item):
"""Create a job to run a scheduled item
schedule_item: the item containing the event to be run at the scheduled time"""
debug('Create job: {}'.format(schedule_item))
try:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from datetime import datetime
from json import dumps, loads
from sqlite3 import connect
from threading import RLock, Thread
from time import sleep
from myDevices.requests_futures.sessions import FuturesSession
from myDevices.utils.logger import debug, error, exception, info, logJson, setDebug, warn
import myDevices.schedule as schedule
and context:
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def logJson(message, category = ''):
# if debugEnabled() == False:
# return
# if checkFlood(message):
# return
# try:
# if category not in jsonData:
# jsonData[category] = []
# if len(jsonData[category]) > MAX_JSON_ITEMS_PER_CATEGORY:
# del jsonData[category][0]
# #2016-03-23 03:53:16 - myDevices - INFO -
# message = str(datetime.today()) + ' - myDevices - INFO - ' + message
# jsonData[category].append(message)
# rotatorJson()
# except Exception as ex:
# exception("logJson failed")
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
which might include code, classes, or functions. Output only the next line. | with self.mutex: |
Next line prediction: <|code_start|>
class SchedulerEngine(Thread):
"""Class that creates the scheduler and launches scheduled actions"""
def __init__(self, client, name):
"""Initialize the scheduler and start the scheduler thread
client: the client running the scheduler
name: name to use for the scheduler thread"""
self.connection = connect('/etc/myDevices/agent.db', check_same_thread = False)
self.cursor = self.connection.cursor()
self.cursor.execute('CREATE TABLE IF NOT EXISTS scheduled_events (id TEXT PRIMARY KEY, event TEXT)')
Thread.__init__(self, name=name)
self.mutex = RLock()
self.schedule_items = {}
self.client = client
<|code_end|>
. Use current file imports:
(from datetime import datetime
from json import dumps, loads
from sqlite3 import connect
from threading import RLock, Thread
from time import sleep
from myDevices.requests_futures.sessions import FuturesSession
from myDevices.utils.logger import debug, error, exception, info, logJson, setDebug, warn
import myDevices.schedule as schedule)
and context including class names, function names, or small code snippets from other files:
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def logJson(message, category = ''):
# if debugEnabled() == False:
# return
# if checkFlood(message):
# return
# try:
# if category not in jsonData:
# jsonData[category] = []
# if len(jsonData[category]) > MAX_JSON_ITEMS_PER_CATEGORY:
# del jsonData[category][0]
# #2016-03-23 03:53:16 - myDevices - INFO -
# message = str(datetime.today()) + ' - myDevices - INFO - ' + message
# jsonData[category].append(message)
# rotatorJson()
# except Exception as ex:
# exception("logJson failed")
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
. Output only the next line. | self.running = False |
Next line prediction: <|code_start|> if config['unit'] == 'hour':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).hours
if config['unit'] == 'minute':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).minutes
if config['unit'] == 'day':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).days.at(config['start_date'])
if config['unit'] == 'week':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).weeks.at(config['start_date'])
if config['unit'] == 'month':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).months.at(config['start_date'])
if config['unit'] == 'year':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).years.at(config['start_date'])
if 'last_run' in schedule_item['event']:
schedule_item['job'].set_last_run(schedule_item['event']['last_run'])
schedule_item['job'].do(self.run_scheduled_item, schedule_item)
except:
exception('Failed setting up scheduler')
return False
return True
def run_scheduled_item(self, schedule_item):
"""Run an item that has been scheduled
schedule_item: the item containing the event to run"""
debug('Process action')
if not schedule_item:
error('No scheduled item to run')
return
result = True
event = schedule_item['event']
<|code_end|>
. Use current file imports:
(from datetime import datetime
from json import dumps, loads
from sqlite3 import connect
from threading import RLock, Thread
from time import sleep
from myDevices.requests_futures.sessions import FuturesSession
from myDevices.utils.logger import debug, error, exception, info, logJson, setDebug, warn
import myDevices.schedule as schedule)
and context including class names, function names, or small code snippets from other files:
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def logJson(message, category = ''):
# if debugEnabled() == False:
# return
# if checkFlood(message):
# return
# try:
# if category not in jsonData:
# jsonData[category] = []
# if len(jsonData[category]) > MAX_JSON_ITEMS_PER_CATEGORY:
# del jsonData[category][0]
# #2016-03-23 03:53:16 - myDevices - INFO -
# message = str(datetime.today()) + ' - myDevices - INFO - ' + message
# jsonData[category].append(message)
# rotatorJson()
# except Exception as ex:
# exception("logJson failed")
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
. Output only the next line. | config = event['config'] |
Using the snippet: <|code_start|> return True
except KeyError:
warn('Key error removing scheduled item: {}'.format(remove_id))
error('Remove id not found: {}'.format(remove_id))
return False
def create_job(self, schedule_item):
"""Create a job to run a scheduled item
schedule_item: the item containing the event to be run at the scheduled time"""
debug('Create job: {}'.format(schedule_item))
try:
with self.mutex:
config = schedule_item['event']['config']
if config['type'] == 'date':
schedule_item['job'] = schedule.once().at(config['start_date'])
if config['type'] == 'interval':
if config['unit'] == 'hour':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).hours
if config['unit'] == 'minute':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).minutes
if config['unit'] == 'day':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).days.at(config['start_date'])
if config['unit'] == 'week':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).weeks.at(config['start_date'])
if config['unit'] == 'month':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).months.at(config['start_date'])
if config['unit'] == 'year':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).years.at(config['start_date'])
if 'last_run' in schedule_item['event']:
<|code_end|>
, determine the next line of code. You have imports:
from datetime import datetime
from json import dumps, loads
from sqlite3 import connect
from threading import RLock, Thread
from time import sleep
from myDevices.requests_futures.sessions import FuturesSession
from myDevices.utils.logger import debug, error, exception, info, logJson, setDebug, warn
import myDevices.schedule as schedule
and context (class names, function names, or code) available:
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def logJson(message, category = ''):
# if debugEnabled() == False:
# return
# if checkFlood(message):
# return
# try:
# if category not in jsonData:
# jsonData[category] = []
# if len(jsonData[category]) > MAX_JSON_ITEMS_PER_CATEGORY:
# del jsonData[category][0]
# #2016-03-23 03:53:16 - myDevices - INFO -
# message = str(datetime.today()) + ' - myDevices - INFO - ' + message
# jsonData[category].append(message)
# rotatorJson()
# except Exception as ex:
# exception("logJson failed")
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
. Output only the next line. | schedule_item['job'].set_last_run(schedule_item['event']['last_run']) |
Here is a snippet: <|code_start|> return False
def create_job(self, schedule_item):
"""Create a job to run a scheduled item
schedule_item: the item containing the event to be run at the scheduled time"""
debug('Create job: {}'.format(schedule_item))
try:
with self.mutex:
config = schedule_item['event']['config']
if config['type'] == 'date':
schedule_item['job'] = schedule.once().at(config['start_date'])
if config['type'] == 'interval':
if config['unit'] == 'hour':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).hours
if config['unit'] == 'minute':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).minutes
if config['unit'] == 'day':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).days.at(config['start_date'])
if config['unit'] == 'week':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).weeks.at(config['start_date'])
if config['unit'] == 'month':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).months.at(config['start_date'])
if config['unit'] == 'year':
schedule_item['job'] = schedule.every(config['interval'], config['start_date']).years.at(config['start_date'])
if 'last_run' in schedule_item['event']:
schedule_item['job'].set_last_run(schedule_item['event']['last_run'])
schedule_item['job'].do(self.run_scheduled_item, schedule_item)
except:
exception('Failed setting up scheduler')
<|code_end|>
. Write the next line using the current file imports:
from datetime import datetime
from json import dumps, loads
from sqlite3 import connect
from threading import RLock, Thread
from time import sleep
from myDevices.requests_futures.sessions import FuturesSession
from myDevices.utils.logger import debug, error, exception, info, logJson, setDebug, warn
import myDevices.schedule as schedule
and context from other files:
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def logJson(message, category = ''):
# if debugEnabled() == False:
# return
# if checkFlood(message):
# return
# try:
# if category not in jsonData:
# jsonData[category] = []
# if len(jsonData[category]) > MAX_JSON_ITEMS_PER_CATEGORY:
# del jsonData[category][0]
# #2016-03-23 03:53:16 - myDevices - INFO -
# message = str(datetime.today()) + ' - myDevices - INFO - ' + message
# jsonData[category].append(message)
# rotatorJson()
# except Exception as ex:
# exception("logJson failed")
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
, which may include functions, classes, or code. Output only the next line. | return False |
Predict the next line for this snippet: <|code_start|>
class SystemInfoTest(unittest.TestCase):
def setUp(self):
setInfo()
system_info = SystemInfo()
self.info = {item['channel']:item for item in system_info.getSystemInformation()}
info(self.info)
<|code_end|>
with the help of current file imports:
import unittest
from myDevices.system.systeminfo import SystemInfo
from myDevices.utils.logger import setInfo, info
and context from other files:
# Path: myDevices/system/systeminfo.py
# class SystemInfo():
# """Class to get system CPU, memory, uptime, storage and network info"""
#
# def getSystemInformation(self):
# """Get a dict containing CPU, memory, uptime, storage and network info"""
# system_info = []
# try:
# system_info += self.getCpuInfo()
# system_info += self.getMemoryInfo((cayennemqtt.USAGE,))
# system_info += self.getDiskInfo((cayennemqtt.USAGE,))
# system_info += self.getNetworkInfo()
# except:
# exception('Error retrieving system info')
# return system_info
#
# def getCpuInfo(self):
# """Get CPU information as a list formatted for Cayenne MQTT
#
# Returned list example::
#
# [{
# 'channel': 'sys:cpu;load',
# 'value': 12.8,
# 'type': 'cpuload',
# 'unit': 'p'
# }, {
# 'channel': 'sys:cpu;temp',
# 'value': 50.843,
# 'type': 'temp',
# 'unit': 'c'
# }]
# """
# cpu_info = []
# try:
# cayennemqtt.DataChannel.add(cpu_info, cayennemqtt.SYS_CPU, suffix=cayennemqtt.LOAD, value=psutil.cpu_percent(1), type='cpuload', unit='p')
# cayennemqtt.DataChannel.add(cpu_info, cayennemqtt.SYS_CPU, suffix=cayennemqtt.TEMPERATURE, value=CpuInfo.get_cpu_temp(), type='temp', unit='c')
# except:
# exception('Error getting CPU info')
# return cpu_info
#
# def getMemoryInfo(self, types):
# """Get memory information as a list formatted for Cayenne MQTT.
#
# Args:
# types: Iterable containing types of memory info to retrieve matching cayennemqtt suffixes, e.g. cayennemqtt.USAGE
#
# Returned list example::
#
# [{
# 'channel': 'sys:ram;capacity',
# 'value': 968208384,
# 'type': 'memory',
# 'type': 'b'
# }, {
# 'channel': 'sys:ram;usage',
# 'value': 296620032,
# 'type': 'memory',
# 'type': 'b'
# }]
# """
# memory_info = []
# try:
# vmem = psutil.virtual_memory()
# if not types or cayennemqtt.USAGE in types:
# cayennemqtt.DataChannel.add(memory_info, cayennemqtt.SYS_RAM, suffix=cayennemqtt.USAGE, value=vmem.total - vmem.available, type='memory', unit='b')
# if not types or cayennemqtt.CAPACITY in types:
# cayennemqtt.DataChannel.add(memory_info, cayennemqtt.SYS_RAM, suffix=cayennemqtt.CAPACITY, value=vmem.total, type='memory', unit='b')
# except:
# exception('Error getting memory info')
# return memory_info
#
# def getDiskInfo(self, types):
# """Get disk information as a list formatted for Cayenne MQTT
#
# Args:
# types: Iterable containing types of disk info to retrieve matching cayennemqtt suffixes, e.g. cayennemqtt.USAGE
#
# Returned list example::
#
# [{
# 'channel': 'sys:storage:/;capacity',
# 'value': 13646516224,
# 'type': 'memory',
# 'type': 'b'
# }, {
# 'channel': 'sys:storage:/;usage',
# 'value': 6353821696,
# 'type': 'memory',
# 'type': 'b'
# }, {
# 'channel': 'sys:storage:/mnt/cdrom;capacity',
# 'value': 479383552,
# 'type': 'memory',
# 'type': 'b'
# }, {
# 'channel': 'sys:storage:/mnt/cdrom;usage',
# 'value': 0,
# 'type': 'memory',
# 'type': 'b'
# }]
# """
# storage_info = []
# try:
# for partition in psutil.disk_partitions(True):
# try:
# if partition.mountpoint == '/':
# usage = psutil.disk_usage(partition.mountpoint)
# if usage.total:
# if not types or cayennemqtt.USAGE in types:
# cayennemqtt.DataChannel.add(storage_info, cayennemqtt.SYS_STORAGE, partition.mountpoint, cayennemqtt.USAGE, usage.used, type='memory', unit='b')
# if not types or cayennemqtt.CAPACITY in types:
# cayennemqtt.DataChannel.add(storage_info, cayennemqtt.SYS_STORAGE, partition.mountpoint, cayennemqtt.CAPACITY, usage.total, type='memory', unit='b')
# except:
# pass
# except:
# exception('Error getting disk info')
# return storage_info
#
# def getNetworkInfo(self):
# """Get network information as a list formatted for Cayenne MQTT
#
# Returned list example::
#
# [{
# 'channel': 'sys:net;ip',
# 'value': '192.168.0.2'
# }]
# """
# network_info = []
# try:
# default_interface = netifaces.gateways()['default'][netifaces.AF_INET][1]
# addresses = netifaces.ifaddresses(default_interface)
# addr = addresses[netifaces.AF_INET][0]['addr']
# cayennemqtt.DataChannel.add(network_info, cayennemqtt.SYS_NET, suffix=cayennemqtt.IP, value=addr)
# except:
# exception('Error getting network info')
# return network_info
#
# Path: myDevices/utils/logger.py
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
, which may contain function names, class names, or code. Output only the next line. | def testSystemInfo(self): |
Continue the code snippet: <|code_start|>
connection = None
cursor = None
mutex = RLock()
class DbManager(Singleton):
def CreateTable(tablename, columns, required_columns = None):
<|code_end|>
. Use current file imports:
from sqlite3 import connect
from myDevices.utils.logger import exception, info, warn, error, debug, setDebug
from threading import RLock
from time import sleep
from myDevices.utils.singleton import Singleton
and context (classes, functions, or code) from other files:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# Path: myDevices/utils/singleton.py
# class Singleton(_Singleton('SingletonMeta', (object,), {})): pass
. Output only the next line. | try: |
Using the snippet: <|code_start|>
connection = None
cursor = None
mutex = RLock()
class DbManager(Singleton):
def CreateTable(tablename, columns, required_columns = None):
try:
with mutex:
if not cursor or not connection:
return False
if required_columns and len(required_columns):
cursor.execute('PRAGMA table_info(' + tablename + ')')
actual_columns = [column[1] for column in cursor.fetchall()]
if actual_columns != required_columns:
try:
if actual_columns:
warn(tablename + ' table columns {} do not match required columns {}, dropping table'.format(actual_columns, required_columns) + " From: " + str(hex(id(connection))) + " " + str(hex(id(cursor))) )
cursor.execute('DROP TABLE ' + tablename)
connection.commit()
except:
<|code_end|>
, determine the next line of code. You have imports:
from sqlite3 import connect
from myDevices.utils.logger import exception, info, warn, error, debug, setDebug
from threading import RLock
from time import sleep
from myDevices.utils.singleton import Singleton
and context (class names, function names, or code) available:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# Path: myDevices/utils/singleton.py
# class Singleton(_Singleton('SingletonMeta', (object,), {})): pass
. Output only the next line. | pass |
Here is a snippet: <|code_start|> cursor.execute(statement)
connection.commit()
return True
def Delete(tablename, id):
if not cursor or not connection:
return False
with mutex:
statement = 'DELETE FROM ' + tablename + ' WHERE id = ?'
cursor.execute(statement, (id,))
connection.commit()
return True
def Select(tablename, where = ''):
if not cursor or not connection:
return
with mutex:
cursor.execute("select * from " + tablename + where)
return cursor.fetchall()
def DeleteAll(tablename):
if not cursor or not connection:
return False
with mutex:
statement = 'DELETE FROM ' + tablename
cursor.execute(statement)
connection.commit()
return True
def test():
tablename = 'test_sensors'
DbManager.CreateTable(tablename, "id TEXT PRIMARY KEY", ['id'])
idtest = "XXXXXXXR"
<|code_end|>
. Write the next line using the current file imports:
from sqlite3 import connect
from myDevices.utils.logger import exception, info, warn, error, debug, setDebug
from threading import RLock
from time import sleep
from myDevices.utils.singleton import Singleton
and context from other files:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# Path: myDevices/utils/singleton.py
# class Singleton(_Singleton('SingletonMeta', (object,), {})): pass
, which may include functions, classes, or code. Output only the next line. | rowId = DbManager.Insert(tablename, idtest) |
Given the following code snippet before the placeholder: <|code_start|>
# Topics
DATA_TOPIC = 'data/json'
COMMAND_TOPIC = 'cmd'
COMMAND_JSON_TOPIC = 'cmd.json'
COMMAND_RESPONSE_TOPIC = 'response'
JOBS_TOPIC = 'jobs.json'
# Data Channels
SYS_HARDWARE_MAKE = 'sys:hw:make'
SYS_HARDWARE_MODEL = 'sys:hw:model'
SYS_OS_NAME = 'sys:os:name'
<|code_end|>
, predict the next line using imports from the current file:
import time
import paho.mqtt.client as mqtt
from json import loads, decoder
from ssl import PROTOCOL_TLSv1_2
from myDevices.utils.logger import debug, error, exception, info, logJson, warn
and context including class names, function names, and sometimes code from other files:
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def logJson(message, category = ''):
# if debugEnabled() == False:
# return
# if checkFlood(message):
# return
# try:
# if category not in jsonData:
# jsonData[category] = []
# if len(jsonData[category]) > MAX_JSON_ITEMS_PER_CATEGORY:
# del jsonData[category][0]
# #2016-03-23 03:53:16 - myDevices - INFO -
# message = str(datetime.today()) + ' - myDevices - INFO - ' + message
# jsonData[category].append(message)
# rotatorJson()
# except Exception as ex:
# exception("logJson failed")
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
. Output only the next line. | SYS_OS_VERSION = 'sys:os:version' |
Given snippet: <|code_start|>
# Topics
DATA_TOPIC = 'data/json'
COMMAND_TOPIC = 'cmd'
COMMAND_JSON_TOPIC = 'cmd.json'
COMMAND_RESPONSE_TOPIC = 'response'
JOBS_TOPIC = 'jobs.json'
# Data Channels
SYS_HARDWARE_MAKE = 'sys:hw:make'
SYS_HARDWARE_MODEL = 'sys:hw:model'
SYS_OS_NAME = 'sys:os:name'
SYS_OS_VERSION = 'sys:os:version'
SYS_NET = 'sys:net'
SYS_STORAGE = 'sys:storage'
SYS_RAM = 'sys:ram'
SYS_CPU = 'sys:cpu'
SYS_I2C = 'sys:i2c'
SYS_SPI = 'sys:spi'
SYS_UART = 'sys:uart'
SYS_ONEWIRE = 'sys:1wire'
SYS_DEVICETREE = 'sys:devicetree'
SYS_GPIO = 'sys:gpio'
SYS_POWER_RESET = 'sys:pwr:reset'
SYS_POWER_HALT = 'sys:pwr:halt'
AGENT_VERSION = 'agent:version'
AGENT_DEVICES = 'agent:devices'
AGENT_MANAGE = 'agent:manage'
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import time
import paho.mqtt.client as mqtt
from json import loads, decoder
from ssl import PROTOCOL_TLSv1_2
from myDevices.utils.logger import debug, error, exception, info, logJson, warn
and context:
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def logJson(message, category = ''):
# if debugEnabled() == False:
# return
# if checkFlood(message):
# return
# try:
# if category not in jsonData:
# jsonData[category] = []
# if len(jsonData[category]) > MAX_JSON_ITEMS_PER_CATEGORY:
# del jsonData[category][0]
# #2016-03-23 03:53:16 - myDevices - INFO -
# message = str(datetime.today()) + ' - myDevices - INFO - ' + message
# jsonData[category].append(message)
# rotatorJson()
# except Exception as ex:
# exception("logJson failed")
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
which might include code, classes, or functions. Output only the next line. | AGENT_SCHEDULER = 'agent:scheduler' |
Predict the next line after this snippet: <|code_start|>
# Topics
DATA_TOPIC = 'data/json'
COMMAND_TOPIC = 'cmd'
COMMAND_JSON_TOPIC = 'cmd.json'
COMMAND_RESPONSE_TOPIC = 'response'
JOBS_TOPIC = 'jobs.json'
# Data Channels
SYS_HARDWARE_MAKE = 'sys:hw:make'
SYS_HARDWARE_MODEL = 'sys:hw:model'
SYS_OS_NAME = 'sys:os:name'
SYS_OS_VERSION = 'sys:os:version'
SYS_NET = 'sys:net'
SYS_STORAGE = 'sys:storage'
SYS_RAM = 'sys:ram'
SYS_CPU = 'sys:cpu'
SYS_I2C = 'sys:i2c'
<|code_end|>
using the current file's imports:
import time
import paho.mqtt.client as mqtt
from json import loads, decoder
from ssl import PROTOCOL_TLSv1_2
from myDevices.utils.logger import debug, error, exception, info, logJson, warn
and any relevant context from other files:
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def logJson(message, category = ''):
# if debugEnabled() == False:
# return
# if checkFlood(message):
# return
# try:
# if category not in jsonData:
# jsonData[category] = []
# if len(jsonData[category]) > MAX_JSON_ITEMS_PER_CATEGORY:
# del jsonData[category][0]
# #2016-03-23 03:53:16 - myDevices - INFO -
# message = str(datetime.today()) + ' - myDevices - INFO - ' + message
# jsonData[category].append(message)
# rotatorJson()
# except Exception as ex:
# exception("logJson failed")
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
. Output only the next line. | SYS_SPI = 'sys:spi' |
Next line prediction: <|code_start|> os.close(self.fd)
self.fd = 0
self.family = family
if slave != None:
addr = slave.split("-")
if len(addr) == 1:
self.slave = "%02x-%s" % (family, slave)
elif len(addr) == 2:
prefix = int(addr[0], 16)
if family > 0 and family != prefix:
raise Exception("1-Wire slave address %s does not match family %02x" % (slave, family))
self.slave = slave
else:
devices = self.deviceList()
if len(devices) == 0:
raise Exception("No device match family %02x" % family)
self.slave = devices[0]
loadExtraModule(extra)
def __str__(self):
return "1-Wire(slave=%s)" % self.slave
def deviceList(self):
devices = []
with open(self.device) as f:
lines = f.read().split("\n")
if self.family > 0:
prefix = "%02x-" % self.family
<|code_end|>
. Use current file imports:
(import os
from myDevices.devices.bus import Bus, loadModule
from myDevices.utils.logger import *)
and context including class names, function names, or small code snippets from other files:
# Path: myDevices/devices/bus.py
# class Bus():
# def __init__(self, busName, device, flag=os.O_RDWR):
# enableBus(busName)
# self.busName = busName
# self.device = device
# self.flag = flag
# self.fd = 0
# self.open()
#
# def open(self):
# self.fd = os.open(self.device, self.flag)
# if self.fd < 0:
# raise Exception("Cannot open %s" % self.device)
#
# def close(self):
# if self.fd > 0:
# os.close(self.fd)
#
# def readDevice(self, size=1):
# if self.fd > 0:
# return os.read(self.fd, size)
# raise Exception("Device %s not open" % self.device)
#
# def readBytes(self, size=1):
# return bytearray(self.readDevice(size))
#
# def readByte(self):
# return self.readBytes()[0]
#
# def writeDevice(self, string):
# if self.fd > 0:
# return os.write(self.fd, string)
# raise Exception("Device %s not open" % self.device)
#
# def writeBytes(self, data):
# return self.writeDevice(bytearray(data))
#
# def writeByte(self, value):
# self.writeBytes([value])
#
# def loadModule(module):
# subprocess.call(["sudo", "modprobe", module])
. Output only the next line. | for line in lines: |
Using the snippet: <|code_start|>
class OneWire(Bus):
def __init__(self, slave=None, family=0, extra=None):
Bus.__init__(self, "ONEWIRE", "/sys/bus/w1/devices/w1_bus_master1/w1_master_slaves", os.O_RDONLY)
if self.fd > 0:
os.close(self.fd)
self.fd = 0
self.family = family
if slave != None:
addr = slave.split("-")
if len(addr) == 1:
self.slave = "%02x-%s" % (family, slave)
elif len(addr) == 2:
prefix = int(addr[0], 16)
if family > 0 and family != prefix:
raise Exception("1-Wire slave address %s does not match family %02x" % (slave, family))
self.slave = slave
else:
devices = self.deviceList()
if len(devices) == 0:
raise Exception("No device match family %02x" % family)
self.slave = devices[0]
loadExtraModule(extra)
def __str__(self):
return "1-Wire(slave=%s)" % self.slave
def deviceList(self):
<|code_end|>
, determine the next line of code. You have imports:
import os
from myDevices.devices.bus import Bus, loadModule
from myDevices.utils.logger import *
and context (class names, function names, or code) available:
# Path: myDevices/devices/bus.py
# class Bus():
# def __init__(self, busName, device, flag=os.O_RDWR):
# enableBus(busName)
# self.busName = busName
# self.device = device
# self.flag = flag
# self.fd = 0
# self.open()
#
# def open(self):
# self.fd = os.open(self.device, self.flag)
# if self.fd < 0:
# raise Exception("Cannot open %s" % self.device)
#
# def close(self):
# if self.fd > 0:
# os.close(self.fd)
#
# def readDevice(self, size=1):
# if self.fd > 0:
# return os.read(self.fd, size)
# raise Exception("Device %s not open" % self.device)
#
# def readBytes(self, size=1):
# return bytearray(self.readDevice(size))
#
# def readByte(self):
# return self.readBytes()[0]
#
# def writeDevice(self, string):
# if self.fd > 0:
# return os.write(self.fd, string)
# raise Exception("Device %s not open" % self.device)
#
# def writeBytes(self, data):
# return self.writeDevice(bytearray(data))
#
# def writeByte(self, value):
# self.writeBytes([value])
#
# def loadModule(module):
# subprocess.call(["sudo", "modprobe", module])
. Output only the next line. | devices = [] |
Here is a snippet: <|code_start|> LOGGER.info(message)
def warn(message):
if checkFlood(message):
return
LOGGER.warn(message)
def error(message, *args, **kwargs):
if checkFlood(message):
return
LOGGER.error(message, *args, **kwargs)
def exception(message):
if checkFlood(message):
return
LOGGER.exception(message)
def logJson(message, category = ''):
if debugEnabled() == False:
return
if checkFlood(message):
return
try:
if category not in jsonData:
jsonData[category] = []
if len(jsonData[category]) > MAX_JSON_ITEMS_PER_CATEGORY:
del jsonData[category][0]
#2016-03-23 03:53:16 - myDevices - INFO -
message = str(datetime.today()) + ' - myDevices - INFO - ' + message
jsonData[category].append(message)
<|code_end|>
. Write the next line using the current file imports:
from logging import Formatter, getLogger, StreamHandler, WARN, INFO, DEBUG
from logging.handlers import TimedRotatingFileHandler,MemoryHandler, RotatingFileHandler
from inspect import getouterframes, currentframe, getargvalues
from traceback import extract_stack
from os import path, getpid, remove
from datetime import datetime
from hashlib import sha256
from myDevices.utils.threadpool import ThreadPool
from glob import iglob
import tarfile
import time
and context from other files:
# Path: myDevices/utils/threadpool.py
# class ThreadPool(Singleton):
# """Singleton thread pool class"""
#
# @staticmethod
# def Submit(func):
# """Submit a function for the thread pool to run"""
# executor.submit(func)
#
# @staticmethod
# def Shutdown():
# """Shutdown the thread pool"""
# executor.shutdown()
, which may include functions, classes, or code. Output only the next line. | rotatorJson() |
Given the following code snippet before the placeholder: <|code_start|>
if __name__ == '__main__':
# Run the code to disable a plugin in a script so it can be called via sudo
setInfo()
info(sys.argv)
if len(sys.argv) != 3:
error('Plugin not disabled, invalid arguments')
<|code_end|>
, predict the next line using imports from the current file:
import sys
from myDevices.utils.config import Config
from myDevices.utils.logger import setInfo, info, error
from myDevices.plugins.manager import PLUGIN_FOLDER
and context including class names, function names, and sometimes code from other files:
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/logger.py
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# Path: myDevices/plugins/manager.py
# PLUGIN_FOLDER = '/etc/myDevices/plugins'
. Output only the next line. | sys.exit(1) |
Based on the snippet: <|code_start|>
if __name__ == '__main__':
# Run the code to disable a plugin in a script so it can be called via sudo
setInfo()
info(sys.argv)
if len(sys.argv) != 3:
error('Plugin not disabled, invalid arguments')
sys.exit(1)
filename = sys.argv[1]
if filename.startswith(PLUGIN_FOLDER) and filename.endswith('.plugin'):
section = sys.argv[2]
config = Config(filename)
<|code_end|>
, predict the immediate next line with the help of imports:
import sys
from myDevices.utils.config import Config
from myDevices.utils.logger import setInfo, info, error
from myDevices.plugins.manager import PLUGIN_FOLDER
and context (classes, functions, sometimes code) from other files:
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/logger.py
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# Path: myDevices/plugins/manager.py
# PLUGIN_FOLDER = '/etc/myDevices/plugins'
. Output only the next line. | if section in config.sections(): |
Given the code snippet: <|code_start|>
if __name__ == '__main__':
# Run the code to disable a plugin in a script so it can be called via sudo
setInfo()
info(sys.argv)
if len(sys.argv) != 3:
error('Plugin not disabled, invalid arguments')
sys.exit(1)
<|code_end|>
, generate the next line using the imports in this file:
import sys
from myDevices.utils.config import Config
from myDevices.utils.logger import setInfo, info, error
from myDevices.plugins.manager import PLUGIN_FOLDER
and context (functions, classes, or occasionally code) from other files:
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/logger.py
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# Path: myDevices/plugins/manager.py
# PLUGIN_FOLDER = '/etc/myDevices/plugins'
. Output only the next line. | filename = sys.argv[1] |
Continue the code snippet: <|code_start|>
if __name__ == '__main__':
# Run the code to disable a plugin in a script so it can be called via sudo
setInfo()
info(sys.argv)
if len(sys.argv) != 3:
error('Plugin not disabled, invalid arguments')
sys.exit(1)
filename = sys.argv[1]
if filename.startswith(PLUGIN_FOLDER) and filename.endswith('.plugin'):
section = sys.argv[2]
config = Config(filename)
<|code_end|>
. Use current file imports:
import sys
from myDevices.utils.config import Config
from myDevices.utils.logger import setInfo, info, error
from myDevices.plugins.manager import PLUGIN_FOLDER
and context (classes, functions, or code) from other files:
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/logger.py
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# Path: myDevices/plugins/manager.py
# PLUGIN_FOLDER = '/etc/myDevices/plugins'
. Output only the next line. | if section in config.sections(): |
Given snippet: <|code_start|>
if __name__ == '__main__':
# Run the code to disable a plugin in a script so it can be called via sudo
setInfo()
info(sys.argv)
if len(sys.argv) != 3:
error('Plugin not disabled, invalid arguments')
sys.exit(1)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import sys
from myDevices.utils.config import Config
from myDevices.utils.logger import setInfo, info, error
from myDevices.plugins.manager import PLUGIN_FOLDER
and context:
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/logger.py
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# Path: myDevices/plugins/manager.py
# PLUGIN_FOLDER = '/etc/myDevices/plugins'
which might include code, classes, or functions. Output only the next line. | filename = sys.argv[1] |
Using the snippet: <|code_start|> speed = getattr(termios, aname)
# input speed
options[4] = speed
# output speed
options[5] = speed
termios.tcsetattr(self.fd, termios.TCSADRAIN, options)
def __str__(self):
return "Serial(%s, %dbps)" % (self.device, self.baudrate)
def __family__(self):
return "Serial"
def available(self):
s = fcntl.ioctl(self.fd, TIOCINQ, TIOCM_zero_str)
return struct.unpack('I',s)[0]
#@request("GET", "")
@response("%s")
def readString(self):
if self.available() > 0:
return self.read(self.available()).decode()
return ""
#@request("POST", "", "data")
def writeString(self, data):
if isinstance(data, str):
self.write(data.encode())
else:
<|code_end|>
, determine the next line of code. You have imports:
import os
import fcntl
import struct
import termios
from myDevices.devices.bus import Bus
from myDevices.decorators.rest import request, response
and context (class names, function names, or code) available:
# Path: myDevices/devices/bus.py
# class Bus():
# def __init__(self, busName, device, flag=os.O_RDWR):
# enableBus(busName)
# self.busName = busName
# self.device = device
# self.flag = flag
# self.fd = 0
# self.open()
#
# def open(self):
# self.fd = os.open(self.device, self.flag)
# if self.fd < 0:
# raise Exception("Cannot open %s" % self.device)
#
# def close(self):
# if self.fd > 0:
# os.close(self.fd)
#
# def readDevice(self, size=1):
# if self.fd > 0:
# return os.read(self.fd, size)
# raise Exception("Device %s not open" % self.device)
#
# def readBytes(self, size=1):
# return bytearray(self.readDevice(size))
#
# def readByte(self):
# return self.readBytes()[0]
#
# def writeDevice(self, string):
# if self.fd > 0:
# return os.write(self.fd, string)
# raise Exception("Device %s not open" % self.device)
#
# def writeBytes(self, data):
# return self.writeDevice(bytearray(data))
#
# def writeByte(self, value):
# self.writeBytes([value])
. Output only the next line. | self.write(data) |
Given snippet: <|code_start|> self.appSettings = config
self.onUpdateConfig = onUpdateConfig
self.env = self.appSettings.get('Agent', 'Environment', fallback='live')
global SETUP_URL
global UPDATE_URL
if self.env == 'live':
SETUP_URL = SETUP_URL + SETUP_NAME
else:
SETUP_URL = SETUP_URL + self.env + '_' + SETUP_NAME
UPDATE_URL = UPDATE_URL + self.env
# UPDATE_URL = self.appSettings.get('Agent', 'UpdateUrl', UPDATE_URL)
# SETUP_URL = self.appSettings.get('Agent', 'SetupUrl', SETUP_URL)
self.scheduler = scheduler(time, sleep)
self.Continue = True
self.currentVersion = ''
self.newVersion = ''
# self.downloadUrl = ''
self.UpdateCleanup()
self.startTime = datetime.now() - timedelta(days=1)
def run(self):
debug('UpdaterThread started')
while self.Continue:
sleep(TIME_TO_SLEEP)
self.SetupUpdater()
self.scheduler.run()
debug('UpdaterThread finished')
def stop(self):
debug('Updater stop called')
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from myDevices.utils.logger import exception, info, warn, error, debug, setDebug
from time import time, sleep
from sched import scheduler
from distutils.version import LooseVersion, StrictVersion
from os import mkdir, path
from threading import Thread
from shutil import rmtree
from datetime import datetime, timedelta
from myDevices.utils.config import Config
from myDevices.utils.subprocess import executeCommand
from urllib.request import urlopen
from urllib2 import urlopen
import random
and context:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/subprocess.py
# def executeCommand(command, increaseMemoryLimit=False, disablePipe=False):
# """Execute a specified command, increasing the processes memory limits if specified"""
# debug('executeCommand: ' + command)
# output = ''
# returncode = 1
# try:
# preexec = None
# pipe = PIPE
# if increaseMemoryLimit:
# preexec = setMemoryLimits
# if disablePipe:
# debug('Disable pipe to prevent child exiting when parent exits')
# pipe = DEVNULL
# process = Popen(command, stdout=pipe, stderr=pipe, shell=True, preexec_fn=preexec)
# (stdout_data, stderr_data) = process.communicate()
# returncode = process.wait()
# returncode = process.returncode
# # debug('executeCommand: stdout_data {}, stderr_data {}'.format(stdout_data, stderr_data))
# if stdout_data:
# output = stdout_data.decode('utf-8')
# stdout_data = None
# except:
# exception('executeCommand failed: ' + command)
# return (output, returncode)
which might include code, classes, or functions. Output only the next line. | self.Continue = False |
Predict the next line for this snippet: <|code_start|>TIME_TO_CHECK = 60 + random.randint(60, 300) #seconds - at least 2 minutes
TIME_TO_SLEEP = 60
UPDATE_URL = 'https://updates.mydevices.com/raspberry/updatecfg'
SETUP_URL = 'https://updates.mydevices.com/raspberry/'
try:
# For Python 3.0 and later
except ImportError:
# Fall back to Python 2's urllib2
class Updater(Thread):
def __init__(self, config, onUpdateConfig = None):
#disable debug after testing is finished
#setDebug()
Thread.__init__(self, name='updater')
self.setDaemon(True)
self.appSettings = config
self.onUpdateConfig = onUpdateConfig
self.env = self.appSettings.get('Agent', 'Environment', fallback='live')
global SETUP_URL
global UPDATE_URL
if self.env == 'live':
SETUP_URL = SETUP_URL + SETUP_NAME
else:
SETUP_URL = SETUP_URL + self.env + '_' + SETUP_NAME
UPDATE_URL = UPDATE_URL + self.env
# UPDATE_URL = self.appSettings.get('Agent', 'UpdateUrl', UPDATE_URL)
# SETUP_URL = self.appSettings.get('Agent', 'SetupUrl', SETUP_URL)
<|code_end|>
with the help of current file imports:
from myDevices.utils.logger import exception, info, warn, error, debug, setDebug
from time import time, sleep
from sched import scheduler
from distutils.version import LooseVersion, StrictVersion
from os import mkdir, path
from threading import Thread
from shutil import rmtree
from datetime import datetime, timedelta
from myDevices.utils.config import Config
from myDevices.utils.subprocess import executeCommand
from urllib.request import urlopen
from urllib2 import urlopen
import random
and context from other files:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/subprocess.py
# def executeCommand(command, increaseMemoryLimit=False, disablePipe=False):
# """Execute a specified command, increasing the processes memory limits if specified"""
# debug('executeCommand: ' + command)
# output = ''
# returncode = 1
# try:
# preexec = None
# pipe = PIPE
# if increaseMemoryLimit:
# preexec = setMemoryLimits
# if disablePipe:
# debug('Disable pipe to prevent child exiting when parent exits')
# pipe = DEVNULL
# process = Popen(command, stdout=pipe, stderr=pipe, shell=True, preexec_fn=preexec)
# (stdout_data, stderr_data) = process.communicate()
# returncode = process.wait()
# returncode = process.returncode
# # debug('executeCommand: stdout_data {}, stderr_data {}'.format(stdout_data, stderr_data))
# if stdout_data:
# output = stdout_data.decode('utf-8')
# stdout_data = None
# except:
# exception('executeCommand failed: ' + command)
# return (output, returncode)
, which may contain function names, class names, or code. Output only the next line. | self.scheduler = scheduler(time, sleep) |
Based on the snippet: <|code_start|> debug('Updater cleanup executes delete')
rmtree(UPDATE_PATH)
return
except:
exception('UpdateCleanup error')
def CheckUpdate(self):
doUpdates = self.appSettings.get('Agent', 'DoUpdates', 'true')
if doUpdates.lower() == 'false':
info('DoUpdates is false, skipping update check')
return
if self.onUpdateConfig:
self.onUpdateConfig()
now = datetime.now()
info('Checking for updates...')
elapsedTime=now-self.startTime
if elapsedTime.total_seconds() < TIME_TO_CHECK:
return
self.startTime = datetime.now()
if path.exists(UPDATE_PATH) == True:
error('myDevices updater another update in progress')
return
sleep(1)
# Run the update as root
executeCommand('sudo python3 -m myDevices.cloud.doupdatecheck')
def DoUpdateCheck(self):
mkdir(UPDATE_PATH)
sleep(1)
try:
<|code_end|>
, predict the immediate next line with the help of imports:
from myDevices.utils.logger import exception, info, warn, error, debug, setDebug
from time import time, sleep
from sched import scheduler
from distutils.version import LooseVersion, StrictVersion
from os import mkdir, path
from threading import Thread
from shutil import rmtree
from datetime import datetime, timedelta
from myDevices.utils.config import Config
from myDevices.utils.subprocess import executeCommand
from urllib.request import urlopen
from urllib2 import urlopen
import random
and context (classes, functions, sometimes code) from other files:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/subprocess.py
# def executeCommand(command, increaseMemoryLimit=False, disablePipe=False):
# """Execute a specified command, increasing the processes memory limits if specified"""
# debug('executeCommand: ' + command)
# output = ''
# returncode = 1
# try:
# preexec = None
# pipe = PIPE
# if increaseMemoryLimit:
# preexec = setMemoryLimits
# if disablePipe:
# debug('Disable pipe to prevent child exiting when parent exits')
# pipe = DEVNULL
# process = Popen(command, stdout=pipe, stderr=pipe, shell=True, preexec_fn=preexec)
# (stdout_data, stderr_data) = process.communicate()
# returncode = process.wait()
# returncode = process.returncode
# # debug('executeCommand: stdout_data {}, stderr_data {}'.format(stdout_data, stderr_data))
# if stdout_data:
# output = stdout_data.decode('utf-8')
# stdout_data = None
# except:
# exception('executeCommand failed: ' + command)
# return (output, returncode)
. Output only the next line. | self.currentVersion = self.appSettings.get('Agent', 'Version', fallback=None) |
Predict the next line for this snippet: <|code_start|>
SETUP_NAME = 'update_raspberrypi.sh'
INSTALL_PATH = '/etc/myDevices/'
UPDATE_PATH = INSTALL_PATH + 'updates/'
UPDATE_CFG = UPDATE_PATH + 'updatecfg'
SETUP_PATH = UPDATE_PATH + SETUP_NAME
TIME_TO_CHECK = 60 + random.randint(60, 300) #seconds - at least 2 minutes
TIME_TO_SLEEP = 60
UPDATE_URL = 'https://updates.mydevices.com/raspberry/updatecfg'
SETUP_URL = 'https://updates.mydevices.com/raspberry/'
try:
# For Python 3.0 and later
except ImportError:
# Fall back to Python 2's urllib2
<|code_end|>
with the help of current file imports:
from myDevices.utils.logger import exception, info, warn, error, debug, setDebug
from time import time, sleep
from sched import scheduler
from distutils.version import LooseVersion, StrictVersion
from os import mkdir, path
from threading import Thread
from shutil import rmtree
from datetime import datetime, timedelta
from myDevices.utils.config import Config
from myDevices.utils.subprocess import executeCommand
from urllib.request import urlopen
from urllib2 import urlopen
import random
and context from other files:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/subprocess.py
# def executeCommand(command, increaseMemoryLimit=False, disablePipe=False):
# """Execute a specified command, increasing the processes memory limits if specified"""
# debug('executeCommand: ' + command)
# output = ''
# returncode = 1
# try:
# preexec = None
# pipe = PIPE
# if increaseMemoryLimit:
# preexec = setMemoryLimits
# if disablePipe:
# debug('Disable pipe to prevent child exiting when parent exits')
# pipe = DEVNULL
# process = Popen(command, stdout=pipe, stderr=pipe, shell=True, preexec_fn=preexec)
# (stdout_data, stderr_data) = process.communicate()
# returncode = process.wait()
# returncode = process.returncode
# # debug('executeCommand: stdout_data {}, stderr_data {}'.format(stdout_data, stderr_data))
# if stdout_data:
# output = stdout_data.decode('utf-8')
# stdout_data = None
# except:
# exception('executeCommand failed: ' + command)
# return (output, returncode)
, which may contain function names, class names, or code. Output only the next line. | class Updater(Thread): |
Here is a snippet: <|code_start|> def DownloadFile(self, url, localPath):
try:
info(url + ' ' + localPath)
with urlopen(url) as response:
with open(localPath, 'wb') as output:
output.write(response.read())
debug('Updater download success')
return True
except:
debug('Updater download failed')
return False
def ExecuteUpdate(self):
debug('Execute update: {} {}'.format(SETUP_URL, SETUP_PATH))
retValue = self.DownloadFile(SETUP_URL, SETUP_PATH)
if retValue is False:
return retValue
command = "chmod +x " + SETUP_PATH
(output, returncode) = executeCommand(command)
del output
command = "nohup " + SETUP_PATH + ' -update >/var/log/myDevices/myDevices.update 2>/var/log/myDevices/myDevices.update.err'
debug('execute command started: {}'.format(command))
(output, returncode) = executeCommand(command)
del output
debug('Updater execute command finished')
def CheckVersion(self, currentVersion, newVersion):
debug('')
bVal = False
try:
<|code_end|>
. Write the next line using the current file imports:
from myDevices.utils.logger import exception, info, warn, error, debug, setDebug
from time import time, sleep
from sched import scheduler
from distutils.version import LooseVersion, StrictVersion
from os import mkdir, path
from threading import Thread
from shutil import rmtree
from datetime import datetime, timedelta
from myDevices.utils.config import Config
from myDevices.utils.subprocess import executeCommand
from urllib.request import urlopen
from urllib2 import urlopen
import random
and context from other files:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/subprocess.py
# def executeCommand(command, increaseMemoryLimit=False, disablePipe=False):
# """Execute a specified command, increasing the processes memory limits if specified"""
# debug('executeCommand: ' + command)
# output = ''
# returncode = 1
# try:
# preexec = None
# pipe = PIPE
# if increaseMemoryLimit:
# preexec = setMemoryLimits
# if disablePipe:
# debug('Disable pipe to prevent child exiting when parent exits')
# pipe = DEVNULL
# process = Popen(command, stdout=pipe, stderr=pipe, shell=True, preexec_fn=preexec)
# (stdout_data, stderr_data) = process.communicate()
# returncode = process.wait()
# returncode = process.returncode
# # debug('executeCommand: stdout_data {}, stderr_data {}'.format(stdout_data, stderr_data))
# if stdout_data:
# output = stdout_data.decode('utf-8')
# stdout_data = None
# except:
# exception('executeCommand failed: ' + command)
# return (output, returncode)
, which may include functions, classes, or code. Output only the next line. | bVal = LooseVersion(currentVersion) < LooseVersion(newVersion) |
Given the code snippet: <|code_start|>
SETUP_NAME = 'update_raspberrypi.sh'
INSTALL_PATH = '/etc/myDevices/'
UPDATE_PATH = INSTALL_PATH + 'updates/'
UPDATE_CFG = UPDATE_PATH + 'updatecfg'
SETUP_PATH = UPDATE_PATH + SETUP_NAME
TIME_TO_CHECK = 60 + random.randint(60, 300) #seconds - at least 2 minutes
TIME_TO_SLEEP = 60
UPDATE_URL = 'https://updates.mydevices.com/raspberry/updatecfg'
SETUP_URL = 'https://updates.mydevices.com/raspberry/'
try:
# For Python 3.0 and later
except ImportError:
# Fall back to Python 2's urllib2
class Updater(Thread):
def __init__(self, config, onUpdateConfig = None):
#disable debug after testing is finished
#setDebug()
Thread.__init__(self, name='updater')
<|code_end|>
, generate the next line using the imports in this file:
from myDevices.utils.logger import exception, info, warn, error, debug, setDebug
from time import time, sleep
from sched import scheduler
from distutils.version import LooseVersion, StrictVersion
from os import mkdir, path
from threading import Thread
from shutil import rmtree
from datetime import datetime, timedelta
from myDevices.utils.config import Config
from myDevices.utils.subprocess import executeCommand
from urllib.request import urlopen
from urllib2 import urlopen
import random
and context (functions, classes, or occasionally code) from other files:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def warn(message):
# if checkFlood(message):
# return
# LOGGER.warn(message)
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/subprocess.py
# def executeCommand(command, increaseMemoryLimit=False, disablePipe=False):
# """Execute a specified command, increasing the processes memory limits if specified"""
# debug('executeCommand: ' + command)
# output = ''
# returncode = 1
# try:
# preexec = None
# pipe = PIPE
# if increaseMemoryLimit:
# preexec = setMemoryLimits
# if disablePipe:
# debug('Disable pipe to prevent child exiting when parent exits')
# pipe = DEVNULL
# process = Popen(command, stdout=pipe, stderr=pipe, shell=True, preexec_fn=preexec)
# (stdout_data, stderr_data) = process.communicate()
# returncode = process.wait()
# returncode = process.returncode
# # debug('executeCommand: stdout_data {}, stderr_data {}'.format(stdout_data, stderr_data))
# if stdout_data:
# output = stdout_data.decode('utf-8')
# stdout_data = None
# except:
# exception('executeCommand failed: ' + command)
# return (output, returncode)
. Output only the next line. | self.setDaemon(True) |
Predict the next line for this snippet: <|code_start|>
class ApiClientTest(unittest.TestCase):
def testMessageBody(self):
cayenneApiClient = CayenneApiClient('https://api.mydevices.com')
message = loads(cayenneApiClient.getMessageBody('invite_code'))
# info(message)
self.assertIn('id', message)
self.assertIn('type', message)
self.assertIn('hardware_id', message)
self.assertIn('properties', message)
<|code_end|>
with the help of current file imports:
import unittest
from myDevices.utils.logger import exception, setDebug, info, debug, error, logToFile, setInfo
from myDevices.cloud.apiclient import CayenneApiClient
from json import loads
and context from other files:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def logToFile(filename=None):
# if not filename:
# filename = '/var/log/myDevices/cayenne.log'
# handler = TimedRotatingFileHandler(filename, when="midnight", interval=1, backupCount=7)
# handler.setFormatter(LOG_FORMATTER)
# handler.rotator=rotator
# handler.namer=namer
# LOGGER.addHandler(handler)
#
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# Path: myDevices/cloud/apiclient.py
# class CayenneApiClient:
# def __init__(self, host):
# self.host = host
# self.auth = None
# self.session = FuturesSession(executor=ThreadPoolExecutor(max_workers=1))
#
# def sendRequest(self, method, uri, body=None):
# if self.session is not None:
# headers = {}
# request_url = self.host + uri
# future = None
# self.session.headers['Content-Type'] = 'application/json'
# self.session.headers['Accept'] = 'application/json'
# if self.auth is not None:
# self.session.headers['Authorization'] = self.auth
# try:
# if method == 'GET':
# future = self.session.get(request_url)
# if method == 'POST':
# future = self.session.post(request_url, data=body)
# if method == 'PUT':
# future = self.session.put(request_url, data=body)
# if method == 'DELETE':
# future = self.session.delete(request_url)
# except Exception as ex:
# error('sendRequest exception: ' + str(ex))
# return None
# try:
# response = future.result()
# except:
# return None
# return response
# exception("No data received")
#
# def getMessageBody(self, inviteCode):
# body = {'id': inviteCode}
# hardware = Hardware()
# if hardware.Serial and hardware.isRaspberryPi():
# body['type'] = 'rpi'
# body['hardware_id'] = hardware.Serial
# else:
# hardware_id = hardware.getMac()
# if hardware_id:
# body['type'] = 'mac'
# body['hardware_id'] = hardware_id
# try:
# system_data = []
# cayennemqtt.DataChannel.add(system_data, cayennemqtt.SYS_HARDWARE_MAKE, value=hardware.getManufacturer(), type='string', unit='utf8')
# cayennemqtt.DataChannel.add(system_data, cayennemqtt.SYS_HARDWARE_MODEL, value=hardware.getModel(), type='string', unit='utf8')
# config = Config(APP_SETTINGS)
# cayennemqtt.DataChannel.add(system_data, cayennemqtt.AGENT_VERSION, value=config.get('Agent', 'Version', __version__))
# system_info = SystemInfo()
# capacity_data = system_info.getMemoryInfo((cayennemqtt.CAPACITY,))
# capacity_data += system_info.getDiskInfo((cayennemqtt.CAPACITY,))
# for item in capacity_data:
# system_data.append(item)
# body['properties'] = {}
# body['properties']['pinmap'] = NativeGPIO().MAPPING
# if system_data:
# body['properties']['sysinfo'] = system_data
# except:
# exception('Error getting system info')
# return json.dumps(body)
#
# def authenticate(self, inviteCode):
# body = self.getMessageBody(inviteCode)
# url = '/things/key/authenticate'
# return self.sendRequest('POST', url, body)
#
# def activate(self, inviteCode):
# body = self.getMessageBody(inviteCode)
# url = '/things/key/activate'
# return self.sendRequest('POST', url, body)
#
# def getCredentials(self, content):
# if content is None:
# return None
# body = content.decode("utf-8")
# if body is None or body is "":
# return None
# return json.loads(body)
#
# def loginDevice(self, inviteCode):
# response = self.activate(inviteCode)
# if response and response.status_code == 200:
# return self.getCredentials(response.content)
# return None
#
# def getDataTypes(self):
# url = '/ui/datatypes'
# return self.sendRequest('GET', url)
, which may contain function names, class names, or code. Output only the next line. | self.assertIn('sysinfo', message['properties']) |
Using the snippet: <|code_start|>
class ApiClientTest(unittest.TestCase):
def testMessageBody(self):
cayenneApiClient = CayenneApiClient('https://api.mydevices.com')
message = loads(cayenneApiClient.getMessageBody('invite_code'))
# info(message)
self.assertIn('id', message)
self.assertIn('type', message)
self.assertIn('hardware_id', message)
self.assertIn('properties', message)
<|code_end|>
, determine the next line of code. You have imports:
import unittest
from myDevices.utils.logger import exception, setDebug, info, debug, error, logToFile, setInfo
from myDevices.cloud.apiclient import CayenneApiClient
from json import loads
and context (class names, function names, or code) available:
# Path: myDevices/utils/logger.py
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def setDebug():
# LOGGER.setLevel(DEBUG)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def logToFile(filename=None):
# if not filename:
# filename = '/var/log/myDevices/cayenne.log'
# handler = TimedRotatingFileHandler(filename, when="midnight", interval=1, backupCount=7)
# handler.setFormatter(LOG_FORMATTER)
# handler.rotator=rotator
# handler.namer=namer
# LOGGER.addHandler(handler)
#
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# Path: myDevices/cloud/apiclient.py
# class CayenneApiClient:
# def __init__(self, host):
# self.host = host
# self.auth = None
# self.session = FuturesSession(executor=ThreadPoolExecutor(max_workers=1))
#
# def sendRequest(self, method, uri, body=None):
# if self.session is not None:
# headers = {}
# request_url = self.host + uri
# future = None
# self.session.headers['Content-Type'] = 'application/json'
# self.session.headers['Accept'] = 'application/json'
# if self.auth is not None:
# self.session.headers['Authorization'] = self.auth
# try:
# if method == 'GET':
# future = self.session.get(request_url)
# if method == 'POST':
# future = self.session.post(request_url, data=body)
# if method == 'PUT':
# future = self.session.put(request_url, data=body)
# if method == 'DELETE':
# future = self.session.delete(request_url)
# except Exception as ex:
# error('sendRequest exception: ' + str(ex))
# return None
# try:
# response = future.result()
# except:
# return None
# return response
# exception("No data received")
#
# def getMessageBody(self, inviteCode):
# body = {'id': inviteCode}
# hardware = Hardware()
# if hardware.Serial and hardware.isRaspberryPi():
# body['type'] = 'rpi'
# body['hardware_id'] = hardware.Serial
# else:
# hardware_id = hardware.getMac()
# if hardware_id:
# body['type'] = 'mac'
# body['hardware_id'] = hardware_id
# try:
# system_data = []
# cayennemqtt.DataChannel.add(system_data, cayennemqtt.SYS_HARDWARE_MAKE, value=hardware.getManufacturer(), type='string', unit='utf8')
# cayennemqtt.DataChannel.add(system_data, cayennemqtt.SYS_HARDWARE_MODEL, value=hardware.getModel(), type='string', unit='utf8')
# config = Config(APP_SETTINGS)
# cayennemqtt.DataChannel.add(system_data, cayennemqtt.AGENT_VERSION, value=config.get('Agent', 'Version', __version__))
# system_info = SystemInfo()
# capacity_data = system_info.getMemoryInfo((cayennemqtt.CAPACITY,))
# capacity_data += system_info.getDiskInfo((cayennemqtt.CAPACITY,))
# for item in capacity_data:
# system_data.append(item)
# body['properties'] = {}
# body['properties']['pinmap'] = NativeGPIO().MAPPING
# if system_data:
# body['properties']['sysinfo'] = system_data
# except:
# exception('Error getting system info')
# return json.dumps(body)
#
# def authenticate(self, inviteCode):
# body = self.getMessageBody(inviteCode)
# url = '/things/key/authenticate'
# return self.sendRequest('POST', url, body)
#
# def activate(self, inviteCode):
# body = self.getMessageBody(inviteCode)
# url = '/things/key/activate'
# return self.sendRequest('POST', url, body)
#
# def getCredentials(self, content):
# if content is None:
# return None
# body = content.decode("utf-8")
# if body is None or body is "":
# return None
# return json.loads(body)
#
# def loginDevice(self, inviteCode):
# response = self.activate(inviteCode)
# if response and response.status_code == 200:
# return self.getCredentials(response.content)
# return None
#
# def getDataTypes(self):
# url = '/ui/datatypes'
# return self.sendRequest('GET', url)
. Output only the next line. | self.assertIn('sysinfo', message['properties']) |
Predict the next line after this snippet: <|code_start|> value_dict['value'] = value[0]
value_dict['type'] = value[1]
value_dict['unit'] = value[2]
except:
if not value_dict:
value_dict['value'] = value
if 'type' in value_dict and 'unit' not in value_dict:
if value_dict['type'] in ('digital_sensor', 'digital_actuator'):
value_dict['unit'] = 'd'
elif value_dict['type'] in ('analog_sensor', 'analog_actuator'):
value_dict['unit'] = 'null'
return value_dict
def is_plugin(self, plugin, channel=None):
"""Returns True if the specified plugin or plugin:channel are valid plugins."""
try:
key = plugin
if channel is not None:
key = plugin + ':' + channel
info('Checking for {} in {}'.format(key, self.plugins.keys()))
return key in self.plugins.keys()
except:
return False
def write_value(self, plugin, channel, value):
"""Write a value to a plugin actuator.
Returns: True if value written, False if it was not"""
actuator = plugin + ':' + channel
info('Write value {} to {}'.format(value, actuator))
<|code_end|>
using the current file's imports:
import fnmatch
import importlib
import json
import os
import sys
import myDevices.cloud.cayennemqtt as cayennemqtt
from configparser import NoOptionError
from myDevices.utils.config import Config
from myDevices.utils.logger import debug, error, exception, info
from myDevices.utils.singleton import Singleton
from myDevices.utils.subprocess import executeCommand
and any relevant context from other files:
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# Path: myDevices/utils/singleton.py
# class Singleton(_Singleton('SingletonMeta', (object,), {})): pass
#
# Path: myDevices/utils/subprocess.py
# def executeCommand(command, increaseMemoryLimit=False, disablePipe=False):
# """Execute a specified command, increasing the processes memory limits if specified"""
# debug('executeCommand: ' + command)
# output = ''
# returncode = 1
# try:
# preexec = None
# pipe = PIPE
# if increaseMemoryLimit:
# preexec = setMemoryLimits
# if disablePipe:
# debug('Disable pipe to prevent child exiting when parent exits')
# pipe = DEVNULL
# process = Popen(command, stdout=pipe, stderr=pipe, shell=True, preexec_fn=preexec)
# (stdout_data, stderr_data) = process.communicate()
# returncode = process.wait()
# returncode = process.returncode
# # debug('executeCommand: stdout_data {}, stderr_data {}'.format(stdout_data, stderr_data))
# if stdout_data:
# output = stdout_data.decode('utf-8')
# stdout_data = None
# except:
# exception('executeCommand failed: ' + command)
# return (output, returncode)
. Output only the next line. | if actuator in self.plugins.keys(): |
Using the snippet: <|code_start|> except:
if not value_dict:
value_dict['value'] = value
if 'type' in value_dict and 'unit' not in value_dict:
if value_dict['type'] in ('digital_sensor', 'digital_actuator'):
value_dict['unit'] = 'd'
elif value_dict['type'] in ('analog_sensor', 'analog_actuator'):
value_dict['unit'] = 'null'
return value_dict
def is_plugin(self, plugin, channel=None):
"""Returns True if the specified plugin or plugin:channel are valid plugins."""
try:
key = plugin
if channel is not None:
key = plugin + ':' + channel
info('Checking for {} in {}'.format(key, self.plugins.keys()))
return key in self.plugins.keys()
except:
return False
def write_value(self, plugin, channel, value):
"""Write a value to a plugin actuator.
Returns: True if value written, False if it was not"""
actuator = plugin + ':' + channel
info('Write value {} to {}'.format(value, actuator))
if actuator in self.plugins.keys():
try:
write_function = getattr(self.plugins[actuator]['instance'], self.plugins[actuator]['write'])
<|code_end|>
, determine the next line of code. You have imports:
import fnmatch
import importlib
import json
import os
import sys
import myDevices.cloud.cayennemqtt as cayennemqtt
from configparser import NoOptionError
from myDevices.utils.config import Config
from myDevices.utils.logger import debug, error, exception, info
from myDevices.utils.singleton import Singleton
from myDevices.utils.subprocess import executeCommand
and context (class names, function names, or code) available:
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# Path: myDevices/utils/singleton.py
# class Singleton(_Singleton('SingletonMeta', (object,), {})): pass
#
# Path: myDevices/utils/subprocess.py
# def executeCommand(command, increaseMemoryLimit=False, disablePipe=False):
# """Execute a specified command, increasing the processes memory limits if specified"""
# debug('executeCommand: ' + command)
# output = ''
# returncode = 1
# try:
# preexec = None
# pipe = PIPE
# if increaseMemoryLimit:
# preexec = setMemoryLimits
# if disablePipe:
# debug('Disable pipe to prevent child exiting when parent exits')
# pipe = DEVNULL
# process = Popen(command, stdout=pipe, stderr=pipe, shell=True, preexec_fn=preexec)
# (stdout_data, stderr_data) = process.communicate()
# returncode = process.wait()
# returncode = process.returncode
# # debug('executeCommand: stdout_data {}, stderr_data {}'.format(stdout_data, stderr_data))
# if stdout_data:
# output = stdout_data.decode('utf-8')
# stdout_data = None
# except:
# exception('executeCommand failed: ' + command)
# return (output, returncode)
. Output only the next line. | write_args = self.get_args(self.plugins[actuator], 'write_args') |
Given the code snippet: <|code_start|> if value_dict['type'] in ('digital_sensor', 'digital_actuator'):
value_dict['unit'] = 'd'
elif value_dict['type'] in ('analog_sensor', 'analog_actuator'):
value_dict['unit'] = 'null'
return value_dict
def is_plugin(self, plugin, channel=None):
"""Returns True if the specified plugin or plugin:channel are valid plugins."""
try:
key = plugin
if channel is not None:
key = plugin + ':' + channel
info('Checking for {} in {}'.format(key, self.plugins.keys()))
return key in self.plugins.keys()
except:
return False
def write_value(self, plugin, channel, value):
"""Write a value to a plugin actuator.
Returns: True if value written, False if it was not"""
actuator = plugin + ':' + channel
info('Write value {} to {}'.format(value, actuator))
if actuator in self.plugins.keys():
try:
write_function = getattr(self.plugins[actuator]['instance'], self.plugins[actuator]['write'])
write_args = self.get_args(self.plugins[actuator], 'write_args')
write_function(float(value), **write_args)
except KeyError as e:
error('Error writing value, missing key: {}'.format(e))
<|code_end|>
, generate the next line using the imports in this file:
import fnmatch
import importlib
import json
import os
import sys
import myDevices.cloud.cayennemqtt as cayennemqtt
from configparser import NoOptionError
from myDevices.utils.config import Config
from myDevices.utils.logger import debug, error, exception, info
from myDevices.utils.singleton import Singleton
from myDevices.utils.subprocess import executeCommand
and context (functions, classes, or occasionally code) from other files:
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# Path: myDevices/utils/singleton.py
# class Singleton(_Singleton('SingletonMeta', (object,), {})): pass
#
# Path: myDevices/utils/subprocess.py
# def executeCommand(command, increaseMemoryLimit=False, disablePipe=False):
# """Execute a specified command, increasing the processes memory limits if specified"""
# debug('executeCommand: ' + command)
# output = ''
# returncode = 1
# try:
# preexec = None
# pipe = PIPE
# if increaseMemoryLimit:
# preexec = setMemoryLimits
# if disablePipe:
# debug('Disable pipe to prevent child exiting when parent exits')
# pipe = DEVNULL
# process = Popen(command, stdout=pipe, stderr=pipe, shell=True, preexec_fn=preexec)
# (stdout_data, stderr_data) = process.communicate()
# returncode = process.wait()
# returncode = process.returncode
# # debug('executeCommand: stdout_data {}, stderr_data {}'.format(stdout_data, stderr_data))
# if stdout_data:
# output = stdout_data.decode('utf-8')
# stdout_data = None
# except:
# exception('executeCommand failed: ' + command)
# return (output, returncode)
. Output only the next line. | return False |
Predict the next line for this snippet: <|code_start|> return value_dict
def is_plugin(self, plugin, channel=None):
"""Returns True if the specified plugin or plugin:channel are valid plugins."""
try:
key = plugin
if channel is not None:
key = plugin + ':' + channel
info('Checking for {} in {}'.format(key, self.plugins.keys()))
return key in self.plugins.keys()
except:
return False
def write_value(self, plugin, channel, value):
"""Write a value to a plugin actuator.
Returns: True if value written, False if it was not"""
actuator = plugin + ':' + channel
info('Write value {} to {}'.format(value, actuator))
if actuator in self.plugins.keys():
try:
write_function = getattr(self.plugins[actuator]['instance'], self.plugins[actuator]['write'])
write_args = self.get_args(self.plugins[actuator], 'write_args')
write_function(float(value), **write_args)
except KeyError as e:
error('Error writing value, missing key: {}'.format(e))
return False
except Exception as e:
error('Error writing value: {}'.format(e))
return False
<|code_end|>
with the help of current file imports:
import fnmatch
import importlib
import json
import os
import sys
import myDevices.cloud.cayennemqtt as cayennemqtt
from configparser import NoOptionError
from myDevices.utils.config import Config
from myDevices.utils.logger import debug, error, exception, info
from myDevices.utils.singleton import Singleton
from myDevices.utils.subprocess import executeCommand
and context from other files:
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# Path: myDevices/utils/singleton.py
# class Singleton(_Singleton('SingletonMeta', (object,), {})): pass
#
# Path: myDevices/utils/subprocess.py
# def executeCommand(command, increaseMemoryLimit=False, disablePipe=False):
# """Execute a specified command, increasing the processes memory limits if specified"""
# debug('executeCommand: ' + command)
# output = ''
# returncode = 1
# try:
# preexec = None
# pipe = PIPE
# if increaseMemoryLimit:
# preexec = setMemoryLimits
# if disablePipe:
# debug('Disable pipe to prevent child exiting when parent exits')
# pipe = DEVNULL
# process = Popen(command, stdout=pipe, stderr=pipe, shell=True, preexec_fn=preexec)
# (stdout_data, stderr_data) = process.communicate()
# returncode = process.wait()
# returncode = process.returncode
# # debug('executeCommand: stdout_data {}, stderr_data {}'.format(stdout_data, stderr_data))
# if stdout_data:
# output = stdout_data.decode('utf-8')
# stdout_data = None
# except:
# exception('executeCommand failed: ' + command)
# return (output, returncode)
, which may contain function names, class names, or code. Output only the next line. | else: |
Based on the snippet: <|code_start|> value_dict['unit'] = 'd'
elif value_dict['type'] in ('analog_sensor', 'analog_actuator'):
value_dict['unit'] = 'null'
return value_dict
def is_plugin(self, plugin, channel=None):
"""Returns True if the specified plugin or plugin:channel are valid plugins."""
try:
key = plugin
if channel is not None:
key = plugin + ':' + channel
info('Checking for {} in {}'.format(key, self.plugins.keys()))
return key in self.plugins.keys()
except:
return False
def write_value(self, plugin, channel, value):
"""Write a value to a plugin actuator.
Returns: True if value written, False if it was not"""
actuator = plugin + ':' + channel
info('Write value {} to {}'.format(value, actuator))
if actuator in self.plugins.keys():
try:
write_function = getattr(self.plugins[actuator]['instance'], self.plugins[actuator]['write'])
write_args = self.get_args(self.plugins[actuator], 'write_args')
write_function(float(value), **write_args)
except KeyError as e:
error('Error writing value, missing key: {}'.format(e))
return False
<|code_end|>
, predict the immediate next line with the help of imports:
import fnmatch
import importlib
import json
import os
import sys
import myDevices.cloud.cayennemqtt as cayennemqtt
from configparser import NoOptionError
from myDevices.utils.config import Config
from myDevices.utils.logger import debug, error, exception, info
from myDevices.utils.singleton import Singleton
from myDevices.utils.subprocess import executeCommand
and context (classes, functions, sometimes code) from other files:
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# Path: myDevices/utils/singleton.py
# class Singleton(_Singleton('SingletonMeta', (object,), {})): pass
#
# Path: myDevices/utils/subprocess.py
# def executeCommand(command, increaseMemoryLimit=False, disablePipe=False):
# """Execute a specified command, increasing the processes memory limits if specified"""
# debug('executeCommand: ' + command)
# output = ''
# returncode = 1
# try:
# preexec = None
# pipe = PIPE
# if increaseMemoryLimit:
# preexec = setMemoryLimits
# if disablePipe:
# debug('Disable pipe to prevent child exiting when parent exits')
# pipe = DEVNULL
# process = Popen(command, stdout=pipe, stderr=pipe, shell=True, preexec_fn=preexec)
# (stdout_data, stderr_data) = process.communicate()
# returncode = process.wait()
# returncode = process.returncode
# # debug('executeCommand: stdout_data {}, stderr_data {}'.format(stdout_data, stderr_data))
# if stdout_data:
# output = stdout_data.decode('utf-8')
# stdout_data = None
# except:
# exception('executeCommand failed: ' + command)
# return (output, returncode)
. Output only the next line. | except Exception as e: |
Given the following code snippet before the placeholder: <|code_start|> value_dict['value'] = value
if 'type' in value_dict and 'unit' not in value_dict:
if value_dict['type'] in ('digital_sensor', 'digital_actuator'):
value_dict['unit'] = 'd'
elif value_dict['type'] in ('analog_sensor', 'analog_actuator'):
value_dict['unit'] = 'null'
return value_dict
def is_plugin(self, plugin, channel=None):
"""Returns True if the specified plugin or plugin:channel are valid plugins."""
try:
key = plugin
if channel is not None:
key = plugin + ':' + channel
info('Checking for {} in {}'.format(key, self.plugins.keys()))
return key in self.plugins.keys()
except:
return False
def write_value(self, plugin, channel, value):
"""Write a value to a plugin actuator.
Returns: True if value written, False if it was not"""
actuator = plugin + ':' + channel
info('Write value {} to {}'.format(value, actuator))
if actuator in self.plugins.keys():
try:
write_function = getattr(self.plugins[actuator]['instance'], self.plugins[actuator]['write'])
write_args = self.get_args(self.plugins[actuator], 'write_args')
write_function(float(value), **write_args)
<|code_end|>
, predict the next line using imports from the current file:
import fnmatch
import importlib
import json
import os
import sys
import myDevices.cloud.cayennemqtt as cayennemqtt
from configparser import NoOptionError
from myDevices.utils.config import Config
from myDevices.utils.logger import debug, error, exception, info
from myDevices.utils.singleton import Singleton
from myDevices.utils.subprocess import executeCommand
and context including class names, function names, and sometimes code from other files:
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# Path: myDevices/utils/singleton.py
# class Singleton(_Singleton('SingletonMeta', (object,), {})): pass
#
# Path: myDevices/utils/subprocess.py
# def executeCommand(command, increaseMemoryLimit=False, disablePipe=False):
# """Execute a specified command, increasing the processes memory limits if specified"""
# debug('executeCommand: ' + command)
# output = ''
# returncode = 1
# try:
# preexec = None
# pipe = PIPE
# if increaseMemoryLimit:
# preexec = setMemoryLimits
# if disablePipe:
# debug('Disable pipe to prevent child exiting when parent exits')
# pipe = DEVNULL
# process = Popen(command, stdout=pipe, stderr=pipe, shell=True, preexec_fn=preexec)
# (stdout_data, stderr_data) = process.communicate()
# returncode = process.wait()
# returncode = process.returncode
# # debug('executeCommand: stdout_data {}, stderr_data {}'.format(stdout_data, stderr_data))
# if stdout_data:
# output = stdout_data.decode('utf-8')
# stdout_data = None
# except:
# exception('executeCommand failed: ' + command)
# return (output, returncode)
. Output only the next line. | except KeyError as e: |
Using the snippet: <|code_start|> if value_dict['type'] in ('digital_sensor', 'digital_actuator'):
value_dict['unit'] = 'd'
elif value_dict['type'] in ('analog_sensor', 'analog_actuator'):
value_dict['unit'] = 'null'
return value_dict
def is_plugin(self, plugin, channel=None):
"""Returns True if the specified plugin or plugin:channel are valid plugins."""
try:
key = plugin
if channel is not None:
key = plugin + ':' + channel
info('Checking for {} in {}'.format(key, self.plugins.keys()))
return key in self.plugins.keys()
except:
return False
def write_value(self, plugin, channel, value):
"""Write a value to a plugin actuator.
Returns: True if value written, False if it was not"""
actuator = plugin + ':' + channel
info('Write value {} to {}'.format(value, actuator))
if actuator in self.plugins.keys():
try:
write_function = getattr(self.plugins[actuator]['instance'], self.plugins[actuator]['write'])
write_args = self.get_args(self.plugins[actuator], 'write_args')
write_function(float(value), **write_args)
except KeyError as e:
error('Error writing value, missing key: {}'.format(e))
<|code_end|>
, determine the next line of code. You have imports:
import fnmatch
import importlib
import json
import os
import sys
import myDevices.cloud.cayennemqtt as cayennemqtt
from configparser import NoOptionError
from myDevices.utils.config import Config
from myDevices.utils.logger import debug, error, exception, info
from myDevices.utils.singleton import Singleton
from myDevices.utils.subprocess import executeCommand
and context (class names, function names, or code) available:
# Path: myDevices/utils/config.py
# class Config:
# def __init__(self, path):
# self.mutex = RLock()
# self.path = path
# self.config = RawConfigParser()
# self.config.optionxform = str
# try:
# with open(path) as fp:
# self.config.read_file(fp)
# except:
# pass
#
# def set(self, section, key, value):
# with self.mutex:
# try:
# self.config.set(section, key, value)
# except NoSectionError:
# self.config.add_section(section)
# self.config.set(section, key, value)
# self.save()
#
# def get(self, section, key, fallback=_UNSET):
# return self.config.get(section, key, fallback=fallback)
#
# def getInt(self, section, key, fallback=_UNSET):
# return self.config.getint(section, key, fallback=fallback)
#
# def remove(self, section, key):
# with self.mutex:
# result = self.config.remove_option(section, key)
# self.save()
#
# def save(self):
# with self.mutex:
# with open(self.path, 'w') as configfile:
# self.config.write(configfile)
#
# def sections(self):
# return self.config.sections()
#
# Path: myDevices/utils/logger.py
# def debug(message):
# outerFrame = getouterframes(currentframe())[1][0]
# (args, _, _, values) = getargvalues(outerFrame)
# argsValue = ''
#
# for i in args:
# if i is 'self':
# continue
# argsValue += "(%s=%s)" % (i, str(values[i]))
#
# stack = extract_stack()
# (filename, line, procname, text) = stack[-2]
# LOGGER.debug(str(filename) + ' ' + str(procname) + str(argsValue) + ':' + str(line) + '> ' + str(message))
#
# def error(message, *args, **kwargs):
# if checkFlood(message):
# return
# LOGGER.error(message, *args, **kwargs)
#
# def exception(message):
# if checkFlood(message):
# return
# LOGGER.exception(message)
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# Path: myDevices/utils/singleton.py
# class Singleton(_Singleton('SingletonMeta', (object,), {})): pass
#
# Path: myDevices/utils/subprocess.py
# def executeCommand(command, increaseMemoryLimit=False, disablePipe=False):
# """Execute a specified command, increasing the processes memory limits if specified"""
# debug('executeCommand: ' + command)
# output = ''
# returncode = 1
# try:
# preexec = None
# pipe = PIPE
# if increaseMemoryLimit:
# preexec = setMemoryLimits
# if disablePipe:
# debug('Disable pipe to prevent child exiting when parent exits')
# pipe = DEVNULL
# process = Popen(command, stdout=pipe, stderr=pipe, shell=True, preexec_fn=preexec)
# (stdout_data, stderr_data) = process.communicate()
# returncode = process.wait()
# returncode = process.returncode
# # debug('executeCommand: stdout_data {}, stderr_data {}'.format(stdout_data, stderr_data))
# if stdout_data:
# output = stdout_data.decode('utf-8')
# stdout_data = None
# except:
# exception('executeCommand failed: ' + command)
# return (output, returncode)
. Output only the next line. | return False |
Predict the next line after this snippet: <|code_start|>
class HarwareTest(unittest.TestCase):
def setUp(self):
setInfo()
self.hardware = Hardware()
def testGetManufacturer(self):
manufacturer = self.hardware.getManufacturer()
info(manufacturer)
self.assertNotEqual(manufacturer, '')
def testGetModel(self):
model = self.hardware.getModel()
info(model)
<|code_end|>
using the current file's imports:
import unittest
from myDevices.utils.logger import setInfo, info
from myDevices.system.hardware import Hardware, BOARD_REVISION, CPU_REVISION, CPU_HARDWARE
and any relevant context from other files:
# Path: myDevices/utils/logger.py
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# Path: myDevices/system/hardware.py
# class Hardware:
# """Class for getting hardware info, including manufacturer, model and MAC address."""
#
# def __init__(self):
# """Initialize board revision and model info"""
# self.Revision = '0'
# self.Serial = None
# try:
# with open('/proc/cpuinfo','r') as f:
# for line in f:
# splitLine = line.split(':')
# if len(splitLine) < 2:
# continue
# key = splitLine[0].strip()
# value = splitLine[1].strip()
# if key == 'Revision':
# self.Revision = value
# if key == 'Serial' and value != len(value) * '0':
# self.Serial = value
# except:
# exception ("Error reading cpuinfo")
# self.model = 'Unknown'
# if self.Revision == 'Beta':
# self.model = 'Raspberry Pi Model B (Beta)'
# if self.Revision in ('000d', '000e', '000f', '0002', '0003', '0004', '0005', '0006'):
# self.model = 'Raspberry Pi Model B'
# if self.Revision in ('0007', '0008', '0009'):
# self.model = 'Raspberry Pi Model A'
# if self.Revision in ('0010', '0013', '900032'):
# self.model = 'Raspberry Pi Model B +'
# if self.Revision in ('0011', '0014'):
# self.model = 'Raspberry Pi Compute Module'
# if self.Revision in ('0012', '0015'):
# self.model = 'Raspberry Pi Model A+'
# if self.Revision in ('a01040', 'a01041', 'a21041', 'a22042'):
# self.model = 'Raspberry Pi 2 Model B'
# if self.Revision in ('900092', '900093', '920093'):
# self.model = 'Raspberry Pi Zero'
# if self.Revision in ('9000c1',):
# self.model = 'Raspberry Pi Zero W'
# if self.Revision in ('a02082', 'a22082', 'a32082'):
# self.model = 'Raspberry Pi 3 Model B'
# if self.Revision in ('a020d3'):
# self.model = 'Raspberry Pi 3 Model B+'
# if self.Revision in ('a020a0'):
# self.model = 'Raspberry Pi Compute Module 3'
# if 'Rockchip' in CPU_HARDWARE:
# self.model = 'Tinker Board'
# self.manufacturer = 'Element14/Premier Farnell'
# if self.Revision in ('a01041', '900092', 'a02082', '0012', '0011', '0010', '000e', '0008', '0004', 'a020d3', 'a01040', 'a020a0'):
# self.manufacturer = 'Sony, UK'
# if self.Revision in ('a32082'):
# self.manufacturer = 'Sony, Japan'
# if self.Revision in ('0014', '0015', 'a21041', 'a22082', '920093'):
# self.manufacturer = 'Embest, China'
# if self.Revision in ('0005', '0009', '000f'):
# self.manufacturer = 'Qisda'
# if self.Revision in ('0006', '0007', '000d'):
# self.manufacturer = 'Egoman'
# if self.Revision == '0000':
# if 'Rockchip' in CPU_HARDWARE:
# self.manufacturer = 'ASUS'
# else:
# try:
# with open('/proc/device-tree/model', 'r') as model_file:
# for line in model_file:
# if 'BeagleBone' in line:
# index = line.index('BeagleBone')
# self.manufacturer = line[:index - 1].strip(' \n\t\0')
# self.model = line[index:].strip(' \n\t\0')
# break
# except:
# exception ("Error reading model")
#
#
# def getManufacturer(self):
# """Return manufacturer name as string"""
# return self.manufacturer
#
# def getModel(self):
# """Return model name as string"""
# return self.model
#
# def getMac(self):
# """Return MAC address as a string or None if no MAC address is found"""
# # Import netifaces here to prevent error importing this module in setup.py
# import netifaces
# interfaces = ['eth0', 'wlan0']
# try:
# interfaces.append(netifaces.gateways()['default'][netifaces.AF_INET][1])
# except:
# pass
# for interface in interfaces:
# try:
# return netifaces.ifaddresses(interface)[netifaces.AF_LINK][0]['addr']
# except ValueError:
# pass
# except:
# exception('Error getting MAC address')
# return None
#
# def isRaspberryPi(self):
# """Return True if device is a Raspberry Pi"""
# return 'Raspberry Pi' in self.model
#
# def isRaspberryPi3(self):
# """Return True if device is a Raspberry Pi 3"""
# return 'Raspberry Pi 3' in self.model
#
# def isTinkerBoard(self):
# """Return True if device is a Tinker Board"""
# return 'Tinker Board' == self.model
#
# def isBeagleBone(self):
# """Return True if device is a BeagleBone"""
# return 'BeagleBone' in self.model
#
# BOARD_REVISION = 0
#
# CPU_REVISION = "0"
#
# CPU_HARDWARE = ""
. Output only the next line. | self.assertNotEqual(model, 'Unknown') |
Given the code snippet: <|code_start|>
class HarwareTest(unittest.TestCase):
def setUp(self):
setInfo()
self.hardware = Hardware()
def testGetManufacturer(self):
manufacturer = self.hardware.getManufacturer()
info(manufacturer)
self.assertNotEqual(manufacturer, '')
def testGetModel(self):
model = self.hardware.getModel()
info(model)
self.assertNotEqual(model, 'Unknown')
def testGetMac(self):
<|code_end|>
, generate the next line using the imports in this file:
import unittest
from myDevices.utils.logger import setInfo, info
from myDevices.system.hardware import Hardware, BOARD_REVISION, CPU_REVISION, CPU_HARDWARE
and context (functions, classes, or occasionally code) from other files:
# Path: myDevices/utils/logger.py
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# Path: myDevices/system/hardware.py
# class Hardware:
# """Class for getting hardware info, including manufacturer, model and MAC address."""
#
# def __init__(self):
# """Initialize board revision and model info"""
# self.Revision = '0'
# self.Serial = None
# try:
# with open('/proc/cpuinfo','r') as f:
# for line in f:
# splitLine = line.split(':')
# if len(splitLine) < 2:
# continue
# key = splitLine[0].strip()
# value = splitLine[1].strip()
# if key == 'Revision':
# self.Revision = value
# if key == 'Serial' and value != len(value) * '0':
# self.Serial = value
# except:
# exception ("Error reading cpuinfo")
# self.model = 'Unknown'
# if self.Revision == 'Beta':
# self.model = 'Raspberry Pi Model B (Beta)'
# if self.Revision in ('000d', '000e', '000f', '0002', '0003', '0004', '0005', '0006'):
# self.model = 'Raspberry Pi Model B'
# if self.Revision in ('0007', '0008', '0009'):
# self.model = 'Raspberry Pi Model A'
# if self.Revision in ('0010', '0013', '900032'):
# self.model = 'Raspberry Pi Model B +'
# if self.Revision in ('0011', '0014'):
# self.model = 'Raspberry Pi Compute Module'
# if self.Revision in ('0012', '0015'):
# self.model = 'Raspberry Pi Model A+'
# if self.Revision in ('a01040', 'a01041', 'a21041', 'a22042'):
# self.model = 'Raspberry Pi 2 Model B'
# if self.Revision in ('900092', '900093', '920093'):
# self.model = 'Raspberry Pi Zero'
# if self.Revision in ('9000c1',):
# self.model = 'Raspberry Pi Zero W'
# if self.Revision in ('a02082', 'a22082', 'a32082'):
# self.model = 'Raspberry Pi 3 Model B'
# if self.Revision in ('a020d3'):
# self.model = 'Raspberry Pi 3 Model B+'
# if self.Revision in ('a020a0'):
# self.model = 'Raspberry Pi Compute Module 3'
# if 'Rockchip' in CPU_HARDWARE:
# self.model = 'Tinker Board'
# self.manufacturer = 'Element14/Premier Farnell'
# if self.Revision in ('a01041', '900092', 'a02082', '0012', '0011', '0010', '000e', '0008', '0004', 'a020d3', 'a01040', 'a020a0'):
# self.manufacturer = 'Sony, UK'
# if self.Revision in ('a32082'):
# self.manufacturer = 'Sony, Japan'
# if self.Revision in ('0014', '0015', 'a21041', 'a22082', '920093'):
# self.manufacturer = 'Embest, China'
# if self.Revision in ('0005', '0009', '000f'):
# self.manufacturer = 'Qisda'
# if self.Revision in ('0006', '0007', '000d'):
# self.manufacturer = 'Egoman'
# if self.Revision == '0000':
# if 'Rockchip' in CPU_HARDWARE:
# self.manufacturer = 'ASUS'
# else:
# try:
# with open('/proc/device-tree/model', 'r') as model_file:
# for line in model_file:
# if 'BeagleBone' in line:
# index = line.index('BeagleBone')
# self.manufacturer = line[:index - 1].strip(' \n\t\0')
# self.model = line[index:].strip(' \n\t\0')
# break
# except:
# exception ("Error reading model")
#
#
# def getManufacturer(self):
# """Return manufacturer name as string"""
# return self.manufacturer
#
# def getModel(self):
# """Return model name as string"""
# return self.model
#
# def getMac(self):
# """Return MAC address as a string or None if no MAC address is found"""
# # Import netifaces here to prevent error importing this module in setup.py
# import netifaces
# interfaces = ['eth0', 'wlan0']
# try:
# interfaces.append(netifaces.gateways()['default'][netifaces.AF_INET][1])
# except:
# pass
# for interface in interfaces:
# try:
# return netifaces.ifaddresses(interface)[netifaces.AF_LINK][0]['addr']
# except ValueError:
# pass
# except:
# exception('Error getting MAC address')
# return None
#
# def isRaspberryPi(self):
# """Return True if device is a Raspberry Pi"""
# return 'Raspberry Pi' in self.model
#
# def isRaspberryPi3(self):
# """Return True if device is a Raspberry Pi 3"""
# return 'Raspberry Pi 3' in self.model
#
# def isTinkerBoard(self):
# """Return True if device is a Tinker Board"""
# return 'Tinker Board' == self.model
#
# def isBeagleBone(self):
# """Return True if device is a BeagleBone"""
# return 'BeagleBone' in self.model
#
# BOARD_REVISION = 0
#
# CPU_REVISION = "0"
#
# CPU_HARDWARE = ""
. Output only the next line. | mac = self.hardware.getMac() |
Here is a snippet: <|code_start|>
class HarwareTest(unittest.TestCase):
def setUp(self):
setInfo()
self.hardware = Hardware()
def testGetManufacturer(self):
<|code_end|>
. Write the next line using the current file imports:
import unittest
from myDevices.utils.logger import setInfo, info
from myDevices.system.hardware import Hardware, BOARD_REVISION, CPU_REVISION, CPU_HARDWARE
and context from other files:
# Path: myDevices/utils/logger.py
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# Path: myDevices/system/hardware.py
# class Hardware:
# """Class for getting hardware info, including manufacturer, model and MAC address."""
#
# def __init__(self):
# """Initialize board revision and model info"""
# self.Revision = '0'
# self.Serial = None
# try:
# with open('/proc/cpuinfo','r') as f:
# for line in f:
# splitLine = line.split(':')
# if len(splitLine) < 2:
# continue
# key = splitLine[0].strip()
# value = splitLine[1].strip()
# if key == 'Revision':
# self.Revision = value
# if key == 'Serial' and value != len(value) * '0':
# self.Serial = value
# except:
# exception ("Error reading cpuinfo")
# self.model = 'Unknown'
# if self.Revision == 'Beta':
# self.model = 'Raspberry Pi Model B (Beta)'
# if self.Revision in ('000d', '000e', '000f', '0002', '0003', '0004', '0005', '0006'):
# self.model = 'Raspberry Pi Model B'
# if self.Revision in ('0007', '0008', '0009'):
# self.model = 'Raspberry Pi Model A'
# if self.Revision in ('0010', '0013', '900032'):
# self.model = 'Raspberry Pi Model B +'
# if self.Revision in ('0011', '0014'):
# self.model = 'Raspberry Pi Compute Module'
# if self.Revision in ('0012', '0015'):
# self.model = 'Raspberry Pi Model A+'
# if self.Revision in ('a01040', 'a01041', 'a21041', 'a22042'):
# self.model = 'Raspberry Pi 2 Model B'
# if self.Revision in ('900092', '900093', '920093'):
# self.model = 'Raspberry Pi Zero'
# if self.Revision in ('9000c1',):
# self.model = 'Raspberry Pi Zero W'
# if self.Revision in ('a02082', 'a22082', 'a32082'):
# self.model = 'Raspberry Pi 3 Model B'
# if self.Revision in ('a020d3'):
# self.model = 'Raspberry Pi 3 Model B+'
# if self.Revision in ('a020a0'):
# self.model = 'Raspberry Pi Compute Module 3'
# if 'Rockchip' in CPU_HARDWARE:
# self.model = 'Tinker Board'
# self.manufacturer = 'Element14/Premier Farnell'
# if self.Revision in ('a01041', '900092', 'a02082', '0012', '0011', '0010', '000e', '0008', '0004', 'a020d3', 'a01040', 'a020a0'):
# self.manufacturer = 'Sony, UK'
# if self.Revision in ('a32082'):
# self.manufacturer = 'Sony, Japan'
# if self.Revision in ('0014', '0015', 'a21041', 'a22082', '920093'):
# self.manufacturer = 'Embest, China'
# if self.Revision in ('0005', '0009', '000f'):
# self.manufacturer = 'Qisda'
# if self.Revision in ('0006', '0007', '000d'):
# self.manufacturer = 'Egoman'
# if self.Revision == '0000':
# if 'Rockchip' in CPU_HARDWARE:
# self.manufacturer = 'ASUS'
# else:
# try:
# with open('/proc/device-tree/model', 'r') as model_file:
# for line in model_file:
# if 'BeagleBone' in line:
# index = line.index('BeagleBone')
# self.manufacturer = line[:index - 1].strip(' \n\t\0')
# self.model = line[index:].strip(' \n\t\0')
# break
# except:
# exception ("Error reading model")
#
#
# def getManufacturer(self):
# """Return manufacturer name as string"""
# return self.manufacturer
#
# def getModel(self):
# """Return model name as string"""
# return self.model
#
# def getMac(self):
# """Return MAC address as a string or None if no MAC address is found"""
# # Import netifaces here to prevent error importing this module in setup.py
# import netifaces
# interfaces = ['eth0', 'wlan0']
# try:
# interfaces.append(netifaces.gateways()['default'][netifaces.AF_INET][1])
# except:
# pass
# for interface in interfaces:
# try:
# return netifaces.ifaddresses(interface)[netifaces.AF_LINK][0]['addr']
# except ValueError:
# pass
# except:
# exception('Error getting MAC address')
# return None
#
# def isRaspberryPi(self):
# """Return True if device is a Raspberry Pi"""
# return 'Raspberry Pi' in self.model
#
# def isRaspberryPi3(self):
# """Return True if device is a Raspberry Pi 3"""
# return 'Raspberry Pi 3' in self.model
#
# def isTinkerBoard(self):
# """Return True if device is a Tinker Board"""
# return 'Tinker Board' == self.model
#
# def isBeagleBone(self):
# """Return True if device is a BeagleBone"""
# return 'BeagleBone' in self.model
#
# BOARD_REVISION = 0
#
# CPU_REVISION = "0"
#
# CPU_HARDWARE = ""
, which may include functions, classes, or code. Output only the next line. | manufacturer = self.hardware.getManufacturer() |
Given the following code snippet before the placeholder: <|code_start|>
class HarwareTest(unittest.TestCase):
def setUp(self):
setInfo()
self.hardware = Hardware()
def testGetManufacturer(self):
manufacturer = self.hardware.getManufacturer()
info(manufacturer)
self.assertNotEqual(manufacturer, '')
def testGetModel(self):
model = self.hardware.getModel()
info(model)
self.assertNotEqual(model, 'Unknown')
<|code_end|>
, predict the next line using imports from the current file:
import unittest
from myDevices.utils.logger import setInfo, info
from myDevices.system.hardware import Hardware, BOARD_REVISION, CPU_REVISION, CPU_HARDWARE
and context including class names, function names, and sometimes code from other files:
# Path: myDevices/utils/logger.py
# def setInfo():
# LOGGER.setLevel(INFO)
# return
#
# def info(message):
# # if checkFlood(message):
# # return
# LOGGER.info(message)
#
# Path: myDevices/system/hardware.py
# class Hardware:
# """Class for getting hardware info, including manufacturer, model and MAC address."""
#
# def __init__(self):
# """Initialize board revision and model info"""
# self.Revision = '0'
# self.Serial = None
# try:
# with open('/proc/cpuinfo','r') as f:
# for line in f:
# splitLine = line.split(':')
# if len(splitLine) < 2:
# continue
# key = splitLine[0].strip()
# value = splitLine[1].strip()
# if key == 'Revision':
# self.Revision = value
# if key == 'Serial' and value != len(value) * '0':
# self.Serial = value
# except:
# exception ("Error reading cpuinfo")
# self.model = 'Unknown'
# if self.Revision == 'Beta':
# self.model = 'Raspberry Pi Model B (Beta)'
# if self.Revision in ('000d', '000e', '000f', '0002', '0003', '0004', '0005', '0006'):
# self.model = 'Raspberry Pi Model B'
# if self.Revision in ('0007', '0008', '0009'):
# self.model = 'Raspberry Pi Model A'
# if self.Revision in ('0010', '0013', '900032'):
# self.model = 'Raspberry Pi Model B +'
# if self.Revision in ('0011', '0014'):
# self.model = 'Raspberry Pi Compute Module'
# if self.Revision in ('0012', '0015'):
# self.model = 'Raspberry Pi Model A+'
# if self.Revision in ('a01040', 'a01041', 'a21041', 'a22042'):
# self.model = 'Raspberry Pi 2 Model B'
# if self.Revision in ('900092', '900093', '920093'):
# self.model = 'Raspberry Pi Zero'
# if self.Revision in ('9000c1',):
# self.model = 'Raspberry Pi Zero W'
# if self.Revision in ('a02082', 'a22082', 'a32082'):
# self.model = 'Raspberry Pi 3 Model B'
# if self.Revision in ('a020d3'):
# self.model = 'Raspberry Pi 3 Model B+'
# if self.Revision in ('a020a0'):
# self.model = 'Raspberry Pi Compute Module 3'
# if 'Rockchip' in CPU_HARDWARE:
# self.model = 'Tinker Board'
# self.manufacturer = 'Element14/Premier Farnell'
# if self.Revision in ('a01041', '900092', 'a02082', '0012', '0011', '0010', '000e', '0008', '0004', 'a020d3', 'a01040', 'a020a0'):
# self.manufacturer = 'Sony, UK'
# if self.Revision in ('a32082'):
# self.manufacturer = 'Sony, Japan'
# if self.Revision in ('0014', '0015', 'a21041', 'a22082', '920093'):
# self.manufacturer = 'Embest, China'
# if self.Revision in ('0005', '0009', '000f'):
# self.manufacturer = 'Qisda'
# if self.Revision in ('0006', '0007', '000d'):
# self.manufacturer = 'Egoman'
# if self.Revision == '0000':
# if 'Rockchip' in CPU_HARDWARE:
# self.manufacturer = 'ASUS'
# else:
# try:
# with open('/proc/device-tree/model', 'r') as model_file:
# for line in model_file:
# if 'BeagleBone' in line:
# index = line.index('BeagleBone')
# self.manufacturer = line[:index - 1].strip(' \n\t\0')
# self.model = line[index:].strip(' \n\t\0')
# break
# except:
# exception ("Error reading model")
#
#
# def getManufacturer(self):
# """Return manufacturer name as string"""
# return self.manufacturer
#
# def getModel(self):
# """Return model name as string"""
# return self.model
#
# def getMac(self):
# """Return MAC address as a string or None if no MAC address is found"""
# # Import netifaces here to prevent error importing this module in setup.py
# import netifaces
# interfaces = ['eth0', 'wlan0']
# try:
# interfaces.append(netifaces.gateways()['default'][netifaces.AF_INET][1])
# except:
# pass
# for interface in interfaces:
# try:
# return netifaces.ifaddresses(interface)[netifaces.AF_LINK][0]['addr']
# except ValueError:
# pass
# except:
# exception('Error getting MAC address')
# return None
#
# def isRaspberryPi(self):
# """Return True if device is a Raspberry Pi"""
# return 'Raspberry Pi' in self.model
#
# def isRaspberryPi3(self):
# """Return True if device is a Raspberry Pi 3"""
# return 'Raspberry Pi 3' in self.model
#
# def isTinkerBoard(self):
# """Return True if device is a Tinker Board"""
# return 'Tinker Board' == self.model
#
# def isBeagleBone(self):
# """Return True if device is a BeagleBone"""
# return 'BeagleBone' in self.model
#
# BOARD_REVISION = 0
#
# CPU_REVISION = "0"
#
# CPU_HARDWARE = ""
. Output only the next line. | def testGetMac(self): |
Predict the next line for this snippet: <|code_start|>
def __init__(self, network: str) -> None:
"""
: network = peercoin [ppc], peercoin-testnet [tppc] ...
"""
self.net = self._netname(network)['short']
self.api_url = self.api_url_fmt.format(net=self.format_name(self.net))
if 'ppc' in self.net:
getcontext().prec = 6 # set to six decimals if it's Peercoin
@staticmethod
def format_name(net: str) -> str:
'''take care of specifics of cryptoid naming system'''
if net.startswith('t') or 'testnet' in net:
net = net[1:] + '-test'
else:
net = net
return net
@staticmethod
def get_url(url: str) -> Union[dict, int, float, str]:
'''Perform a GET request for the url and return a dictionary parsed from
the JSON response.'''
request = Request(url, headers={"User-Agent": "pypeerassets"})
response = cast(HTTPResponse, urlopen(request))
if response.status != 200:
<|code_end|>
with the help of current file imports:
from decimal import Decimal, getcontext
from http.client import HTTPResponse
from operator import itemgetter
from typing import Union, cast
from urllib.request import Request, urlopen
from btcpy.structs.transaction import TxIn, Sequence, ScriptSig
from pypeerassets.exceptions import InsufficientFunds
from pypeerassets.provider.common import Provider
import json
and context from other files:
# Path: pypeerassets/exceptions.py
# class InsufficientFunds(Exception):
# '''this address does not have enough assigned UTXOs'''
#
# Path: pypeerassets/provider/common.py
# class Provider(ABC):
#
# net = ""
#
# headers = {"User-Agent": "pypeerassets"}
#
# @staticmethod
# def _netname(name: str) -> dict:
# '''resolute network name,
# required because some providers use shortnames and other use longnames.'''
#
# try:
# long = net_query(name).name
# short = net_query(name).shortname
# except AttributeError:
# raise UnsupportedNetwork('''This blockchain network is not supported by the pypeerassets, check networks.py for list of supported networks.''')
#
# return {'long': long,
# 'short': short}
#
# @property
# def network(self) -> str:
# '''return network full name'''
#
# return self._netname(self.net)['long']
#
# @property
# def pa_parameters(self) -> PAParams:
# '''load network PeerAssets parameters.'''
#
# return param_query(self.network)
#
# @property
# def network_properties(self) -> Constants:
# '''network parameters [min_fee, denomination, ...]'''
#
# return net_query(self.network)
#
# @property
# def is_testnet(self) -> bool:
# """testnet or not?"""
#
# if "testnet" in self.network:
# return True
# else:
# return False
#
# @classmethod
# def sendrawtransaction(cls, rawtxn: str) -> str:
# '''sendrawtransaction remote API'''
#
# if cls.is_testnet:
# url = 'https://testnet-explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
# else:
# url = 'https://explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
#
# resp = urllib.request.urlopen(url)
# return resp.read().decode('utf-8')
#
# @abstractmethod
# def getblockhash(self, blocknum: int) -> str:
# '''get blockhash using blocknum query'''
# raise NotImplementedError
#
# @abstractmethod
# def getblockcount(self) -> int:
# '''get block count'''
# raise NotImplementedError
#
# @abstractmethod
# def getblock(self, hash: str) -> dict:
# '''query block using <blockhash> as key.'''
# raise NotImplementedError
#
# @abstractmethod
# def getdifficulty(self) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getbalance(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def getreceivedbyaddress(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def listunspent(self, address: str) -> list:
# raise NotImplementedError
#
# @abstractmethod
# def select_inputs(self, address: str, amount: int) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getrawtransaction(self, txid: str, decrypt: int=1) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def listtransactions(self, address: str) -> list:
# raise NotImplementedError
#
# def validateaddress(self, address: str) -> bool:
# "Returns True if the passed address is valid, False otherwise."
#
# try:
# Address.from_string(address, self.network_properties)
# except InvalidAddress:
# return False
#
# return True
, which may contain function names, class names, or code. Output only the next line. | raise Exception(response.reason) |
Next line prediction: <|code_start|> : network = peercoin [ppc], peercoin-testnet [tppc] ...
"""
self.net = self._netname(network)['short']
self.api_url = self.api_url_fmt.format(net=self.format_name(self.net))
if 'ppc' in self.net:
getcontext().prec = 6 # set to six decimals if it's Peercoin
@staticmethod
def format_name(net: str) -> str:
'''take care of specifics of cryptoid naming system'''
if net.startswith('t') or 'testnet' in net:
net = net[1:] + '-test'
else:
net = net
return net
@staticmethod
def get_url(url: str) -> Union[dict, int, float, str]:
'''Perform a GET request for the url and return a dictionary parsed from
the JSON response.'''
request = Request(url, headers={"User-Agent": "pypeerassets"})
response = cast(HTTPResponse, urlopen(request))
if response.status != 200:
raise Exception(response.reason)
return json.loads(response.read().decode())
<|code_end|>
. Use current file imports:
(from decimal import Decimal, getcontext
from http.client import HTTPResponse
from operator import itemgetter
from typing import Union, cast
from urllib.request import Request, urlopen
from btcpy.structs.transaction import TxIn, Sequence, ScriptSig
from pypeerassets.exceptions import InsufficientFunds
from pypeerassets.provider.common import Provider
import json)
and context including class names, function names, or small code snippets from other files:
# Path: pypeerassets/exceptions.py
# class InsufficientFunds(Exception):
# '''this address does not have enough assigned UTXOs'''
#
# Path: pypeerassets/provider/common.py
# class Provider(ABC):
#
# net = ""
#
# headers = {"User-Agent": "pypeerassets"}
#
# @staticmethod
# def _netname(name: str) -> dict:
# '''resolute network name,
# required because some providers use shortnames and other use longnames.'''
#
# try:
# long = net_query(name).name
# short = net_query(name).shortname
# except AttributeError:
# raise UnsupportedNetwork('''This blockchain network is not supported by the pypeerassets, check networks.py for list of supported networks.''')
#
# return {'long': long,
# 'short': short}
#
# @property
# def network(self) -> str:
# '''return network full name'''
#
# return self._netname(self.net)['long']
#
# @property
# def pa_parameters(self) -> PAParams:
# '''load network PeerAssets parameters.'''
#
# return param_query(self.network)
#
# @property
# def network_properties(self) -> Constants:
# '''network parameters [min_fee, denomination, ...]'''
#
# return net_query(self.network)
#
# @property
# def is_testnet(self) -> bool:
# """testnet or not?"""
#
# if "testnet" in self.network:
# return True
# else:
# return False
#
# @classmethod
# def sendrawtransaction(cls, rawtxn: str) -> str:
# '''sendrawtransaction remote API'''
#
# if cls.is_testnet:
# url = 'https://testnet-explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
# else:
# url = 'https://explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
#
# resp = urllib.request.urlopen(url)
# return resp.read().decode('utf-8')
#
# @abstractmethod
# def getblockhash(self, blocknum: int) -> str:
# '''get blockhash using blocknum query'''
# raise NotImplementedError
#
# @abstractmethod
# def getblockcount(self) -> int:
# '''get block count'''
# raise NotImplementedError
#
# @abstractmethod
# def getblock(self, hash: str) -> dict:
# '''query block using <blockhash> as key.'''
# raise NotImplementedError
#
# @abstractmethod
# def getdifficulty(self) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getbalance(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def getreceivedbyaddress(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def listunspent(self, address: str) -> list:
# raise NotImplementedError
#
# @abstractmethod
# def select_inputs(self, address: str, amount: int) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getrawtransaction(self, txid: str, decrypt: int=1) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def listtransactions(self, address: str) -> list:
# raise NotImplementedError
#
# def validateaddress(self, address: str) -> bool:
# "Returns True if the passed address is valid, False otherwise."
#
# try:
# Address.from_string(address, self.network_properties)
# except InvalidAddress:
# return False
#
# return True
. Output only the next line. | def api_req(self, query: str) -> dict: |
Predict the next line for this snippet: <|code_start|> return r.decode()
def getdifficulty(self) -> dict:
'''Returns the current difficulty.'''
return cast(dict, self.api_fetch(''))['backend']['difficulty']
def getblockcount(self) -> int:
'''Returns the current block index.'''
return cast(int, self.api_fetch(''))['backend']['blocks']
def getblockhash(self, index: int) -> str:
'''Returns the hash of the block at ; index 0 is the genesis block.'''
return cast(str, self.api_fetch('block-index/' + str(index))['blockHash'])
def getblock(self, hash: str) -> dict:
'''Returns information about the block with the given hash.'''
return cast(dict, self.api_fetch('block/' + hash))
def getrawtransaction(self, txid: str, decrypt: int=0) -> dict:
'''Returns raw transaction representation for given transaction id.
decrypt can be set to 0(false) or 1(true).'''
q = '/tx-specific/{txid}'.format(txid=txid)
return cast(dict, self.api_fetch(q))
<|code_end|>
with the help of current file imports:
from decimal import Decimal
from http.client import HTTPResponse
from typing import Union, cast
from urllib.request import urlopen
from btcpy.structs.transaction import ScriptSig, Sequence, TxIn
from pypeerassets.exceptions import InsufficientFunds, UnsupportedNetwork
from pypeerassets.provider.common import Provider
import json
and context from other files:
# Path: pypeerassets/exceptions.py
# class InsufficientFunds(Exception):
# '''this address does not have enough assigned UTXOs'''
#
# class UnsupportedNetwork(Exception):
# '''This network is not suppored by pypeerassets.'''
#
# Path: pypeerassets/provider/common.py
# class Provider(ABC):
#
# net = ""
#
# headers = {"User-Agent": "pypeerassets"}
#
# @staticmethod
# def _netname(name: str) -> dict:
# '''resolute network name,
# required because some providers use shortnames and other use longnames.'''
#
# try:
# long = net_query(name).name
# short = net_query(name).shortname
# except AttributeError:
# raise UnsupportedNetwork('''This blockchain network is not supported by the pypeerassets, check networks.py for list of supported networks.''')
#
# return {'long': long,
# 'short': short}
#
# @property
# def network(self) -> str:
# '''return network full name'''
#
# return self._netname(self.net)['long']
#
# @property
# def pa_parameters(self) -> PAParams:
# '''load network PeerAssets parameters.'''
#
# return param_query(self.network)
#
# @property
# def network_properties(self) -> Constants:
# '''network parameters [min_fee, denomination, ...]'''
#
# return net_query(self.network)
#
# @property
# def is_testnet(self) -> bool:
# """testnet or not?"""
#
# if "testnet" in self.network:
# return True
# else:
# return False
#
# @classmethod
# def sendrawtransaction(cls, rawtxn: str) -> str:
# '''sendrawtransaction remote API'''
#
# if cls.is_testnet:
# url = 'https://testnet-explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
# else:
# url = 'https://explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
#
# resp = urllib.request.urlopen(url)
# return resp.read().decode('utf-8')
#
# @abstractmethod
# def getblockhash(self, blocknum: int) -> str:
# '''get blockhash using blocknum query'''
# raise NotImplementedError
#
# @abstractmethod
# def getblockcount(self) -> int:
# '''get block count'''
# raise NotImplementedError
#
# @abstractmethod
# def getblock(self, hash: str) -> dict:
# '''query block using <blockhash> as key.'''
# raise NotImplementedError
#
# @abstractmethod
# def getdifficulty(self) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getbalance(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def getreceivedbyaddress(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def listunspent(self, address: str) -> list:
# raise NotImplementedError
#
# @abstractmethod
# def select_inputs(self, address: str, amount: int) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getrawtransaction(self, txid: str, decrypt: int=1) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def listtransactions(self, address: str) -> list:
# raise NotImplementedError
#
# def validateaddress(self, address: str) -> bool:
# "Returns True if the passed address is valid, False otherwise."
#
# try:
# Address.from_string(address, self.network_properties)
# except InvalidAddress:
# return False
#
# return True
, which may contain function names, class names, or code. Output only the next line. | def getaddress(self, address: str) -> dict:
|
Predict the next line for this snippet: <|code_start|> return json.loads(r.decode())
except json.decoder.JSONDecodeError:
return r.decode()
def getdifficulty(self) -> dict:
'''Returns the current difficulty.'''
return cast(dict, self.api_fetch(''))['backend']['difficulty']
def getblockcount(self) -> int:
'''Returns the current block index.'''
return cast(int, self.api_fetch(''))['backend']['blocks']
def getblockhash(self, index: int) -> str:
'''Returns the hash of the block at ; index 0 is the genesis block.'''
return cast(str, self.api_fetch('block-index/' + str(index))['blockHash'])
def getblock(self, hash: str) -> dict:
'''Returns information about the block with the given hash.'''
return cast(dict, self.api_fetch('block/' + hash))
def getrawtransaction(self, txid: str, decrypt: int=0) -> dict:
'''Returns raw transaction representation for given transaction id.
decrypt can be set to 0(false) or 1(true).'''
q = '/tx-specific/{txid}'.format(txid=txid)
<|code_end|>
with the help of current file imports:
from decimal import Decimal
from http.client import HTTPResponse
from typing import Union, cast
from urllib.request import urlopen
from btcpy.structs.transaction import ScriptSig, Sequence, TxIn
from pypeerassets.exceptions import InsufficientFunds, UnsupportedNetwork
from pypeerassets.provider.common import Provider
import json
and context from other files:
# Path: pypeerassets/exceptions.py
# class InsufficientFunds(Exception):
# '''this address does not have enough assigned UTXOs'''
#
# class UnsupportedNetwork(Exception):
# '''This network is not suppored by pypeerassets.'''
#
# Path: pypeerassets/provider/common.py
# class Provider(ABC):
#
# net = ""
#
# headers = {"User-Agent": "pypeerassets"}
#
# @staticmethod
# def _netname(name: str) -> dict:
# '''resolute network name,
# required because some providers use shortnames and other use longnames.'''
#
# try:
# long = net_query(name).name
# short = net_query(name).shortname
# except AttributeError:
# raise UnsupportedNetwork('''This blockchain network is not supported by the pypeerassets, check networks.py for list of supported networks.''')
#
# return {'long': long,
# 'short': short}
#
# @property
# def network(self) -> str:
# '''return network full name'''
#
# return self._netname(self.net)['long']
#
# @property
# def pa_parameters(self) -> PAParams:
# '''load network PeerAssets parameters.'''
#
# return param_query(self.network)
#
# @property
# def network_properties(self) -> Constants:
# '''network parameters [min_fee, denomination, ...]'''
#
# return net_query(self.network)
#
# @property
# def is_testnet(self) -> bool:
# """testnet or not?"""
#
# if "testnet" in self.network:
# return True
# else:
# return False
#
# @classmethod
# def sendrawtransaction(cls, rawtxn: str) -> str:
# '''sendrawtransaction remote API'''
#
# if cls.is_testnet:
# url = 'https://testnet-explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
# else:
# url = 'https://explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
#
# resp = urllib.request.urlopen(url)
# return resp.read().decode('utf-8')
#
# @abstractmethod
# def getblockhash(self, blocknum: int) -> str:
# '''get blockhash using blocknum query'''
# raise NotImplementedError
#
# @abstractmethod
# def getblockcount(self) -> int:
# '''get block count'''
# raise NotImplementedError
#
# @abstractmethod
# def getblock(self, hash: str) -> dict:
# '''query block using <blockhash> as key.'''
# raise NotImplementedError
#
# @abstractmethod
# def getdifficulty(self) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getbalance(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def getreceivedbyaddress(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def listunspent(self, address: str) -> list:
# raise NotImplementedError
#
# @abstractmethod
# def select_inputs(self, address: str, amount: int) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getrawtransaction(self, txid: str, decrypt: int=1) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def listtransactions(self, address: str) -> list:
# raise NotImplementedError
#
# def validateaddress(self, address: str) -> bool:
# "Returns True if the passed address is valid, False otherwise."
#
# try:
# Address.from_string(address, self.network_properties)
# except InvalidAddress:
# return False
#
# return True
, which may contain function names, class names, or code. Output only the next line. | return cast(dict, self.api_fetch(q))
|
Using the snippet: <|code_start|> return json.loads(r.decode())
except json.decoder.JSONDecodeError:
return r.decode()
def getdifficulty(self) -> dict:
'''Returns the current difficulty.'''
return cast(dict, self.api_fetch(''))['backend']['difficulty']
def getblockcount(self) -> int:
'''Returns the current block index.'''
return cast(int, self.api_fetch(''))['backend']['blocks']
def getblockhash(self, index: int) -> str:
'''Returns the hash of the block at ; index 0 is the genesis block.'''
return cast(str, self.api_fetch('block-index/' + str(index))['blockHash'])
def getblock(self, hash: str) -> dict:
'''Returns information about the block with the given hash.'''
return cast(dict, self.api_fetch('block/' + hash))
def getrawtransaction(self, txid: str, decrypt: int=0) -> dict:
'''Returns raw transaction representation for given transaction id.
decrypt can be set to 0(false) or 1(true).'''
q = '/tx-specific/{txid}'.format(txid=txid)
<|code_end|>
, determine the next line of code. You have imports:
from decimal import Decimal
from http.client import HTTPResponse
from typing import Union, cast
from urllib.request import urlopen
from btcpy.structs.transaction import ScriptSig, Sequence, TxIn
from pypeerassets.exceptions import InsufficientFunds, UnsupportedNetwork
from pypeerassets.provider.common import Provider
import json
and context (class names, function names, or code) available:
# Path: pypeerassets/exceptions.py
# class InsufficientFunds(Exception):
# '''this address does not have enough assigned UTXOs'''
#
# class UnsupportedNetwork(Exception):
# '''This network is not suppored by pypeerassets.'''
#
# Path: pypeerassets/provider/common.py
# class Provider(ABC):
#
# net = ""
#
# headers = {"User-Agent": "pypeerassets"}
#
# @staticmethod
# def _netname(name: str) -> dict:
# '''resolute network name,
# required because some providers use shortnames and other use longnames.'''
#
# try:
# long = net_query(name).name
# short = net_query(name).shortname
# except AttributeError:
# raise UnsupportedNetwork('''This blockchain network is not supported by the pypeerassets, check networks.py for list of supported networks.''')
#
# return {'long': long,
# 'short': short}
#
# @property
# def network(self) -> str:
# '''return network full name'''
#
# return self._netname(self.net)['long']
#
# @property
# def pa_parameters(self) -> PAParams:
# '''load network PeerAssets parameters.'''
#
# return param_query(self.network)
#
# @property
# def network_properties(self) -> Constants:
# '''network parameters [min_fee, denomination, ...]'''
#
# return net_query(self.network)
#
# @property
# def is_testnet(self) -> bool:
# """testnet or not?"""
#
# if "testnet" in self.network:
# return True
# else:
# return False
#
# @classmethod
# def sendrawtransaction(cls, rawtxn: str) -> str:
# '''sendrawtransaction remote API'''
#
# if cls.is_testnet:
# url = 'https://testnet-explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
# else:
# url = 'https://explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
#
# resp = urllib.request.urlopen(url)
# return resp.read().decode('utf-8')
#
# @abstractmethod
# def getblockhash(self, blocknum: int) -> str:
# '''get blockhash using blocknum query'''
# raise NotImplementedError
#
# @abstractmethod
# def getblockcount(self) -> int:
# '''get block count'''
# raise NotImplementedError
#
# @abstractmethod
# def getblock(self, hash: str) -> dict:
# '''query block using <blockhash> as key.'''
# raise NotImplementedError
#
# @abstractmethod
# def getdifficulty(self) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getbalance(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def getreceivedbyaddress(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def listunspent(self, address: str) -> list:
# raise NotImplementedError
#
# @abstractmethod
# def select_inputs(self, address: str, amount: int) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getrawtransaction(self, txid: str, decrypt: int=1) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def listtransactions(self, address: str) -> list:
# raise NotImplementedError
#
# def validateaddress(self, address: str) -> bool:
# "Returns True if the passed address is valid, False otherwise."
#
# try:
# Address.from_string(address, self.network_properties)
# except InvalidAddress:
# return False
#
# return True
. Output only the next line. | return cast(dict, self.api_fetch(q))
|
Continue the code snippet: <|code_start|>'''Common provider class with basic features.'''
class Provider(ABC):
net = ""
headers = {"User-Agent": "pypeerassets"}
@staticmethod
def _netname(name: str) -> dict:
'''resolute network name,
required because some providers use shortnames and other use longnames.'''
<|code_end|>
. Use current file imports:
from abc import ABC, abstractmethod
from decimal import Decimal
from btcpy.structs.address import Address, InvalidAddress
from pypeerassets.exceptions import UnsupportedNetwork
from pypeerassets.pa_constants import PAParams, param_query
from pypeerassets.networks import Constants, net_query
import urllib.request
and context (classes, functions, or code) from other files:
# Path: pypeerassets/exceptions.py
# class UnsupportedNetwork(Exception):
# '''This network is not suppored by pypeerassets.'''
#
# Path: pypeerassets/pa_constants.py
# def param_query(name: str) -> PAParams:
#
# Path: pypeerassets/networks.py
# class PeercoinTxOut(TxOut):
# def get_dust_threshold(self, size_to_relay_fee) -> float:
# def net_query(name: str) -> Constants:
. Output only the next line. | try: |
Using the snippet: <|code_start|>'''Common provider class with basic features.'''
class Provider(ABC):
net = ""
headers = {"User-Agent": "pypeerassets"}
@staticmethod
def _netname(name: str) -> dict:
'''resolute network name,
required because some providers use shortnames and other use longnames.'''
try:
long = net_query(name).name
short = net_query(name).shortname
except AttributeError:
raise UnsupportedNetwork('''This blockchain network is not supported by the pypeerassets, check networks.py for list of supported networks.''')
return {'long': long,
'short': short}
@property
<|code_end|>
, determine the next line of code. You have imports:
from abc import ABC, abstractmethod
from decimal import Decimal
from btcpy.structs.address import Address, InvalidAddress
from pypeerassets.exceptions import UnsupportedNetwork
from pypeerassets.pa_constants import PAParams, param_query
from pypeerassets.networks import Constants, net_query
import urllib.request
and context (class names, function names, or code) available:
# Path: pypeerassets/exceptions.py
# class UnsupportedNetwork(Exception):
# '''This network is not suppored by pypeerassets.'''
#
# Path: pypeerassets/pa_constants.py
# def param_query(name: str) -> PAParams:
#
# Path: pypeerassets/networks.py
# class PeercoinTxOut(TxOut):
# def get_dust_threshold(self, size_to_relay_fee) -> float:
# def net_query(name: str) -> Constants:
. Output only the next line. | def network(self) -> str: |
Based on the snippet: <|code_start|>'''Common provider class with basic features.'''
class Provider(ABC):
net = ""
headers = {"User-Agent": "pypeerassets"}
@staticmethod
def _netname(name: str) -> dict:
'''resolute network name,
required because some providers use shortnames and other use longnames.'''
try:
long = net_query(name).name
short = net_query(name).shortname
except AttributeError:
raise UnsupportedNetwork('''This blockchain network is not supported by the pypeerassets, check networks.py for list of supported networks.''')
<|code_end|>
, predict the immediate next line with the help of imports:
from abc import ABC, abstractmethod
from decimal import Decimal
from btcpy.structs.address import Address, InvalidAddress
from pypeerassets.exceptions import UnsupportedNetwork
from pypeerassets.pa_constants import PAParams, param_query
from pypeerassets.networks import Constants, net_query
import urllib.request
and context (classes, functions, sometimes code) from other files:
# Path: pypeerassets/exceptions.py
# class UnsupportedNetwork(Exception):
# '''This network is not suppored by pypeerassets.'''
#
# Path: pypeerassets/pa_constants.py
# def param_query(name: str) -> PAParams:
#
# Path: pypeerassets/networks.py
# class PeercoinTxOut(TxOut):
# def get_dust_threshold(self, size_to_relay_fee) -> float:
# def net_query(name: str) -> Constants:
. Output only the next line. | return {'long': long, |
Here is a snippet: <|code_start|>'''Common provider class with basic features.'''
class Provider(ABC):
net = ""
headers = {"User-Agent": "pypeerassets"}
@staticmethod
def _netname(name: str) -> dict:
'''resolute network name,
required because some providers use shortnames and other use longnames.'''
try:
long = net_query(name).name
short = net_query(name).shortname
except AttributeError:
raise UnsupportedNetwork('''This blockchain network is not supported by the pypeerassets, check networks.py for list of supported networks.''')
return {'long': long,
'short': short}
<|code_end|>
. Write the next line using the current file imports:
from abc import ABC, abstractmethod
from decimal import Decimal
from btcpy.structs.address import Address, InvalidAddress
from pypeerassets.exceptions import UnsupportedNetwork
from pypeerassets.pa_constants import PAParams, param_query
from pypeerassets.networks import Constants, net_query
import urllib.request
and context from other files:
# Path: pypeerassets/exceptions.py
# class UnsupportedNetwork(Exception):
# '''This network is not suppored by pypeerassets.'''
#
# Path: pypeerassets/pa_constants.py
# def param_query(name: str) -> PAParams:
#
# Path: pypeerassets/networks.py
# class PeercoinTxOut(TxOut):
# def get_dust_threshold(self, size_to_relay_fee) -> float:
# def net_query(name: str) -> Constants:
, which may include functions, classes, or code. Output only the next line. | @property |
Given the following code snippet before the placeholder: <|code_start|>'''Common provider class with basic features.'''
class Provider(ABC):
net = ""
headers = {"User-Agent": "pypeerassets"}
@staticmethod
def _netname(name: str) -> dict:
'''resolute network name,
required because some providers use shortnames and other use longnames.'''
<|code_end|>
, predict the next line using imports from the current file:
from abc import ABC, abstractmethod
from decimal import Decimal
from btcpy.structs.address import Address, InvalidAddress
from pypeerassets.exceptions import UnsupportedNetwork
from pypeerassets.pa_constants import PAParams, param_query
from pypeerassets.networks import Constants, net_query
import urllib.request
and context including class names, function names, and sometimes code from other files:
# Path: pypeerassets/exceptions.py
# class UnsupportedNetwork(Exception):
# '''This network is not suppored by pypeerassets.'''
#
# Path: pypeerassets/pa_constants.py
# def param_query(name: str) -> PAParams:
#
# Path: pypeerassets/networks.py
# class PeercoinTxOut(TxOut):
# def get_dust_threshold(self, size_to_relay_fee) -> float:
# def net_query(name: str) -> Constants:
. Output only the next line. | try: |
Using the snippet: <|code_start|>
'''Communicate with local or remote peercoin-daemon via JSON-RPC'''
getcontext().prec = 6
try:
except ImportError:
raise ImportError("peercoin_rpc library is required for this to work,\
use the pip to install it.")
class RpcNode(Client, Provider):
'''JSON-RPC connection to local Peercoin node'''
def select_inputs(self, address: str, amount: int) -> dict:
'''finds apropriate utxo's to include in rawtx, while being careful
to never spend old transactions with a lot of coin age.
Argument is intiger, returns list of apropriate UTXO's'''
utxos = []
utxo_sum = Decimal(0)
for tx in sorted(self.listunspent(address=address), key=itemgetter('confirmations')):
<|code_end|>
, determine the next line of code. You have imports:
from operator import itemgetter
from .common import Provider
from pypeerassets.exceptions import InsufficientFunds
from btcpy.structs.transaction import MutableTxIn, Sequence, ScriptSig
from decimal import Decimal, getcontext
from peercoin_rpc import Client
and context (class names, function names, or code) available:
# Path: pypeerassets/provider/common.py
# class Provider(ABC):
#
# net = ""
#
# headers = {"User-Agent": "pypeerassets"}
#
# @staticmethod
# def _netname(name: str) -> dict:
# '''resolute network name,
# required because some providers use shortnames and other use longnames.'''
#
# try:
# long = net_query(name).name
# short = net_query(name).shortname
# except AttributeError:
# raise UnsupportedNetwork('''This blockchain network is not supported by the pypeerassets, check networks.py for list of supported networks.''')
#
# return {'long': long,
# 'short': short}
#
# @property
# def network(self) -> str:
# '''return network full name'''
#
# return self._netname(self.net)['long']
#
# @property
# def pa_parameters(self) -> PAParams:
# '''load network PeerAssets parameters.'''
#
# return param_query(self.network)
#
# @property
# def network_properties(self) -> Constants:
# '''network parameters [min_fee, denomination, ...]'''
#
# return net_query(self.network)
#
# @property
# def is_testnet(self) -> bool:
# """testnet or not?"""
#
# if "testnet" in self.network:
# return True
# else:
# return False
#
# @classmethod
# def sendrawtransaction(cls, rawtxn: str) -> str:
# '''sendrawtransaction remote API'''
#
# if cls.is_testnet:
# url = 'https://testnet-explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
# else:
# url = 'https://explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
#
# resp = urllib.request.urlopen(url)
# return resp.read().decode('utf-8')
#
# @abstractmethod
# def getblockhash(self, blocknum: int) -> str:
# '''get blockhash using blocknum query'''
# raise NotImplementedError
#
# @abstractmethod
# def getblockcount(self) -> int:
# '''get block count'''
# raise NotImplementedError
#
# @abstractmethod
# def getblock(self, hash: str) -> dict:
# '''query block using <blockhash> as key.'''
# raise NotImplementedError
#
# @abstractmethod
# def getdifficulty(self) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getbalance(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def getreceivedbyaddress(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def listunspent(self, address: str) -> list:
# raise NotImplementedError
#
# @abstractmethod
# def select_inputs(self, address: str, amount: int) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getrawtransaction(self, txid: str, decrypt: int=1) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def listtransactions(self, address: str) -> list:
# raise NotImplementedError
#
# def validateaddress(self, address: str) -> bool:
# "Returns True if the passed address is valid, False otherwise."
#
# try:
# Address.from_string(address, self.network_properties)
# except InvalidAddress:
# return False
#
# return True
#
# Path: pypeerassets/exceptions.py
# class InsufficientFunds(Exception):
# '''this address does not have enough assigned UTXOs'''
. Output only the next line. | if tx["address"] not in (self.pa_parameters.P2TH_addr, |
Based on the snippet: <|code_start|>
'''Communicate with local or remote peercoin-daemon via JSON-RPC'''
getcontext().prec = 6
try:
except ImportError:
raise ImportError("peercoin_rpc library is required for this to work,\
use the pip to install it.")
class RpcNode(Client, Provider):
'''JSON-RPC connection to local Peercoin node'''
def select_inputs(self, address: str, amount: int) -> dict:
'''finds apropriate utxo's to include in rawtx, while being careful
to never spend old transactions with a lot of coin age.
Argument is intiger, returns list of apropriate UTXO's'''
utxos = []
utxo_sum = Decimal(0)
for tx in sorted(self.listunspent(address=address), key=itemgetter('confirmations')):
if tx["address"] not in (self.pa_parameters.P2TH_addr,
<|code_end|>
, predict the immediate next line with the help of imports:
from operator import itemgetter
from .common import Provider
from pypeerassets.exceptions import InsufficientFunds
from btcpy.structs.transaction import MutableTxIn, Sequence, ScriptSig
from decimal import Decimal, getcontext
from peercoin_rpc import Client
and context (classes, functions, sometimes code) from other files:
# Path: pypeerassets/provider/common.py
# class Provider(ABC):
#
# net = ""
#
# headers = {"User-Agent": "pypeerassets"}
#
# @staticmethod
# def _netname(name: str) -> dict:
# '''resolute network name,
# required because some providers use shortnames and other use longnames.'''
#
# try:
# long = net_query(name).name
# short = net_query(name).shortname
# except AttributeError:
# raise UnsupportedNetwork('''This blockchain network is not supported by the pypeerassets, check networks.py for list of supported networks.''')
#
# return {'long': long,
# 'short': short}
#
# @property
# def network(self) -> str:
# '''return network full name'''
#
# return self._netname(self.net)['long']
#
# @property
# def pa_parameters(self) -> PAParams:
# '''load network PeerAssets parameters.'''
#
# return param_query(self.network)
#
# @property
# def network_properties(self) -> Constants:
# '''network parameters [min_fee, denomination, ...]'''
#
# return net_query(self.network)
#
# @property
# def is_testnet(self) -> bool:
# """testnet or not?"""
#
# if "testnet" in self.network:
# return True
# else:
# return False
#
# @classmethod
# def sendrawtransaction(cls, rawtxn: str) -> str:
# '''sendrawtransaction remote API'''
#
# if cls.is_testnet:
# url = 'https://testnet-explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
# else:
# url = 'https://explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
#
# resp = urllib.request.urlopen(url)
# return resp.read().decode('utf-8')
#
# @abstractmethod
# def getblockhash(self, blocknum: int) -> str:
# '''get blockhash using blocknum query'''
# raise NotImplementedError
#
# @abstractmethod
# def getblockcount(self) -> int:
# '''get block count'''
# raise NotImplementedError
#
# @abstractmethod
# def getblock(self, hash: str) -> dict:
# '''query block using <blockhash> as key.'''
# raise NotImplementedError
#
# @abstractmethod
# def getdifficulty(self) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getbalance(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def getreceivedbyaddress(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def listunspent(self, address: str) -> list:
# raise NotImplementedError
#
# @abstractmethod
# def select_inputs(self, address: str, amount: int) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getrawtransaction(self, txid: str, decrypt: int=1) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def listtransactions(self, address: str) -> list:
# raise NotImplementedError
#
# def validateaddress(self, address: str) -> bool:
# "Returns True if the passed address is valid, False otherwise."
#
# try:
# Address.from_string(address, self.network_properties)
# except InvalidAddress:
# return False
#
# return True
#
# Path: pypeerassets/exceptions.py
# class InsufficientFunds(Exception):
# '''this address does not have enough assigned UTXOs'''
. Output only the next line. | self.pa_parameters.test_P2TH_addr): |
Given snippet: <|code_start|>
def test_net_query():
"Check that we can find NetworkParams for networks by name."
# Use a network's long name
net_params = net_query("peercoin")
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pytest
from pypeerassets.exceptions import UnsupportedNetwork
from pypeerassets.networks import net_query
and context:
# Path: pypeerassets/exceptions.py
# class UnsupportedNetwork(Exception):
# '''This network is not suppored by pypeerassets.'''
#
# Path: pypeerassets/networks.py
# def net_query(name: str) -> Constants:
# '''Find the NetworkParams for a network by its long or short name. Raises
# UnsupportedNetwork if no NetworkParams is found.
# '''
#
# for net_params in networks:
# if name in (net_params.name, net_params.shortname,):
# return net_params
#
# raise UnsupportedNetwork
which might include code, classes, or functions. Output only the next line. | assert net_params.shortname == "ppc" |
Using the snippet: <|code_start|>
def test_net_query():
"Check that we can find NetworkParams for networks by name."
# Use a network's long name
net_params = net_query("peercoin")
assert net_params.shortname == "ppc"
# Use a network's short name
net_params = net_query("tppc")
<|code_end|>
, determine the next line of code. You have imports:
import pytest
from pypeerassets.exceptions import UnsupportedNetwork
from pypeerassets.networks import net_query
and context (class names, function names, or code) available:
# Path: pypeerassets/exceptions.py
# class UnsupportedNetwork(Exception):
# '''This network is not suppored by pypeerassets.'''
#
# Path: pypeerassets/networks.py
# def net_query(name: str) -> Constants:
# '''Find the NetworkParams for a network by its long or short name. Raises
# UnsupportedNetwork if no NetworkParams is found.
# '''
#
# for net_params in networks:
# if name in (net_params.name, net_params.shortname,):
# return net_params
#
# raise UnsupportedNetwork
. Output only the next line. | assert net_params.name == "peercoin-testnet" |
Given the following code snippet before the placeholder: <|code_start|># Install the Peercoin Wallet software and make the testnet rpc server
# available. A peercoin.conf with the following options should work:
#
# testnet=1
# server=1
# txindex=1
# rpcuser=<rpc username>
# rpcpassword=<rpc password>
RPC_USERNAME = "<rpc username>"
RPC_PASSWORD = "<rpc password>"
# Generate an address for Friendly Co., Alice, Bob and Charles using the
# Peercoin Wallet software:
FRIENDLY_CO = "<testnet address>"
ALICE = "<testnet address>"
BOB = "<testnet address>"
CHARLES = "<testnet address>"
# Obtain testnet coins for Friendly Co. and Alice
# using https://faucet.peercoinexplorer.net
# Run the script `python once_issue_mode_example.py` :)
def wait_for_confirmation(provider, transaction_id):
'Sleep on a loop until we see a confirmation of the transaction.'
while(True):
transaction = provider.gettransaction(transaction_id)
<|code_end|>
, predict the next line using imports from the current file:
import time
import pypeerassets as pa
from pypeerassets.protocol import IssueMode
from pypeerassets.provider import RpcNode
from pypeerassets.transactions import sign_transaction
and context including class names, function names, and sometimes code from other files:
# Path: pypeerassets/protocol.py
# class IssueMode(Enum):
#
# NONE = 0x00
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L19
# # No issuance allowed.
#
# CUSTOM = 0x01
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L20
# # Custom issue mode, verified by client aware of this.
#
# ONCE = 0x02
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L21
# # A single card_issue transaction allowed.
#
# MULTI = 0x04
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L22
# # Multiple card_issue transactions allowed.
#
# MONO = 0x08
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L23
# # All card transaction amounts are equal to 1.
#
# UNFLUSHABLE = 0x10
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L24
# # The UNFLUSHABLE issue mode invalidates any card transfer transaction except for the card issue transaction.
# # Meaning that only the issuing entity is able to change the balance of a specific address.
# # To correctly calculate the balance of a PeerAssets addres a client should only consider the card transfer
# # transactions originating from the deck owner.
#
# SUBSCRIPTION = 0x34 # SUBSCRIPTION (34 = 20 | 4 | 10)
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L26
# # The SUBSCRIPTION issue mode marks an address holding tokens as subscribed for a limited timeframe. This timeframe is
# # defined by the balance of the account and the time at which the first cards of this token are received.
# # To check validity of a subscription one should take the timestamp of the first received cards and add the address' balance to it in hours.
#
# SINGLET = 0x0a # SINGLET is a combination of ONCE and MONO (2 | 8)
#
# Path: pypeerassets/provider/rpcnode.py
# class RpcNode(Client, Provider):
# '''JSON-RPC connection to local Peercoin node'''
#
# def select_inputs(self, address: str, amount: int) -> dict:
# '''finds apropriate utxo's to include in rawtx, while being careful
# to never spend old transactions with a lot of coin age.
# Argument is intiger, returns list of apropriate UTXO's'''
#
# utxos = []
# utxo_sum = Decimal(0)
# for tx in sorted(self.listunspent(address=address), key=itemgetter('confirmations')):
#
# if tx["address"] not in (self.pa_parameters.P2TH_addr,
# self.pa_parameters.test_P2TH_addr):
#
# utxos.append(
# MutableTxIn(txid=tx['txid'],
# txout=tx['vout'],
# sequence=Sequence.max(),
# script_sig=ScriptSig.empty())
# )
#
# utxo_sum += Decimal(tx["amount"])
# if utxo_sum >= amount:
# return {'utxos': utxos, 'total': utxo_sum}
#
# if utxo_sum < amount:
# raise InsufficientFunds("Insufficient funds.")
#
# raise Exception("undefined behavior :.(")
#
# @property
# def is_testnet(self) -> bool:
# '''check if node is configured to use testnet or mainnet'''
#
# if self.getinfo()["testnet"] is True:
# return True
# else:
# return False
#
# @property
# def network(self) -> str:
# '''return which network is the node operating on.'''
#
# if self.is_testnet:
# return "tppc"
# else:
# return "ppc"
#
# def listunspent(
# self,
# address: str="",
# minconf: int=1,
# maxconf: int=999999,
# ) -> list:
# '''list UTXOs
# modified version to allow filtering by address.
# '''
# if address:
# return self.req("listunspent", [minconf, maxconf, [address]])
#
# return self.req("listunspent", [minconf, maxconf])
#
# Path: pypeerassets/transactions.py
# def sign_transaction(provider: Provider, unsigned: MutableTransaction,
# key: Kutil) -> Transaction:
# '''sign transaction with Kutil'''
#
# parent_outputs = [find_parent_outputs(provider, i) for i in unsigned.ins]
# return key.sign_transaction(parent_outputs, unsigned)
. Output only the next line. | if transaction["confirmations"] > 0: |
Continue the code snippet: <|code_start|> print("Waiting for confirmation...")
wait_for_confirmation(rpc_node, card_transfer_tx.txid)
print("Friendly Co. Cards created!")
print("Double checking the Friendly Co. Deck State...")
cards = pa.find_all_valid_cards(rpc_node, deck)
deck_state = pa.DeckState(cards)
assert len(deck_state.balances) == 1, "Only Alice should have Friendly Co. Cards."
assert deck_state.balances[ALICE] == 1000000, "Alice should have the initial 1,000,000 Cards."
print("Friendly Co. Deck State looks good!")
# Card Transfer
print("Build, sign and send the Card Transfer transaction to Bob and Charles...")
alice_key = pa.Kutil(
network="tppc",
from_wif=rpc_node.dumpprivkey(ALICE),
)
card_transfer = pa.CardTransfer(
deck=deck,
receiver=[BOB, CHARLES],
amount=[250000, 250000],
sender=ALICE,
)
card_transfer_tx = pa.card_transfer(
provider=rpc_node,
card=card_transfer,
<|code_end|>
. Use current file imports:
import time
import pypeerassets as pa
from pypeerassets.protocol import IssueMode
from pypeerassets.provider import RpcNode
from pypeerassets.transactions import sign_transaction
and context (classes, functions, or code) from other files:
# Path: pypeerassets/protocol.py
# class IssueMode(Enum):
#
# NONE = 0x00
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L19
# # No issuance allowed.
#
# CUSTOM = 0x01
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L20
# # Custom issue mode, verified by client aware of this.
#
# ONCE = 0x02
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L21
# # A single card_issue transaction allowed.
#
# MULTI = 0x04
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L22
# # Multiple card_issue transactions allowed.
#
# MONO = 0x08
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L23
# # All card transaction amounts are equal to 1.
#
# UNFLUSHABLE = 0x10
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L24
# # The UNFLUSHABLE issue mode invalidates any card transfer transaction except for the card issue transaction.
# # Meaning that only the issuing entity is able to change the balance of a specific address.
# # To correctly calculate the balance of a PeerAssets addres a client should only consider the card transfer
# # transactions originating from the deck owner.
#
# SUBSCRIPTION = 0x34 # SUBSCRIPTION (34 = 20 | 4 | 10)
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L26
# # The SUBSCRIPTION issue mode marks an address holding tokens as subscribed for a limited timeframe. This timeframe is
# # defined by the balance of the account and the time at which the first cards of this token are received.
# # To check validity of a subscription one should take the timestamp of the first received cards and add the address' balance to it in hours.
#
# SINGLET = 0x0a # SINGLET is a combination of ONCE and MONO (2 | 8)
#
# Path: pypeerassets/provider/rpcnode.py
# class RpcNode(Client, Provider):
# '''JSON-RPC connection to local Peercoin node'''
#
# def select_inputs(self, address: str, amount: int) -> dict:
# '''finds apropriate utxo's to include in rawtx, while being careful
# to never spend old transactions with a lot of coin age.
# Argument is intiger, returns list of apropriate UTXO's'''
#
# utxos = []
# utxo_sum = Decimal(0)
# for tx in sorted(self.listunspent(address=address), key=itemgetter('confirmations')):
#
# if tx["address"] not in (self.pa_parameters.P2TH_addr,
# self.pa_parameters.test_P2TH_addr):
#
# utxos.append(
# MutableTxIn(txid=tx['txid'],
# txout=tx['vout'],
# sequence=Sequence.max(),
# script_sig=ScriptSig.empty())
# )
#
# utxo_sum += Decimal(tx["amount"])
# if utxo_sum >= amount:
# return {'utxos': utxos, 'total': utxo_sum}
#
# if utxo_sum < amount:
# raise InsufficientFunds("Insufficient funds.")
#
# raise Exception("undefined behavior :.(")
#
# @property
# def is_testnet(self) -> bool:
# '''check if node is configured to use testnet or mainnet'''
#
# if self.getinfo()["testnet"] is True:
# return True
# else:
# return False
#
# @property
# def network(self) -> str:
# '''return which network is the node operating on.'''
#
# if self.is_testnet:
# return "tppc"
# else:
# return "ppc"
#
# def listunspent(
# self,
# address: str="",
# minconf: int=1,
# maxconf: int=999999,
# ) -> list:
# '''list UTXOs
# modified version to allow filtering by address.
# '''
# if address:
# return self.req("listunspent", [minconf, maxconf, [address]])
#
# return self.req("listunspent", [minconf, maxconf])
#
# Path: pypeerassets/transactions.py
# def sign_transaction(provider: Provider, unsigned: MutableTransaction,
# key: Kutil) -> Transaction:
# '''sign transaction with Kutil'''
#
# parent_outputs = [find_parent_outputs(provider, i) for i in unsigned.ins]
# return key.sign_transaction(parent_outputs, unsigned)
. Output only the next line. | inputs=rpc_node.select_inputs(ALICE, 0.02), |
Next line prediction: <|code_start|> transaction = provider.gettransaction(transaction_id)
if transaction["confirmations"] > 0:
break
time.sleep(10)
if __name__ == "__main__":
# Deck Spawn
print("Build, sign and send the Friendly Co. Deck spawning transaction...")
rpc_node = RpcNode(testnet=True, username=RPC_USERNAME, password=RPC_PASSWORD)
friendly_co_key = pa.Kutil(
network="tppc",
from_wif=rpc_node.dumpprivkey(FRIENDLY_CO),
)
deck = pa.Deck(
name="Friendly Co. Deck",
number_of_decimals=0,
issue_mode=IssueMode.ONCE.value,
network="tppc",
production=False,
version=1,
issuer=FRIENDLY_CO,
)
deck_spawn_tx = pa.deck_spawn(
<|code_end|>
. Use current file imports:
(import time
import pypeerassets as pa
from pypeerassets.protocol import IssueMode
from pypeerassets.provider import RpcNode
from pypeerassets.transactions import sign_transaction)
and context including class names, function names, or small code snippets from other files:
# Path: pypeerassets/protocol.py
# class IssueMode(Enum):
#
# NONE = 0x00
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L19
# # No issuance allowed.
#
# CUSTOM = 0x01
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L20
# # Custom issue mode, verified by client aware of this.
#
# ONCE = 0x02
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L21
# # A single card_issue transaction allowed.
#
# MULTI = 0x04
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L22
# # Multiple card_issue transactions allowed.
#
# MONO = 0x08
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L23
# # All card transaction amounts are equal to 1.
#
# UNFLUSHABLE = 0x10
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L24
# # The UNFLUSHABLE issue mode invalidates any card transfer transaction except for the card issue transaction.
# # Meaning that only the issuing entity is able to change the balance of a specific address.
# # To correctly calculate the balance of a PeerAssets addres a client should only consider the card transfer
# # transactions originating from the deck owner.
#
# SUBSCRIPTION = 0x34 # SUBSCRIPTION (34 = 20 | 4 | 10)
# # https://github.com/PeerAssets/rfcs/blob/master/0001-peerassets-transaction-specification.proto#L26
# # The SUBSCRIPTION issue mode marks an address holding tokens as subscribed for a limited timeframe. This timeframe is
# # defined by the balance of the account and the time at which the first cards of this token are received.
# # To check validity of a subscription one should take the timestamp of the first received cards and add the address' balance to it in hours.
#
# SINGLET = 0x0a # SINGLET is a combination of ONCE and MONO (2 | 8)
#
# Path: pypeerassets/provider/rpcnode.py
# class RpcNode(Client, Provider):
# '''JSON-RPC connection to local Peercoin node'''
#
# def select_inputs(self, address: str, amount: int) -> dict:
# '''finds apropriate utxo's to include in rawtx, while being careful
# to never spend old transactions with a lot of coin age.
# Argument is intiger, returns list of apropriate UTXO's'''
#
# utxos = []
# utxo_sum = Decimal(0)
# for tx in sorted(self.listunspent(address=address), key=itemgetter('confirmations')):
#
# if tx["address"] not in (self.pa_parameters.P2TH_addr,
# self.pa_parameters.test_P2TH_addr):
#
# utxos.append(
# MutableTxIn(txid=tx['txid'],
# txout=tx['vout'],
# sequence=Sequence.max(),
# script_sig=ScriptSig.empty())
# )
#
# utxo_sum += Decimal(tx["amount"])
# if utxo_sum >= amount:
# return {'utxos': utxos, 'total': utxo_sum}
#
# if utxo_sum < amount:
# raise InsufficientFunds("Insufficient funds.")
#
# raise Exception("undefined behavior :.(")
#
# @property
# def is_testnet(self) -> bool:
# '''check if node is configured to use testnet or mainnet'''
#
# if self.getinfo()["testnet"] is True:
# return True
# else:
# return False
#
# @property
# def network(self) -> str:
# '''return which network is the node operating on.'''
#
# if self.is_testnet:
# return "tppc"
# else:
# return "ppc"
#
# def listunspent(
# self,
# address: str="",
# minconf: int=1,
# maxconf: int=999999,
# ) -> list:
# '''list UTXOs
# modified version to allow filtering by address.
# '''
# if address:
# return self.req("listunspent", [minconf, maxconf, [address]])
#
# return self.req("listunspent", [minconf, maxconf])
#
# Path: pypeerassets/transactions.py
# def sign_transaction(provider: Provider, unsigned: MutableTransaction,
# key: Kutil) -> Transaction:
# '''sign transaction with Kutil'''
#
# parent_outputs = [find_parent_outputs(provider, i) for i in unsigned.ins]
# return key.sign_transaction(parent_outputs, unsigned)
. Output only the next line. | provider=rpc_node, |
Given snippet: <|code_start|>def test_crypotid_network():
assert Cryptoid(network="ppc").network == "peercoin"
def test_cryptoid_getblockcount():
assert isinstance(Cryptoid(network="ppc").getblockcount(), int)
def test_cryptoid_getblock():
provider = Cryptoid(network="tppc")
assert isinstance(provider.getblock('0000000429a1e623da44a7430b9d9ae377bc2da203043c444c313b2d4390eba2'), dict)
def test_cryptoid_get_block_hash():
assert isinstance(Cryptoid(network="ppc").getblockhash(3378), str)
def test_cryptoid_getdifficulty():
difficulty = Cryptoid(network="ppc").getdifficulty()
assert isinstance(difficulty["proof-of-stake"], float)
def test_cryptoid_getbalance():
assert isinstance(Cryptoid(network="ppc").getbalance(
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from decimal import Decimal
from pypeerassets.provider.cryptoid import Cryptoid
and context:
# Path: pypeerassets/provider/cryptoid.py
# class Cryptoid(Provider):
#
# '''API wrapper for http://chainz.cryptoid.info blockexplorer.'''
#
# api_key = '7547f94398e3'
# api_url_fmt = 'https://chainz.cryptoid.info/{net}/api.dws'
# explorer_url = 'https://chainz.cryptoid.info/explorer/'
#
# def __init__(self, network: str) -> None:
# """
# : network = peercoin [ppc], peercoin-testnet [tppc] ...
# """
#
# self.net = self._netname(network)['short']
# self.api_url = self.api_url_fmt.format(net=self.format_name(self.net))
# if 'ppc' in self.net:
# getcontext().prec = 6 # set to six decimals if it's Peercoin
#
# @staticmethod
# def format_name(net: str) -> str:
# '''take care of specifics of cryptoid naming system'''
#
# if net.startswith('t') or 'testnet' in net:
# net = net[1:] + '-test'
# else:
# net = net
#
# return net
#
# @staticmethod
# def get_url(url: str) -> Union[dict, int, float, str]:
# '''Perform a GET request for the url and return a dictionary parsed from
# the JSON response.'''
#
# request = Request(url, headers={"User-Agent": "pypeerassets"})
# response = cast(HTTPResponse, urlopen(request))
# if response.status != 200:
# raise Exception(response.reason)
# return json.loads(response.read().decode())
#
# def api_req(self, query: str) -> dict:
#
# query = "?q=" + query + "&key=" + self.api_key
# return cast(dict, self.get_url(self.api_url + query))
#
# def getblockcount(self) -> int:
#
# return cast(int, self.api_req('getblockcount'))
#
# def getblock(self, blockhash: str) -> dict:
# '''query block using <blockhash> as key.'''
#
# query = 'block.raw.dws?coin={net}&hash={blockhash}'.format(
# net=self.format_name(self.net),
# blockhash=blockhash,
# )
# return cast(dict, self.get_url(self.explorer_url + query))
#
# def getblockhash(self, blocknum: int) -> str:
# '''get blockhash'''
#
# query = 'getblockhash' + '&height=' + str(blocknum)
# return cast(str, self.api_req(query))
#
# def getdifficulty(self) -> dict:
#
# pos_difficulty = cast(float, self.api_req('getdifficulty'))
# return {"proof-of-stake": pos_difficulty}
#
# def getbalance(self, address: str) -> Decimal:
#
# query = 'getbalance' + '&a=' + address
# return Decimal(cast(float, self.api_req(query)))
#
# def getreceivedbyaddress(self, address: str) -> Decimal:
#
# query = 'getreceivedbyaddress' + "&a=" + address
# return Decimal(cast(float, self.api_req(query)))
#
# def listunspent(self, address: str) -> list:
#
# query = 'unspent' + "&active=" + address
# return cast(dict, self.api_req(query))['unspent_outputs']
#
# def select_inputs(self, address: str, amount: int) -> dict:
# '''select UTXOs'''
#
# utxos = []
# utxo_sum = Decimal(-0.01) # starts from negative due to minimal fee
# for tx in sorted(self.listunspent(address=address), key=itemgetter('confirmations')):
#
# utxos.append(
# TxIn(txid=tx['tx_hash'],
# txout=tx['tx_ouput_n'],
# sequence=Sequence.max(),
# script_sig=ScriptSig.unhexlify(tx['script']))
# )
#
# utxo_sum += Decimal(int(tx['value']) / 100000000)
# if utxo_sum >= amount:
# return {'utxos': utxos, 'total': utxo_sum}
#
# if utxo_sum < amount:
# raise InsufficientFunds('Insufficient funds.')
#
# raise Exception("undefined behavior :.(")
#
# def getrawtransaction(self, txid: str, decrypt: int=0) -> dict:
#
# query = 'tx.raw.dws?coin={net}&id={txid}'.format(
# net=self.format_name(self.net),
# txid=txid,
# )
# if not decrypt:
# query += '&hex'
# return cast(dict, self.get_url(self.explorer_url + query))['hex']
#
# return cast(dict, self.get_url(self.explorer_url + query))
#
# def listtransactions(self, address: str) -> list:
#
# query = 'address.summary.dws?coin={net}&id={addr}'.format(
# net=self.format_name(self.net),
# addr=address,
# )
# response = cast(dict, self.get_url(self.explorer_url + query))
# return [tx[1].lower() for tx in response["tx"]]
which might include code, classes, or functions. Output only the next line. | 'PHvDhfz1dGyPbZZ3Qnp56y92zmy98sncZT'), Decimal) |
Next line prediction: <|code_start|>
class PeercoinTxOut(TxOut):
def get_dust_threshold(self, size_to_relay_fee) -> float:
if isinstance(self.script_pubkey, NulldataScript):
return 0
return 0.01
# constants to be consumed by the backend
Constants = namedtuple('Constants', [
'name',
'shortname',
'base58_prefixes',
'base58_raw_prefixes',
'bech32_hrp',
'bech32_net',
'xkeys_prefix',
'xpub_version',
'xprv_version',
'wif_prefix',
'from_unit',
'to_unit',
'min_tx_fee',
'tx_timestamp',
<|code_end|>
. Use current file imports:
(from collections import namedtuple
from decimal import Decimal
from btcpy.structs.transaction import TxOut
from btcpy.structs.script import NulldataScript
from pypeerassets.exceptions import UnsupportedNetwork)
and context including class names, function names, or small code snippets from other files:
# Path: pypeerassets/exceptions.py
# class UnsupportedNetwork(Exception):
# '''This network is not suppored by pypeerassets.'''
. Output only the next line. | 'tx_out_cls', |
Using the snippet: <|code_start|> return cast(dict, self.api_fetch('getdifficulty'))
def getconnectioncount(self) -> int:
'''Returns the number of connections the block explorer has to other nodes.'''
return cast(int, self.api_fetch('getconnectioncount'))
def getblockcount(self) -> int:
'''Returns the current block index.'''
return cast(int, self.api_fetch('getblockcount'))
def getblockhash(self, index: int) -> str:
'''Returns the hash of the block at ; index 0 is the genesis block.'''
return cast(str, self.api_fetch('getblockhash?index=' + str(index)))
def getblock(self, hash: str) -> dict:
'''Returns information about the block with the given hash.'''
return cast(dict, self.api_fetch('getblock?hash=' + hash))
def getrawtransaction(self, txid: str, decrypt: int=0) -> dict:
'''Returns raw transaction representation for given transaction id.
decrypt can be set to 0(false) or 1(true).'''
q = 'getrawtransaction?txid={txid}&decrypt={decrypt}'.format(txid=txid, decrypt=decrypt)
return cast(dict, self.api_fetch(q))
<|code_end|>
, determine the next line of code. You have imports:
from decimal import Decimal
from http.client import HTTPResponse
from typing import Union, cast
from urllib.request import urlopen
from btcpy.structs.transaction import ScriptSig, Sequence, TxIn
from pypeerassets.exceptions import InsufficientFunds, UnsupportedNetwork
from pypeerassets.provider.common import Provider
import json
and context (class names, function names, or code) available:
# Path: pypeerassets/exceptions.py
# class InsufficientFunds(Exception):
# '''this address does not have enough assigned UTXOs'''
#
# class UnsupportedNetwork(Exception):
# '''This network is not suppored by pypeerassets.'''
#
# Path: pypeerassets/provider/common.py
# class Provider(ABC):
#
# net = ""
#
# headers = {"User-Agent": "pypeerassets"}
#
# @staticmethod
# def _netname(name: str) -> dict:
# '''resolute network name,
# required because some providers use shortnames and other use longnames.'''
#
# try:
# long = net_query(name).name
# short = net_query(name).shortname
# except AttributeError:
# raise UnsupportedNetwork('''This blockchain network is not supported by the pypeerassets, check networks.py for list of supported networks.''')
#
# return {'long': long,
# 'short': short}
#
# @property
# def network(self) -> str:
# '''return network full name'''
#
# return self._netname(self.net)['long']
#
# @property
# def pa_parameters(self) -> PAParams:
# '''load network PeerAssets parameters.'''
#
# return param_query(self.network)
#
# @property
# def network_properties(self) -> Constants:
# '''network parameters [min_fee, denomination, ...]'''
#
# return net_query(self.network)
#
# @property
# def is_testnet(self) -> bool:
# """testnet or not?"""
#
# if "testnet" in self.network:
# return True
# else:
# return False
#
# @classmethod
# def sendrawtransaction(cls, rawtxn: str) -> str:
# '''sendrawtransaction remote API'''
#
# if cls.is_testnet:
# url = 'https://testnet-explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
# else:
# url = 'https://explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
#
# resp = urllib.request.urlopen(url)
# return resp.read().decode('utf-8')
#
# @abstractmethod
# def getblockhash(self, blocknum: int) -> str:
# '''get blockhash using blocknum query'''
# raise NotImplementedError
#
# @abstractmethod
# def getblockcount(self) -> int:
# '''get block count'''
# raise NotImplementedError
#
# @abstractmethod
# def getblock(self, hash: str) -> dict:
# '''query block using <blockhash> as key.'''
# raise NotImplementedError
#
# @abstractmethod
# def getdifficulty(self) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getbalance(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def getreceivedbyaddress(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def listunspent(self, address: str) -> list:
# raise NotImplementedError
#
# @abstractmethod
# def select_inputs(self, address: str, amount: int) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getrawtransaction(self, txid: str, decrypt: int=1) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def listtransactions(self, address: str) -> list:
# raise NotImplementedError
#
# def validateaddress(self, address: str) -> bool:
# "Returns True if the passed address is valid, False otherwise."
#
# try:
# Address.from_string(address, self.network_properties)
# except InvalidAddress:
# return False
#
# return True
. Output only the next line. | def getnetworkghps(self) -> float: |
Here is a snippet: <|code_start|> '''Returns the current difficulty.'''
return cast(dict, self.api_fetch('getdifficulty'))
def getconnectioncount(self) -> int:
'''Returns the number of connections the block explorer has to other nodes.'''
return cast(int, self.api_fetch('getconnectioncount'))
def getblockcount(self) -> int:
'''Returns the current block index.'''
return cast(int, self.api_fetch('getblockcount'))
def getblockhash(self, index: int) -> str:
'''Returns the hash of the block at ; index 0 is the genesis block.'''
return cast(str, self.api_fetch('getblockhash?index=' + str(index)))
def getblock(self, hash: str) -> dict:
'''Returns information about the block with the given hash.'''
return cast(dict, self.api_fetch('getblock?hash=' + hash))
def getrawtransaction(self, txid: str, decrypt: int=0) -> dict:
'''Returns raw transaction representation for given transaction id.
decrypt can be set to 0(false) or 1(true).'''
q = 'getrawtransaction?txid={txid}&decrypt={decrypt}'.format(txid=txid, decrypt=decrypt)
<|code_end|>
. Write the next line using the current file imports:
from decimal import Decimal
from http.client import HTTPResponse
from typing import Union, cast
from urllib.request import urlopen
from btcpy.structs.transaction import ScriptSig, Sequence, TxIn
from pypeerassets.exceptions import InsufficientFunds, UnsupportedNetwork
from pypeerassets.provider.common import Provider
import json
and context from other files:
# Path: pypeerassets/exceptions.py
# class InsufficientFunds(Exception):
# '''this address does not have enough assigned UTXOs'''
#
# class UnsupportedNetwork(Exception):
# '''This network is not suppored by pypeerassets.'''
#
# Path: pypeerassets/provider/common.py
# class Provider(ABC):
#
# net = ""
#
# headers = {"User-Agent": "pypeerassets"}
#
# @staticmethod
# def _netname(name: str) -> dict:
# '''resolute network name,
# required because some providers use shortnames and other use longnames.'''
#
# try:
# long = net_query(name).name
# short = net_query(name).shortname
# except AttributeError:
# raise UnsupportedNetwork('''This blockchain network is not supported by the pypeerassets, check networks.py for list of supported networks.''')
#
# return {'long': long,
# 'short': short}
#
# @property
# def network(self) -> str:
# '''return network full name'''
#
# return self._netname(self.net)['long']
#
# @property
# def pa_parameters(self) -> PAParams:
# '''load network PeerAssets parameters.'''
#
# return param_query(self.network)
#
# @property
# def network_properties(self) -> Constants:
# '''network parameters [min_fee, denomination, ...]'''
#
# return net_query(self.network)
#
# @property
# def is_testnet(self) -> bool:
# """testnet or not?"""
#
# if "testnet" in self.network:
# return True
# else:
# return False
#
# @classmethod
# def sendrawtransaction(cls, rawtxn: str) -> str:
# '''sendrawtransaction remote API'''
#
# if cls.is_testnet:
# url = 'https://testnet-explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
# else:
# url = 'https://explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
#
# resp = urllib.request.urlopen(url)
# return resp.read().decode('utf-8')
#
# @abstractmethod
# def getblockhash(self, blocknum: int) -> str:
# '''get blockhash using blocknum query'''
# raise NotImplementedError
#
# @abstractmethod
# def getblockcount(self) -> int:
# '''get block count'''
# raise NotImplementedError
#
# @abstractmethod
# def getblock(self, hash: str) -> dict:
# '''query block using <blockhash> as key.'''
# raise NotImplementedError
#
# @abstractmethod
# def getdifficulty(self) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getbalance(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def getreceivedbyaddress(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def listunspent(self, address: str) -> list:
# raise NotImplementedError
#
# @abstractmethod
# def select_inputs(self, address: str, amount: int) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getrawtransaction(self, txid: str, decrypt: int=1) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def listtransactions(self, address: str) -> list:
# raise NotImplementedError
#
# def validateaddress(self, address: str) -> bool:
# "Returns True if the passed address is valid, False otherwise."
#
# try:
# Address.from_string(address, self.network_properties)
# except InvalidAddress:
# return False
#
# return True
, which may include functions, classes, or code. Output only the next line. | return cast(dict, self.api_fetch(q)) |
Predict the next line for this snippet: <|code_start|> return cast(dict, self.api_fetch('getdifficulty'))
def getconnectioncount(self) -> int:
'''Returns the number of connections the block explorer has to other nodes.'''
return cast(int, self.api_fetch('getconnectioncount'))
def getblockcount(self) -> int:
'''Returns the current block index.'''
return cast(int, self.api_fetch('getblockcount'))
def getblockhash(self, index: int) -> str:
'''Returns the hash of the block at ; index 0 is the genesis block.'''
return cast(str, self.api_fetch('getblockhash?index=' + str(index)))
def getblock(self, hash: str) -> dict:
'''Returns information about the block with the given hash.'''
return cast(dict, self.api_fetch('getblock?hash=' + hash))
def getrawtransaction(self, txid: str, decrypt: int=0) -> dict:
'''Returns raw transaction representation for given transaction id.
decrypt can be set to 0(false) or 1(true).'''
q = 'getrawtransaction?txid={txid}&decrypt={decrypt}'.format(txid=txid, decrypt=decrypt)
return cast(dict, self.api_fetch(q))
<|code_end|>
with the help of current file imports:
from decimal import Decimal
from http.client import HTTPResponse
from typing import Union, cast
from urllib.request import urlopen
from btcpy.structs.transaction import ScriptSig, Sequence, TxIn
from pypeerassets.exceptions import InsufficientFunds, UnsupportedNetwork
from pypeerassets.provider.common import Provider
import json
and context from other files:
# Path: pypeerassets/exceptions.py
# class InsufficientFunds(Exception):
# '''this address does not have enough assigned UTXOs'''
#
# class UnsupportedNetwork(Exception):
# '''This network is not suppored by pypeerassets.'''
#
# Path: pypeerassets/provider/common.py
# class Provider(ABC):
#
# net = ""
#
# headers = {"User-Agent": "pypeerassets"}
#
# @staticmethod
# def _netname(name: str) -> dict:
# '''resolute network name,
# required because some providers use shortnames and other use longnames.'''
#
# try:
# long = net_query(name).name
# short = net_query(name).shortname
# except AttributeError:
# raise UnsupportedNetwork('''This blockchain network is not supported by the pypeerassets, check networks.py for list of supported networks.''')
#
# return {'long': long,
# 'short': short}
#
# @property
# def network(self) -> str:
# '''return network full name'''
#
# return self._netname(self.net)['long']
#
# @property
# def pa_parameters(self) -> PAParams:
# '''load network PeerAssets parameters.'''
#
# return param_query(self.network)
#
# @property
# def network_properties(self) -> Constants:
# '''network parameters [min_fee, denomination, ...]'''
#
# return net_query(self.network)
#
# @property
# def is_testnet(self) -> bool:
# """testnet or not?"""
#
# if "testnet" in self.network:
# return True
# else:
# return False
#
# @classmethod
# def sendrawtransaction(cls, rawtxn: str) -> str:
# '''sendrawtransaction remote API'''
#
# if cls.is_testnet:
# url = 'https://testnet-explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
# else:
# url = 'https://explorer.peercoin.net/api/sendrawtransaction?hex={0}'.format(rawtxn)
#
# resp = urllib.request.urlopen(url)
# return resp.read().decode('utf-8')
#
# @abstractmethod
# def getblockhash(self, blocknum: int) -> str:
# '''get blockhash using blocknum query'''
# raise NotImplementedError
#
# @abstractmethod
# def getblockcount(self) -> int:
# '''get block count'''
# raise NotImplementedError
#
# @abstractmethod
# def getblock(self, hash: str) -> dict:
# '''query block using <blockhash> as key.'''
# raise NotImplementedError
#
# @abstractmethod
# def getdifficulty(self) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getbalance(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def getreceivedbyaddress(self, address: str) -> Decimal:
# raise NotImplementedError
#
# @abstractmethod
# def listunspent(self, address: str) -> list:
# raise NotImplementedError
#
# @abstractmethod
# def select_inputs(self, address: str, amount: int) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def getrawtransaction(self, txid: str, decrypt: int=1) -> dict:
# raise NotImplementedError
#
# @abstractmethod
# def listtransactions(self, address: str) -> list:
# raise NotImplementedError
#
# def validateaddress(self, address: str) -> bool:
# "Returns True if the passed address is valid, False otherwise."
#
# try:
# Address.from_string(address, self.network_properties)
# except InvalidAddress:
# return False
#
# return True
, which may contain function names, class names, or code. Output only the next line. | def getnetworkghps(self) -> float: |
Given the code snippet: <|code_start|>
self.assertTrue(m.called_once)
self.assertExpectedAuthHeaders()
@mock.patch.object(
osprofiler.profiler._Profiler,
'get_base_id',
mock.MagicMock(return_value=PROFILER_TRACE_ID)
)
@mock.patch.object(
osprofiler.profiler._Profiler,
'get_id',
mock.MagicMock(return_value=PROFILER_TRACE_ID)
)
def test_get_request_options_with_profile_enabled(self):
m = self.requests_mock.get(EXPECTED_URL, text='text')
osprofiler.profiler.init(PROFILER_HMAC_KEY)
data = {'base_id': PROFILER_TRACE_ID, 'parent_id': PROFILER_TRACE_ID}
signed_data = osprofiler_utils.signed_pack(data, PROFILER_HMAC_KEY)
headers = {
'X-Trace-Info': signed_data[0],
'X-Trace-HMAC': signed_data[1]
}
self.client.get(API_URL)
self.assertTrue(m.called_once)
headers = self.assertExpectedAuthHeaders()
<|code_end|>
, generate the next line using the imports in this file:
import base64
import copy
import osprofiler.profiler
from unittest import mock
from urllib import parse as urlparse
from oslo_utils import uuidutils
from osprofiler import _utils as osprofiler_utils
from mistralclient.api import httpclient
from mistralclient.tests.unit import base
and context (functions, classes, or occasionally code) from other files:
# Path: mistralclient/api/httpclient.py
# AUTH_TOKEN = 'auth_token'
# SESSION = 'session'
# CACERT = 'cacert'
# CERT_FILE = 'cert'
# CERT_KEY = 'key'
# INSECURE = 'insecure'
# PROJECT_ID = 'project_id'
# USER_ID = 'user_id'
# REGION_NAME = 'region_name'
# TARGET_AUTH_TOKEN = 'target_auth_token'
# TARGET_SESSION = 'target_session'
# TARGET_AUTH_URI = 'target_auth_url'
# TARGET_PROJECT_ID = 'target_project_id'
# TARGET_USER_ID = 'target_user_id'
# TARGET_INSECURE = 'target_insecure'
# TARGET_SERVICE_CATALOG = 'target_service_catalog'
# TARGET_REGION_NAME = 'target_region_name'
# TARGET_USER_DOMAIN_NAME = 'target_user_domain_name'
# TARGET_PROJECT_DOMAIN_NAME = 'target_project_domain_name'
# LOG = logging.getLogger(__name__)
# def log_request(func):
# def decorator(self, *args, **kwargs):
# def __init__(self, base_url, **kwargs):
# def get(self, url, headers=None):
# def post(self, url, body, headers=None):
# def put(self, url, body, headers=None):
# def delete(self, url, headers=None):
# def _get_request_options(self, method, headers):
# def _update_headers(self, headers):
# class HTTPClient(object):
#
# Path: mistralclient/tests/unit/base.py
# class BaseClientTest(base.BaseTestCase):
# class BaseCommandTest(base.BaseTestCase):
# def setUp(self):
# def setUp(self):
# def call(self, command, app_args=(), prog_name=''):
. Output only the next line. | self.assertEqual(signed_data[0], headers['X-Trace-Info']) |
Continue the code snippet: <|code_start|> self.assertEqual(target_project_id, headers['X-Target-Project-Id'])
self.assertEqual(str(target_insecure), headers['X-Target-Insecure'])
self.assertEqual(target_region, headers['X-Target-Region-Name'])
self.assertEqual(target_user_domain_name,
headers['X-Target-User-Domain-Name'])
self.assertEqual(target_project_domain_name,
headers['X-Target-Project-Domain-Name'])
catalog = base64.b64encode(target_service_catalog.encode('utf-8'))
self.assertEqual(catalog, headers['X-Target-Service-Catalog'])
def test_get_request_options_with_headers_for_post(self):
m = self.requests_mock.post(EXPECTED_URL, text='text')
headers = {'foo': 'bar'}
self.client.post(API_URL, EXPECTED_BODY, headers=headers)
self.assertTrue(m.called_once)
headers = self.assertExpectedAuthHeaders()
self.assertEqual('application/json', headers['Content-Type'])
self.assertEqual('bar', headers['foo'])
self.assertExpectedBody()
def test_get_request_options_with_headers_for_put(self):
m = self.requests_mock.put(EXPECTED_URL, text='text')
headers = {'foo': 'bar'}
self.client.put(API_URL, EXPECTED_BODY, headers=headers)
self.assertTrue(m.called_once)
<|code_end|>
. Use current file imports:
import base64
import copy
import osprofiler.profiler
from unittest import mock
from urllib import parse as urlparse
from oslo_utils import uuidutils
from osprofiler import _utils as osprofiler_utils
from mistralclient.api import httpclient
from mistralclient.tests.unit import base
and context (classes, functions, or code) from other files:
# Path: mistralclient/api/httpclient.py
# AUTH_TOKEN = 'auth_token'
# SESSION = 'session'
# CACERT = 'cacert'
# CERT_FILE = 'cert'
# CERT_KEY = 'key'
# INSECURE = 'insecure'
# PROJECT_ID = 'project_id'
# USER_ID = 'user_id'
# REGION_NAME = 'region_name'
# TARGET_AUTH_TOKEN = 'target_auth_token'
# TARGET_SESSION = 'target_session'
# TARGET_AUTH_URI = 'target_auth_url'
# TARGET_PROJECT_ID = 'target_project_id'
# TARGET_USER_ID = 'target_user_id'
# TARGET_INSECURE = 'target_insecure'
# TARGET_SERVICE_CATALOG = 'target_service_catalog'
# TARGET_REGION_NAME = 'target_region_name'
# TARGET_USER_DOMAIN_NAME = 'target_user_domain_name'
# TARGET_PROJECT_DOMAIN_NAME = 'target_project_domain_name'
# LOG = logging.getLogger(__name__)
# def log_request(func):
# def decorator(self, *args, **kwargs):
# def __init__(self, base_url, **kwargs):
# def get(self, url, headers=None):
# def post(self, url, body, headers=None):
# def put(self, url, body, headers=None):
# def delete(self, url, headers=None):
# def _get_request_options(self, method, headers):
# def _update_headers(self, headers):
# class HTTPClient(object):
#
# Path: mistralclient/tests/unit/base.py
# class BaseClientTest(base.BaseTestCase):
# class BaseCommandTest(base.BaseTestCase):
# def setUp(self):
# def setUp(self):
# def call(self, command, app_args=(), prog_name=''):
. Output only the next line. | headers = self.assertExpectedAuthHeaders() |
Based on the snippet: <|code_start|> COLUMNS = [
('id', 'ID'),
('name', 'Name'),
('is_system', 'Is system'),
('input', 'Input'),
('description', 'Description'),
('tags', 'Tags'),
('created_at', 'Created at'),
('updated_at', 'Updated at'),
]
@staticmethod
def format(action=None, lister=False):
if action:
tags = getattr(action, 'tags', None) or []
input_ = action.input if not lister else base.cut(action.input)
desc = (action.description if not lister
else base.cut(action.description))
data = (
action.id,
action.name,
action.is_system,
input_,
desc,
base.wrap(', '.join(tags)) or '<none>',
action.created_at,
)
if hasattr(action, 'updated_at'):
data += (action.updated_at,)
<|code_end|>
, predict the immediate next line with the help of imports:
import argparse
from osc_lib.command import command
from mistralclient.commands.v2 import base
from mistralclient import utils
and context (classes, functions, sometimes code) from other files:
# Path: mistralclient/commands/v2/base.py
# DEFAULT_LIMIT = 100
# COLUMNS = []
# class MistralFormatter(metaclass=abc.ABCMeta):
# class MistralLister(command.Lister, metaclass=abc.ABCMeta):
# class MistralExecutionLister(MistralLister, metaclass=abc.ABCMeta):
# def fields(cls):
# def headings(cls):
# def format_list(cls, instance=None):
# def format(instance=None, lister=False):
# def _get_format_function(self):
# def get_parser(self, parsed_args):
# def _get_resources(self, parsed_args):
# def _validate_parsed_args(self, parsed_args):
# def take_action(self, parsed_args):
# def get_parser(self, parsed_args):
# def take_action(self, parsed_args):
# def cut(string, length=25):
# def wrap(string, width=25):
# def get_filters(parsed_args):
# def get_duration_str(start_dt_str, end_dt_str):
#
# Path: mistralclient/utils.py
# def do_action_on_many(action, resources, success_msg, error_msg):
# def load_content(content):
# def load_file(path):
# def get_contents_if_file(contents_or_file_name):
# def load_json(input_string):
. Output only the next line. | else: |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.