Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Given the following code snippet before the placeholder: <|code_start|># -*- coding: utf-8 -*-
pid = PID(resource_filename('peoplefinder', '.pid.file'))
JOB_STATUS = (
'downloading',
'ready',
)
START_STATUS = (
'started',
'already started',
)
STOP_STATUS = (
'stopped',
'not started',
)
@view_config(route_name='download_tiles_start', request_method='POST', renderer='json')
<|code_end|>
, predict the next line using imports from the current file:
import psutil
import subprocess
import threading
from pyramid.view import view_config
from pkg_resources import resource_filename
from psutil import (
STATUS_SLEEPING,
STATUS_RUNNING,
STATUS_ZOMBIE,
NoSuchProcess,
)
from .pid import PID
and context including class names, function names, and sometimes code from other files:
# Path: web/peoplefinder/views/pid.py
# class PID(object):
# def __init__(self, path):
# self.path = path
#
# def get_value(self):
# with open(self.path) as pid_file:
# try:
# value = int(pid_file.readline())
# except ValueError:
# return None
# return value
#
#
# def set_value(self, value):
# with open(self.path, 'w') as pid_file:
# pid_file.write('%s' % value)
#
#
# value = property(get_value, set_value)
. Output only the next line. | def download_tiles_start(request): |
Predict the next line after this snippet: <|code_start|>
def try_run_vty_client(self):
self.logger.info("Try to create connection to VTY!")
try:
self.vty_client_connection = telnetlib.Telnet(self.vty_host, self.vty_port, self.vty_readtimeout_secs)
except:
self.vty_client_connection = None
self.logger.error("Create VTY connection failed!")
return False
try:
self.vty_client_connection.read_until("OpenBSC>", self.vty_readtimeout_secs)
except:
self.vty_client_connection.close()
self.vty_client_connection = None
self.logger.error("Read VTY wellcome message failed!")
return False
self.logger.info("Connection to VTY is established!")
return True
def process_measure_worker(self):
self.logger.info("Process measurement thread START!")
while not self.time_to_shutdown_event.is_set():
meas = self.measure_model.get_measurement()
if meas is not None:
self.process_measure(meas)
else:
time.sleep(0.1)
<|code_end|>
using the current file's imports:
import os
import time
import Queue
import urllib
import socket
import datetime
import threading
import telnetlib
import transaction
import ConfigParser
import logging_utils
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
from sqlalchemy import func
from model.models import (
bind_session,
DBSession,
Measure,
Settings,
)
from model.hlr import (
bind_session as bind_hlr_session,
HLRDBSession,
Subscriber,
Sms,
create_sms
)
and any relevant context from other files:
# Path: model/models.py
# def bind_session(connection_string, echo=False):
# class Measure(Base):
# class Settings(Base):
#
# Path: model/hlr.py
# def bind_session(connection_string, echo=False):
# def user_data_decode(user_data, data_coding_scheme, ud_hdr_ind):
# def create_sms(src_addr, dest_addr, text, charset=None):
# class Subscriber(Base):
# class Sms(Base):
. Output only the next line. | self.logger.info("Process measurement thread FINISH!")
|
Given the following code snippet before the placeholder: <|code_start|> while not self.time_to_shutdown_event.is_set():
meas = self.measure_model.get_measurement()
if meas is not None:
self.process_measure(meas)
else:
time.sleep(0.1)
self.logger.info("Process measurement thread FINISH!")
def process_measure(self, meas):
self.logger.info("Process meas: IMSI {0}".format(meas['imsi']))
imsi = meas['imsi']
extensions = HLRDBSession.query(Subscriber.extension).filter(Subscriber.imsi == imsi).all()
if len(extensions) != 1:
self.logger.error("HLR struct ERROR imsi {0} not one".format(imsi))
return
extension = extensions[0][0]
last_measure = self.get_last_measure(imsi)
if last_measure is not None:
self.logger.info("IMSI already detected.")
last_measure_timestamp = time.mktime(last_measure.timestamp.timetuple())
if meas['time'] < last_measure_timestamp:
self.logger.info("Ignore measure because: measure is older then one in DB!")
return
<|code_end|>
, predict the next line using imports from the current file:
import os
import time
import Queue
import urllib
import socket
import datetime
import threading
import telnetlib
import transaction
import ConfigParser
import logging_utils
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
from sqlalchemy import func
from model.models import (
bind_session,
DBSession,
Measure,
Settings,
)
from model.hlr import (
bind_session as bind_hlr_session,
HLRDBSession,
Subscriber,
Sms,
create_sms
)
and context including class names, function names, and sometimes code from other files:
# Path: model/models.py
# def bind_session(connection_string, echo=False):
# class Measure(Base):
# class Settings(Base):
#
# Path: model/hlr.py
# def bind_session(connection_string, echo=False):
# def user_data_decode(user_data, data_coding_scheme, ud_hdr_ind):
# def create_sms(src_addr, dest_addr, text, charset=None):
# class Subscriber(Base):
# class Sms(Base):
. Output only the next line. | if ((meas['time'] - last_measure_timestamp) < self.measure_update_period) and (last_measure.timing_advance == meas['meas_rep']['L1_TA']):
|
Predict the next line after this snippet: <|code_start|> self.logger.info("Process measurement thread FINISH!")
def process_measure(self, meas):
self.logger.info("Process meas: IMSI {0}".format(meas['imsi']))
imsi = meas['imsi']
extensions = HLRDBSession.query(Subscriber.extension).filter(Subscriber.imsi == imsi).all()
if len(extensions) != 1:
self.logger.error("HLR struct ERROR imsi {0} not one".format(imsi))
return
extension = extensions[0][0]
last_measure = self.get_last_measure(imsi)
if last_measure is not None:
self.logger.info("IMSI already detected.")
last_measure_timestamp = time.mktime(last_measure.timestamp.timetuple())
if meas['time'] < last_measure_timestamp:
self.logger.info("Ignore measure because: measure is older then one in DB!")
return
if ((meas['time'] - last_measure_timestamp) < self.measure_update_period) and (last_measure.timing_advance == meas['meas_rep']['L1_TA']):
self.logger.info("Ignore measure because: TA is no different from the last mesaure done less then {0} seconds!".format(self.measure_update_period))
return
else:
self.logger.info("Detect new IMSI.")
<|code_end|>
using the current file's imports:
import os
import time
import Queue
import urllib
import socket
import datetime
import threading
import telnetlib
import transaction
import ConfigParser
import logging_utils
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
from sqlalchemy import func
from model.models import (
bind_session,
DBSession,
Measure,
Settings,
)
from model.hlr import (
bind_session as bind_hlr_session,
HLRDBSession,
Subscriber,
Sms,
create_sms
)
and any relevant context from other files:
# Path: model/models.py
# def bind_session(connection_string, echo=False):
# class Measure(Base):
# class Settings(Base):
#
# Path: model/hlr.py
# def bind_session(connection_string, echo=False):
# def user_data_decode(user_data, data_coding_scheme, ud_hdr_ind):
# def create_sms(src_addr, dest_addr, text, charset=None):
# class Subscriber(Base):
# class Sms(Base):
. Output only the next line. | welcome_msg = self.get_formated_welcome_message(ms_phone_number=extension)
|
Here is a snippet: <|code_start|> return None
return reply_message_res[0][0].format(**wargs)
def get_last_measure(self, imsi):
last_measures = DBSession.query(
Measure
).filter(
Measure.imsi == imsi
).order_by(
Measure.id.desc()
).limit(1).all()
if len(last_measures) == 0:
return None
return last_measures[0]
def save_measure_to_db(self, meas, extension):
self.logger.debug("Save measure to DB!")
distance = self.__calculate_distance(long(meas['meas_rep']['L1_TA']))
self.logger.debug("distance: {0}".format(distance))
with transaction.manager:
obj = Measure(imsi=meas['imsi'],
timestamp=datetime.datetime.fromtimestamp(meas['time']),
timing_advance=meas['meas_rep']['L1_TA'],
distance=distance,
phone_number=extension,
<|code_end|>
. Write the next line using the current file imports:
import os
import time
import Queue
import urllib
import socket
import datetime
import threading
import telnetlib
import transaction
import ConfigParser
import logging_utils
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
from sqlalchemy import func
from model.models import (
bind_session,
DBSession,
Measure,
Settings,
)
from model.hlr import (
bind_session as bind_hlr_session,
HLRDBSession,
Subscriber,
Sms,
create_sms
)
and context from other files:
# Path: model/models.py
# def bind_session(connection_string, echo=False):
# class Measure(Base):
# class Settings(Base):
#
# Path: model/hlr.py
# def bind_session(connection_string, echo=False):
# def user_data_decode(user_data, data_coding_scheme, ud_hdr_ind):
# def create_sms(src_addr, dest_addr, text, charset=None):
# class Subscriber(Base):
# class Sms(Base):
, which may include functions, classes, or code. Output only the next line. | gps_lat=meas['lat'],
|
Given the code snippet: <|code_start|>
return True
def stop_tracking(self):
self.__stop_trackin_event.set()
self.__tracking_process.join()
self.__prepare_imsi_process.join()
self.logger.info("Stop tracking!")
return True
def tracking_process(self):
while self.__stop_trackin_event.is_set() is False:
try:
imsi = self.__imis_reday_for_silent_sms_list.get_nowait()
if self.vty_send_silent_sms(imsi):
self.logger.info("Tracking. Send silent sms to IMSI %s!" % imsi)
else:
self.logger.error("Tracking. Silent sms to IMSI %s NOT SEND!" % imsi)
except Queue.Empty:
time.sleep(0.1)
def prepare_ready_for_silent_sms(self):
while self.__stop_trackin_event.is_set() is False:
sub_sms = HLRDBSession.query(
Subscriber.imsi,
Sms.dest_addr,
Sms.sent,
func.max(Sms.created)
).select_from(
<|code_end|>
, generate the next line using the imports in this file:
import os
import time
import Queue
import urllib
import socket
import datetime
import threading
import telnetlib
import transaction
import ConfigParser
import logging_utils
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
from sqlalchemy import func
from model.models import (
bind_session,
DBSession,
Measure,
Settings,
)
from model.hlr import (
bind_session as bind_hlr_session,
HLRDBSession,
Subscriber,
Sms,
create_sms
)
and context (functions, classes, or occasionally code) from other files:
# Path: model/models.py
# def bind_session(connection_string, echo=False):
# class Measure(Base):
# class Settings(Base):
#
# Path: model/hlr.py
# def bind_session(connection_string, echo=False):
# def user_data_decode(user_data, data_coding_scheme, ud_hdr_ind):
# def create_sms(src_addr, dest_addr, text, charset=None):
# class Subscriber(Base):
# class Sms(Base):
. Output only the next line. | Subscriber
|
Predict the next line after this snippet: <|code_start|>from __future__ import with_statement
__all__ = ["get_coqc_version", "get_coqtop_version", "get_coqc_help", "get_coqc_coqlib", "get_coq_accepts_top", "get_coq_accepts_time", "get_coq_accepts_o", "get_coq_accepts_compile", "get_coq_native_compiler_ondemand_fragment", "group_coq_args_split_recognized", "group_coq_args", "coq_makefile_supports_arg"]
@memoize
def get_coqc_version_helper(coqc):
p = subprocess.Popen([coqc, "-q", "-v"], stderr=subprocess.STDOUT, stdout=subprocess.PIPE, stdin=subprocess.PIPE)
(stdout, stderr) = p.communicate()
return util.normalize_newlines(util.s(stdout).replace('The Coq Proof Assistant, version ', '')).replace('\n', ' ').strip()
def get_coqc_version(coqc_prog, **kwargs):
kwargs['log']('Running command: "%s"' % '" "'.join([coqc_prog, "-q", "-v"]), level=2)
<|code_end|>
using the current file's imports:
import subprocess, tempfile, re
import util
from file_util import clean_v_file
from memoize import memoize
and any relevant context from other files:
# Path: file_util.py
# def clean_v_file(file_name):
# clean_extra_coq_files(file_name, extra_exts=('.v',))
#
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
. Output only the next line. | return get_coqc_version_helper(coqc_prog) |
Using the snippet: <|code_start|> clean_v_file(temp_file_name)
return any(v in util.s(stdout) for v in ('The native-compiler option is deprecated',
'Native compiler is disabled',
'native-compiler-disabled',
'deprecated-native-compiler-option'))
def get_coq_native_compiler_ondemand_fragment(coqc_prog, **kwargs):
help_lines = get_coqc_help(coqc_prog, **kwargs).split('\n')
if any('ondemand' in line for line in help_lines if line.strip().startswith('-native-compiler')):
if get_coq_accepts_w(coqc_prog, **kwargs):
return ('-w', '-deprecated-native-compiler-option,-native-compiler-disabled', '-native-compiler', 'ondemand')
elif not get_coqc_native_compiler_ondemand_errors(coqc_prog):
return ('-native-compiler', 'ondemand')
return tuple()
def get_coq_accepts_time(coqc_prog, **kwargs):
return '-time' in get_coqc_help(coqc_prog, **kwargs)
HELP_REG = re.compile(r'^ ([^\n]*?)(?:\t| )', re.MULTILINE)
HELP_MAKEFILE_REG = re.compile(r'^\[(-[^\n\]]*)\]', re.MULTILINE)
def all_help_tags(coqc_help, is_coq_makefile=False):
if is_coq_makefile:
return HELP_MAKEFILE_REG.findall(coqc_help)
else:
return HELP_REG.findall(coqc_help)
def get_single_help_tags(coqc_help, **kwargs):
return tuple(i for i in all_help_tags(coqc_help, **kwargs) if ' ' not in i)
<|code_end|>
, determine the next line of code. You have imports:
import subprocess, tempfile, re
import util
from file_util import clean_v_file
from memoize import memoize
and context (class names, function names, or code) available:
# Path: file_util.py
# def clean_v_file(file_name):
# clean_extra_coq_files(file_name, extra_exts=('.v',))
#
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
. Output only the next line. | def get_multiple_help_tags(coqc_help, **kwargs): |
Predict the next line for this snippet: <|code_start|>#!/usr/bin/env python2
SCRIPT_DIRECTORY = os.path.dirname(os.path.realpath(__file__))
parser = argparse.ArgumentParser(description='Absolutize the imports of Coq files')
parser.add_argument('input_files', metavar='INFILE', nargs='*', type=argparse.FileType('r'),
<|code_end|>
with the help of current file imports:
import shutil, os, os.path, sys
from argparse_compat import argparse
from import_util import get_file, sort_files_by_dependency, IMPORT_ABSOLUTIZE_TUPLE, ALL_ABSOLUTIZE_TUPLE
from custom_arguments import add_libname_arguments, update_env_with_libnames, add_logging_arguments, process_logging_arguments
from file_util import write_to_file
and context from other files:
# Path: argparse_compat.py
#
# Path: import_util.py
# def get_file(*args, **kwargs):
# return util.normalize_newlines(get_file_as_bytes(*args, **kwargs).decode('utf-8'))
#
# def sort_files_by_dependency(filenames, reverse=True, **kwargs):
# kwargs = fill_kwargs(kwargs)
# filenames = map(fix_path, filenames)
# filenames = [(filename + '.v' if filename[-2:] != '.v' else filename) for filename in filenames]
# libnames = [lib_of_filename(filename, **kwargs) for filename in filenames]
# requires = get_recursive_requires(*libnames, **kwargs)
#
# def fcmp(f1, f2):
# if f1 == f2: return cmp(f1, f2)
# l1, l2 = lib_of_filename(f1, **kwargs), lib_of_filename(f2, **kwargs)
# if l1 == l2: return cmp(f1, f2)
# # this only works correctly if the closure is *reflexive* as
# # well as transitive, because we require that if A requires B,
# # then A must have strictly more requires than B (i.e., it
# # must include itself)
# if len(requires[l1]) != len(requires[l2]): return cmp(len(requires[l1]), len(requires[l2]))
# return cmp(l1, l2)
#
# filenames = sorted(filenames, key=cmp_to_key(fcmp), reverse=reverse)
# return filenames
#
# IMPORT_ABSOLUTIZE_TUPLE = ('lib', 'mod')
#
# ALL_ABSOLUTIZE_TUPLE = ('lib', 'proj', 'rec', 'ind', 'constr', 'def', 'syndef', 'class', 'thm', 'lem', 'prf', 'ax', 'inst', 'prfax', 'coind', 'scheme', 'vardef', 'mod')# , 'modtype')
#
# Path: custom_arguments.py
# def add_libname_arguments(parser): add_libname_arguments_gen(parser, passing='')
#
# def update_env_with_libnames(env, args, default=(('.', 'Top'), ), include_passing=False, use_default=True, use_passing_default=True):
# all_keys = ('libnames', 'non_recursive_libnames', 'ocaml_dirnames', '_CoqProject', '_CoqProject_v_files', '_CoqProject_unknown')
# passing_opts = ('', ) if not include_passing else ('', 'passing_', 'nonpassing_')
# for passing in passing_opts:
# for key in all_keys:
# env[passing + key] = []
# if getattr(args, passing + 'CoqProjectFile'):
# for f in getattr(args, passing + 'CoqProjectFile'):
# env[passing + '_CoqProject'] = f.read()
# f.close()
# process_CoqProject(env, env[passing + '_CoqProject'], passing=passing)
# env[passing + 'libnames'].extend(getattr(args, passing + 'libnames'))
# env[passing + 'non_recursive_libnames'].extend(getattr(args, passing + 'non_recursive_libnames'))
# env[passing + 'ocaml_dirnames'].extend(getattr(args, passing + 'ocaml_dirnames'))
# if include_passing:
# # The nonpassing_ prefix is actually temporary; the semantics
# # are that, e.g., libnames = libnames + nonpassing_libnames,
# # while passing_libnames = libnames + passing_libnames
# for key in all_keys:
# env['passing_' + key] = env[key] + env['passing_' + key]
# env[key] = env[key] + env['nonpassing_' + key]
# del env['nonpassing_' + key]
# if use_default:
# update_env_with_libname_default(env, args, default=default)
# if use_passing_default and include_passing:
# update_env_with_libname_default(env, args, default=default, passing='passing_')
#
# def add_logging_arguments(parser):
# parser.add_argument('--verbose', '-v', dest='verbose',
# action='count',
# help='display some extra information by default (does not impact --verbose-log-file)')
# parser.add_argument('--quiet', '-q', dest='quiet',
# action='count',
# help='the inverse of --verbose')
# parser.add_argument('--log-file', '-l', dest='log_files', nargs='+', type=argparse.FileType('w'),
# default=[sys.stderr],
# help='The files to log output to. Use - for stdout.')
# parser.add_argument('--verbose-log-file', dest='verbose_log_files', nargs='+', type=TupleType(int, argparse.FileType('w')),
# default=[],
# help=(('The files to log output to at verbosity other than the default verbosity (%d if no -v/-q arguments are passed); ' +
# 'each argument should be a pair of a verbosity level and a file name. '
# 'Use - for stdout.') % DEFAULT_VERBOSITY))
#
# def process_logging_arguments(args):
# if args.verbose is None: args.verbose = DEFAULT_VERBOSITY
# if args.quiet is None: args.quiet = 0
# args.verbose -= args.quiet
# args.log = make_logger([(args.verbose, f) for f in args.log_files]
# + args.verbose_log_files)
# del args.quiet
# del args.verbose
# return args
#
# Path: file_util.py
# def write_to_file(file_name, contents, *args, **kwargs):
# return write_bytes_to_file(file_name, contents.replace('\n', os.linesep).encode('utf-8'), *args, **kwargs)
, which may contain function names, class names, or code. Output only the next line. | help='.v files to update') |
Predict the next line for this snippet: <|code_start|>
__all__ = ["join_definitions", "split_statements_to_definitions"]
def get_definitions_diff(previous_definition_string, new_definition_string):
"""Returns a triple of lists (definitions_removed,
definitions_shared, definitions_added)"""
old_definitions = [i for i in previous_definition_string.split('|') if i]
new_definitions = [i for i in new_definition_string.split('|') if i]
if all(i == 'branch' for i in old_definitions + new_definitions): # work
# around bug #5577 when all theorem names are "branch", we
# don't assume that names are unique, and instead go by
# ordering
removed = []
shared = []
added = []
for i in range(max((len(old_definitions), len(new_definitions)))):
<|code_end|>
with the help of current file imports:
import re, time
import split_definitions_old
import util
from subprocess import Popen, PIPE, STDOUT
from split_file import postprocess_split_proof_term
from coq_version import get_coq_accepts_time
from coq_running_support import get_proof_term_works_with_time
from custom_arguments import DEFAULT_LOG, LOG_ALWAYS
and context from other files:
# Path: split_file.py
# def postprocess_split_proof_term(statements, do_warn=True, **kwargs):
# def do_warn_method(statement_num, statement, proof_term):
# kwargs['log']("""Warning: Your version of Coq suffers from bug #5349 (https://coq.inria.fr/bugs/show_bug.cgi?id=5349)
# and does not support [Proof (term).] with -time. Falling back to
# replacing [Proof (term).] with [Proof. exact (term). Qed.], which may fail.""")
# if do_warn and 'log' in kwargs.keys():
# do_warn = do_warn_method
# else:
# do_warn = None
# return list(postprocess_split_proof_term_iter(statements, do_warn))
#
# Path: coq_version.py
# def get_coq_accepts_time(coqc_prog, **kwargs):
# return get_coq_accepts_option(coqc_prog, '-time', **kwargs)
#
# Path: coq_running_support.py
# def get_proof_term_works_with_time(coqc_prog, **kwargs):
# contents = r"""Lemma foo : forall _ : Type, Type.
# Proof (fun x => x)."""
# output, cmds, retcode, runtime = get_coq_output(coqc_prog, ('-time', '-q'), contents, 1, verbose_base=3, **kwargs)
# return 'Error: Attempt to save an incomplete proof' not in output
#
# Path: custom_arguments.py
# DEFAULT_LOG = make_logger([(DEFAULT_VERBOSITY, sys.stderr)])
#
# LOG_ALWAYS=None
, which may contain function names, class names, or code. Output only the next line. | if i < len(old_definitions) and i < len(new_definitions): |
Here is a snippet: <|code_start|> if char_end <= last_char_end: continue
match = prompt_reg.match(full_response_text)
if not match:
log('Warning: Could not find statements in %d:%d: %s' % (char_start, char_end, full_response_text), level=LOG_ALWAYS)
continue
response_text, cur_name, line_num1, cur_definition_names, line_num2, unknown = match.groups()
statement = strip_newlines(statements_bytes[last_char_end:char_end].decode('utf-8'))
last_char_end = char_end
terms_defined = defined_reg.findall(response_text.strip())
definitions_removed, definitions_shared, definitions_added = get_definitions_diff(last_definitions, cur_definition_names)
# first, to be on the safe side, we add the new
# definitions key to the dict, if it wasn't already there.
if cur_definition_names.strip('|') and cur_definition_names not in cur_definition:
cur_definition[cur_definition_names] = {'statements':[], 'terms_defined':[]}
log((statement, (char_start, char_end), definitions_removed, terms_defined, 'last_definitions:', last_definitions, 'cur_definition_names:', cur_definition_names, cur_definition.get(last_definitions, []), cur_definition.get(cur_definition_names, []), response_text), level=2)
# first, we handle the case where we have just finished
# defining something. This should correspond to
# len(definitions_removed) > 0 and len(terms_defined) > 0.
# If only len(definitions_removed) > 0, then we have
# aborted something (or we're in Coq >= 8.11; see
# https://github.com/coq/coq/issues/15201). If only
# len(terms_defined) > 0, then we have defined something
# with a one-liner.
<|code_end|>
. Write the next line using the current file imports:
import re, time
import split_definitions_old
import util
from subprocess import Popen, PIPE, STDOUT
from split_file import postprocess_split_proof_term
from coq_version import get_coq_accepts_time
from coq_running_support import get_proof_term_works_with_time
from custom_arguments import DEFAULT_LOG, LOG_ALWAYS
and context from other files:
# Path: split_file.py
# def postprocess_split_proof_term(statements, do_warn=True, **kwargs):
# def do_warn_method(statement_num, statement, proof_term):
# kwargs['log']("""Warning: Your version of Coq suffers from bug #5349 (https://coq.inria.fr/bugs/show_bug.cgi?id=5349)
# and does not support [Proof (term).] with -time. Falling back to
# replacing [Proof (term).] with [Proof. exact (term). Qed.], which may fail.""")
# if do_warn and 'log' in kwargs.keys():
# do_warn = do_warn_method
# else:
# do_warn = None
# return list(postprocess_split_proof_term_iter(statements, do_warn))
#
# Path: coq_version.py
# def get_coq_accepts_time(coqc_prog, **kwargs):
# return get_coq_accepts_option(coqc_prog, '-time', **kwargs)
#
# Path: coq_running_support.py
# def get_proof_term_works_with_time(coqc_prog, **kwargs):
# contents = r"""Lemma foo : forall _ : Type, Type.
# Proof (fun x => x)."""
# output, cmds, retcode, runtime = get_coq_output(coqc_prog, ('-time', '-q'), contents, 1, verbose_base=3, **kwargs)
# return 'Error: Attempt to save an incomplete proof' not in output
#
# Path: custom_arguments.py
# DEFAULT_LOG = make_logger([(DEFAULT_VERBOSITY, sys.stderr)])
#
# LOG_ALWAYS=None
, which may include functions, classes, or code. Output only the next line. | if definitions_removed: |
Using the snippet: <|code_start|> if not get_coq_accepts_time(coqtop, log=log):
return fallback()
if not get_proof_term_works_with_time(coqtop, is_coqtop=True, log=log, **kwargs):
statements = postprocess_split_proof_term(statements, log=log, **kwargs)
p = Popen([coqtop, '-q', '-emacs', '-time'] + list(coqtop_args), stdout=PIPE, stderr=STDOUT, stdin=PIPE)
chars_time_reg = re.compile(r'Chars ([0-9]+) - ([0-9]+) [^\s]+'.replace(' ', r'\s*'))
prompt_reg = re.compile(r'^(.*)<prompt>([^<]*?) < ([0-9]+) ([^<]*?) ([0-9]+) < ([^<]*)$'.replace(' ', r'\s*'),
flags=re.DOTALL)
defined_reg = re.compile(r'^(?:<infomsg>)?([^\s]+) is (?:defined|assumed|declared)(?:</infomsg>)?$', re.MULTILINE)
# goals and definitions are on stdout, prompts are on stderr
statements_string = '\n'.join(statements) + '\n\n'
statements_bytes = statements_string.encode('utf-8')
log('Sending statements to coqtop...')
log(statements_string, level=3)
(stdout, stderr) = p.communicate(input=statements_bytes)
stdout = util.s(stdout)
if 'know what to do with -time' in stdout.strip().split('\n')[0]:
# we're using a version of coqtop that doesn't support -time
return fallback()
log('Done. Splitting to definitions...')
rtn = []
cur_definition = {}
last_definitions = '||'
cur_definition_names = '||'
last_char_end = 0
#log('re.findall(' + repr(r'Chars ([0-9]+) - ([0-9]+) [^\s]+ (.*?)<prompt>([^<]*?) < ([0-9]+) ([^<]*?) ([0-9]+) < ([^<]*?)</prompt>'.replace(' ', r'\s*')) + ', ' + repr(stdout) + ', ' + 'flags=re.DOTALL)', level=3)
for i, prompt in enumerate(stdout.split('</prompt>')):
log('Processing:\n%s' % prompt, level=4)
<|code_end|>
, determine the next line of code. You have imports:
import re, time
import split_definitions_old
import util
from subprocess import Popen, PIPE, STDOUT
from split_file import postprocess_split_proof_term
from coq_version import get_coq_accepts_time
from coq_running_support import get_proof_term_works_with_time
from custom_arguments import DEFAULT_LOG, LOG_ALWAYS
and context (class names, function names, or code) available:
# Path: split_file.py
# def postprocess_split_proof_term(statements, do_warn=True, **kwargs):
# def do_warn_method(statement_num, statement, proof_term):
# kwargs['log']("""Warning: Your version of Coq suffers from bug #5349 (https://coq.inria.fr/bugs/show_bug.cgi?id=5349)
# and does not support [Proof (term).] with -time. Falling back to
# replacing [Proof (term).] with [Proof. exact (term). Qed.], which may fail.""")
# if do_warn and 'log' in kwargs.keys():
# do_warn = do_warn_method
# else:
# do_warn = None
# return list(postprocess_split_proof_term_iter(statements, do_warn))
#
# Path: coq_version.py
# def get_coq_accepts_time(coqc_prog, **kwargs):
# return get_coq_accepts_option(coqc_prog, '-time', **kwargs)
#
# Path: coq_running_support.py
# def get_proof_term_works_with_time(coqc_prog, **kwargs):
# contents = r"""Lemma foo : forall _ : Type, Type.
# Proof (fun x => x)."""
# output, cmds, retcode, runtime = get_coq_output(coqc_prog, ('-time', '-q'), contents, 1, verbose_base=3, **kwargs)
# return 'Error: Attempt to save an incomplete proof' not in output
#
# Path: custom_arguments.py
# DEFAULT_LOG = make_logger([(DEFAULT_VERBOSITY, sys.stderr)])
#
# LOG_ALWAYS=None
. Output only the next line. | if prompt.strip() == '': continue |
Predict the next line for this snippet: <|code_start|> definitions_removed, definitions_shared, definitions_added = get_definitions_diff(last_definitions, cur_definition_names)
# first, to be on the safe side, we add the new
# definitions key to the dict, if it wasn't already there.
if cur_definition_names.strip('|') and cur_definition_names not in cur_definition:
cur_definition[cur_definition_names] = {'statements':[], 'terms_defined':[]}
log((statement, (char_start, char_end), definitions_removed, terms_defined, 'last_definitions:', last_definitions, 'cur_definition_names:', cur_definition_names, cur_definition.get(last_definitions, []), cur_definition.get(cur_definition_names, []), response_text), level=2)
# first, we handle the case where we have just finished
# defining something. This should correspond to
# len(definitions_removed) > 0 and len(terms_defined) > 0.
# If only len(definitions_removed) > 0, then we have
# aborted something (or we're in Coq >= 8.11; see
# https://github.com/coq/coq/issues/15201). If only
# len(terms_defined) > 0, then we have defined something
# with a one-liner.
if definitions_removed:
cur_definition[last_definitions]['statements'].append(statement)
cur_definition[last_definitions]['terms_defined'] += terms_defined
if cur_definition_names.strip('|'):
# we are still inside a definition. For now, we
# flatten all definitions.
#
# TODO(jgross): Come up with a better story for
# nested definitions.
cur_definition[cur_definition_names]['statements'] += cur_definition[last_definitions]['statements']
cur_definition[cur_definition_names]['terms_defined'] += cur_definition[last_definitions]['terms_defined']
<|code_end|>
with the help of current file imports:
import re, time
import split_definitions_old
import util
from subprocess import Popen, PIPE, STDOUT
from split_file import postprocess_split_proof_term
from coq_version import get_coq_accepts_time
from coq_running_support import get_proof_term_works_with_time
from custom_arguments import DEFAULT_LOG, LOG_ALWAYS
and context from other files:
# Path: split_file.py
# def postprocess_split_proof_term(statements, do_warn=True, **kwargs):
# def do_warn_method(statement_num, statement, proof_term):
# kwargs['log']("""Warning: Your version of Coq suffers from bug #5349 (https://coq.inria.fr/bugs/show_bug.cgi?id=5349)
# and does not support [Proof (term).] with -time. Falling back to
# replacing [Proof (term).] with [Proof. exact (term). Qed.], which may fail.""")
# if do_warn and 'log' in kwargs.keys():
# do_warn = do_warn_method
# else:
# do_warn = None
# return list(postprocess_split_proof_term_iter(statements, do_warn))
#
# Path: coq_version.py
# def get_coq_accepts_time(coqc_prog, **kwargs):
# return get_coq_accepts_option(coqc_prog, '-time', **kwargs)
#
# Path: coq_running_support.py
# def get_proof_term_works_with_time(coqc_prog, **kwargs):
# contents = r"""Lemma foo : forall _ : Type, Type.
# Proof (fun x => x)."""
# output, cmds, retcode, runtime = get_coq_output(coqc_prog, ('-time', '-q'), contents, 1, verbose_base=3, **kwargs)
# return 'Error: Attempt to save an incomplete proof' not in output
#
# Path: custom_arguments.py
# DEFAULT_LOG = make_logger([(DEFAULT_VERBOSITY, sys.stderr)])
#
# LOG_ALWAYS=None
, which may contain function names, class names, or code. Output only the next line. | del cur_definition[last_definitions] |
Given the following code snippet before the placeholder: <|code_start|>from __future__ import print_function
__all__ = ["add_libname_arguments", "add_passing_libname_arguments", "ArgumentParser", "update_env_with_libnames", "add_logging_arguments", "process_logging_arguments", "update_env_with_coqpath_folders", "DEFAULT_LOG", "DEFAULT_VERBOSITY", "LOG_ALWAYS"]
# grumble, grumble, we want to support multiple -R arguments like coqc
class CoqLibnameAction(argparse.Action):
non_default = False
# def __init__(self, *args, **kwargs):
# super(CoqLibnameAction, self).__init__(*args, **kwargs)
def __call__(self, parser, namespace, values, option_string=None):
# print('%r %r %r' % (namespace, values, option_string))
if not self.non_default:
setattr(namespace, self.dest, [])
self.non_default = True
<|code_end|>
, predict the next line using imports from the current file:
import sys, os
from argparse_compat import argparse
from util import PY3
and context including class names, function names, and sometimes code from other files:
# Path: argparse_compat.py
#
# Path: util.py
# PY3 = False
. Output only the next line. | getattr(namespace, self.dest).append(tuple(values)) |
Given the code snippet: <|code_start|>from __future__ import print_function
__all__ = ["add_libname_arguments", "add_passing_libname_arguments", "ArgumentParser", "update_env_with_libnames", "add_logging_arguments", "process_logging_arguments", "update_env_with_coqpath_folders", "DEFAULT_LOG", "DEFAULT_VERBOSITY", "LOG_ALWAYS"]
# grumble, grumble, we want to support multiple -R arguments like coqc
class CoqLibnameAction(argparse.Action):
non_default = False
# def __init__(self, *args, **kwargs):
# super(CoqLibnameAction, self).__init__(*args, **kwargs)
def __call__(self, parser, namespace, values, option_string=None):
# print('%r %r %r' % (namespace, values, option_string))
if not self.non_default:
setattr(namespace, self.dest, [])
self.non_default = True
getattr(namespace, self.dest).append(tuple(values))
DEFAULT_VERBOSITY=1
LOG_ALWAYS=None
def make_logger(log_files):
# log if level <= the level of the logger
def log(text, level=DEFAULT_VERBOSITY, max_level=None, force_stdout=False, force_stderr=False, end='\n'):
selected_log_files = [f for flevel, f in log_files if level is LOG_ALWAYS or (level <= flevel and (max_level is None or flevel < max_level))]
for i in selected_log_files:
if force_stderr and i.fileno() == 1 and not force_stdout: continue # skip stdout if we write to stderr
if force_stdout and i.fileno() == 2 and not force_stderr: continue # skip stderr if we write to stdout
i.write(str(text) + end)
i.flush()
if i.fileno() > 2: # stderr
os.fsync(i.fileno())
<|code_end|>
, generate the next line using the imports in this file:
import sys, os
from argparse_compat import argparse
from util import PY3
and context (functions, classes, or occasionally code) from other files:
# Path: argparse_compat.py
#
# Path: util.py
# PY3 = False
. Output only the next line. | for (force, fno, sys_file) in ((force_stdout, 1, sys.stdout), (force_stderr, 2, sys.stderr)): |
Given the following code snippet before the placeholder: <|code_start|>from __future__ import with_statement, print_function
__all__ = ["include_imports", "normalize_requires", "get_required_contents", "recursively_get_requires_from_file", "absolutize_and_mangle_libname"]
file_contents = {}
lib_imports_fast = {}
lib_imports_slow = {}
<|code_end|>
, predict the next line using imports from the current file:
import os, subprocess, re, sys, glob, os.path
import doctest
from memoize import memoize
from split_file import split_leading_comments_and_whitespace
from import_util import filename_of_lib, lib_of_filename, get_file, run_recursively_get_imports, recursively_get_imports, absolutize_has_all_constants, is_local_import, ALL_ABSOLUTIZE_TUPLE, IMPORT_ABSOLUTIZE_TUPLE
from custom_arguments import DEFAULT_LOG
and context including class names, function names, and sometimes code from other files:
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
#
# Path: split_file.py
# def split_leading_comments_and_whitespace(text):
# comment_level = 0
# in_str = False
# skip = False
# for i, (ch, next_ch) in enumerate(zip(text, text[1:] + '\0')):
# if skip:
# skip = False
# elif in_str:
# if ch in '"': in_str = False
# elif ch == '(' and next_ch == '*':
# comment_level += 1
# skip = True
# elif ch == '*' and next_ch == ')':
# comment_level -= 1
# skip = True
# elif comment_level > 0:
# if ch in '"': in_str = True
# elif ch.isspace():
# pass
# else:
# return text[:i], text[i:]
# return text, ''
#
# Path: import_util.py
# def filename_of_lib(lib, ext='.v', **kwargs):
# kwargs = fill_kwargs(kwargs)
# return filename_of_lib_helper(lib, libnames=tuple(kwargs['libnames']), non_recursive_libnames=tuple(kwargs['non_recursive_libnames']), ext=ext)
#
# def lib_of_filename(filename, exts=('.v', '.glob'), **kwargs):
# kwargs = fill_kwargs(kwargs)
# filename, libname = lib_of_filename_helper(filename, libnames=tuple(kwargs['libnames']), non_recursive_libnames=tuple(kwargs['non_recursive_libnames']), exts=exts)
# # if '.' in filename:
# # # TODO: Do we still need this warning?
# # kwargs['log']("WARNING: There is a dot (.) in filename %s; the library conversion probably won't work." % filename)
# return libname
#
# def get_file(*args, **kwargs):
# return util.normalize_newlines(get_file_as_bytes(*args, **kwargs).decode('utf-8'))
#
# def run_recursively_get_imports(lib, recur=recursively_get_imports, fast=False, **kwargs):
# kwargs = fill_kwargs(kwargs)
# lib = norm_libname(lib, **kwargs)
# glob_name = filename_of_lib(lib, ext='.glob', **kwargs)
# v_name = filename_of_lib(lib, ext='.v', **kwargs)
# if os.path.isfile(v_name):
# imports = get_imports(lib, fast=fast, **kwargs)
# if kwargs['inline_coqlib'] and 'Coq.Init.Prelude' not in imports:
# mykwargs = dict(kwargs)
# coqlib_libname = (os.path.join(kwargs['inline_coqlib'], 'theories'), 'Coq')
# if coqlib_libname not in mykwargs['libnames']:
# mykwargs['libnames'] = tuple(list(kwargs['libnames']) + [coqlib_libname])
# try:
# coqlib_imports = get_imports('Coq.Init.Prelude', fast=fast, **mykwargs)
# if imports and not any(i in imports for i in coqlib_imports):
# imports = tuple(list(coqlib_imports) + list(imports))
# except IOError as e:
# kwargs['log']("WARNING: --inline-coqlib passed, but no Coq.Init.Prelude found on disk.\n Searched in %s\n (Error was: %s)\n\n" % (repr(mykwargs['libnames']), repr(e)), level=LOG_ALWAYS)
# if not fast: make_globs(imports, **kwargs)
# imports_list = [recur(k, fast=fast, **kwargs) for k in imports]
# return merge_imports(tuple(map(tuple, imports_list + [[lib]])), **kwargs)
# return [lib]
#
# def recursively_get_imports(lib, **kwargs):
# return internal_recursively_get_imports(lib, **safe_kwargs(kwargs))
#
# def absolutize_has_all_constants(absolutize_tuple):
# '''Returns True if absolutizing the types of things mentioned by the tuple is enough to ensure that we only use absolute names'''
# return set(ALL_ABSOLUTIZE_TUPLE).issubset(set(absolutize_tuple))
#
# def is_local_import(libname, **kwargs):
# '''Returns True if libname is an import to a local file that we can discover and include, and False otherwise'''
# return os.path.isfile(filename_of_lib(libname, **kwargs))
#
# ALL_ABSOLUTIZE_TUPLE = ('lib', 'proj', 'rec', 'ind', 'constr', 'def', 'syndef', 'class', 'thm', 'lem', 'prf', 'ax', 'inst', 'prfax', 'coind', 'scheme', 'vardef', 'mod')# , 'modtype')
#
# IMPORT_ABSOLUTIZE_TUPLE = ('lib', 'mod')
#
# Path: custom_arguments.py
# DEFAULT_LOG = make_logger([(DEFAULT_VERBOSITY, sys.stderr)])
. Output only the next line. | DEFAULT_LIBNAMES=(('.', 'Top'), ) |
Using the snippet: <|code_start|>from __future__ import with_statement, print_function
__all__ = ["include_imports", "normalize_requires", "get_required_contents", "recursively_get_requires_from_file", "absolutize_and_mangle_libname"]
file_contents = {}
<|code_end|>
, determine the next line of code. You have imports:
import os, subprocess, re, sys, glob, os.path
import doctest
from memoize import memoize
from split_file import split_leading_comments_and_whitespace
from import_util import filename_of_lib, lib_of_filename, get_file, run_recursively_get_imports, recursively_get_imports, absolutize_has_all_constants, is_local_import, ALL_ABSOLUTIZE_TUPLE, IMPORT_ABSOLUTIZE_TUPLE
from custom_arguments import DEFAULT_LOG
and context (class names, function names, or code) available:
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
#
# Path: split_file.py
# def split_leading_comments_and_whitespace(text):
# comment_level = 0
# in_str = False
# skip = False
# for i, (ch, next_ch) in enumerate(zip(text, text[1:] + '\0')):
# if skip:
# skip = False
# elif in_str:
# if ch in '"': in_str = False
# elif ch == '(' and next_ch == '*':
# comment_level += 1
# skip = True
# elif ch == '*' and next_ch == ')':
# comment_level -= 1
# skip = True
# elif comment_level > 0:
# if ch in '"': in_str = True
# elif ch.isspace():
# pass
# else:
# return text[:i], text[i:]
# return text, ''
#
# Path: import_util.py
# def filename_of_lib(lib, ext='.v', **kwargs):
# kwargs = fill_kwargs(kwargs)
# return filename_of_lib_helper(lib, libnames=tuple(kwargs['libnames']), non_recursive_libnames=tuple(kwargs['non_recursive_libnames']), ext=ext)
#
# def lib_of_filename(filename, exts=('.v', '.glob'), **kwargs):
# kwargs = fill_kwargs(kwargs)
# filename, libname = lib_of_filename_helper(filename, libnames=tuple(kwargs['libnames']), non_recursive_libnames=tuple(kwargs['non_recursive_libnames']), exts=exts)
# # if '.' in filename:
# # # TODO: Do we still need this warning?
# # kwargs['log']("WARNING: There is a dot (.) in filename %s; the library conversion probably won't work." % filename)
# return libname
#
# def get_file(*args, **kwargs):
# return util.normalize_newlines(get_file_as_bytes(*args, **kwargs).decode('utf-8'))
#
# def run_recursively_get_imports(lib, recur=recursively_get_imports, fast=False, **kwargs):
# kwargs = fill_kwargs(kwargs)
# lib = norm_libname(lib, **kwargs)
# glob_name = filename_of_lib(lib, ext='.glob', **kwargs)
# v_name = filename_of_lib(lib, ext='.v', **kwargs)
# if os.path.isfile(v_name):
# imports = get_imports(lib, fast=fast, **kwargs)
# if kwargs['inline_coqlib'] and 'Coq.Init.Prelude' not in imports:
# mykwargs = dict(kwargs)
# coqlib_libname = (os.path.join(kwargs['inline_coqlib'], 'theories'), 'Coq')
# if coqlib_libname not in mykwargs['libnames']:
# mykwargs['libnames'] = tuple(list(kwargs['libnames']) + [coqlib_libname])
# try:
# coqlib_imports = get_imports('Coq.Init.Prelude', fast=fast, **mykwargs)
# if imports and not any(i in imports for i in coqlib_imports):
# imports = tuple(list(coqlib_imports) + list(imports))
# except IOError as e:
# kwargs['log']("WARNING: --inline-coqlib passed, but no Coq.Init.Prelude found on disk.\n Searched in %s\n (Error was: %s)\n\n" % (repr(mykwargs['libnames']), repr(e)), level=LOG_ALWAYS)
# if not fast: make_globs(imports, **kwargs)
# imports_list = [recur(k, fast=fast, **kwargs) for k in imports]
# return merge_imports(tuple(map(tuple, imports_list + [[lib]])), **kwargs)
# return [lib]
#
# def recursively_get_imports(lib, **kwargs):
# return internal_recursively_get_imports(lib, **safe_kwargs(kwargs))
#
# def absolutize_has_all_constants(absolutize_tuple):
# '''Returns True if absolutizing the types of things mentioned by the tuple is enough to ensure that we only use absolute names'''
# return set(ALL_ABSOLUTIZE_TUPLE).issubset(set(absolutize_tuple))
#
# def is_local_import(libname, **kwargs):
# '''Returns True if libname is an import to a local file that we can discover and include, and False otherwise'''
# return os.path.isfile(filename_of_lib(libname, **kwargs))
#
# ALL_ABSOLUTIZE_TUPLE = ('lib', 'proj', 'rec', 'ind', 'constr', 'def', 'syndef', 'class', 'thm', 'lem', 'prf', 'ax', 'inst', 'prfax', 'coind', 'scheme', 'vardef', 'mod')# , 'modtype')
#
# IMPORT_ABSOLUTIZE_TUPLE = ('lib', 'mod')
#
# Path: custom_arguments.py
# DEFAULT_LOG = make_logger([(DEFAULT_VERBOSITY, sys.stderr)])
. Output only the next line. | lib_imports_fast = {} |
Given the code snippet: <|code_start|> i += 1
elif stack[-1] == STRING:
if term[i] == '"':
stack.pop()
i += 1
elif stack[-1] == COMMENT:
if term[i:i+2] == '(*':
stack.extend(COMMENT)
i += 2
elif term[i:i+2] == '*)':
stack.pop()
i += 2
elif term[i] == '"':
stack.extend(STRING)
i += 1
else:
i += 1
else: # len(stack) == 0
assert(False)
return len(term) - 1
def update_proof(name, before_match, match, after_match, filename, rest_id, suggestion, **env):
ending = re.search(ALL_ENDINGS, after_match, re.MULTILINE)
if ending:
proof_part = after_match[:ending.start()]
env['log']('Inspecting proof: %s' % proof_part, level=2)
if proof_part.count('Proof') == 1:
proof_match = re.search('Proof(?: using[^\.]*)?\.', proof_part)
if proof_match:
if proof_match.group() == suggestion:
<|code_end|>
, generate the next line using the imports in this file:
import os, sys, re
from argparse_compat import argparse
from custom_arguments import add_libname_arguments, update_env_with_libnames, add_logging_arguments, process_logging_arguments, LOG_ALWAYS
from memoize import memoize
from file_util import read_from_file, write_to_file
and context (functions, classes, or occasionally code) from other files:
# Path: argparse_compat.py
#
# Path: custom_arguments.py
# def add_libname_arguments(parser): add_libname_arguments_gen(parser, passing='')
#
# def update_env_with_libnames(env, args, default=(('.', 'Top'), ), include_passing=False, use_default=True, use_passing_default=True):
# all_keys = ('libnames', 'non_recursive_libnames', 'ocaml_dirnames', '_CoqProject', '_CoqProject_v_files', '_CoqProject_unknown')
# passing_opts = ('', ) if not include_passing else ('', 'passing_', 'nonpassing_')
# for passing in passing_opts:
# for key in all_keys:
# env[passing + key] = []
# if getattr(args, passing + 'CoqProjectFile'):
# for f in getattr(args, passing + 'CoqProjectFile'):
# env[passing + '_CoqProject'] = f.read()
# f.close()
# process_CoqProject(env, env[passing + '_CoqProject'], passing=passing)
# env[passing + 'libnames'].extend(getattr(args, passing + 'libnames'))
# env[passing + 'non_recursive_libnames'].extend(getattr(args, passing + 'non_recursive_libnames'))
# env[passing + 'ocaml_dirnames'].extend(getattr(args, passing + 'ocaml_dirnames'))
# if include_passing:
# # The nonpassing_ prefix is actually temporary; the semantics
# # are that, e.g., libnames = libnames + nonpassing_libnames,
# # while passing_libnames = libnames + passing_libnames
# for key in all_keys:
# env['passing_' + key] = env[key] + env['passing_' + key]
# env[key] = env[key] + env['nonpassing_' + key]
# del env['nonpassing_' + key]
# if use_default:
# update_env_with_libname_default(env, args, default=default)
# if use_passing_default and include_passing:
# update_env_with_libname_default(env, args, default=default, passing='passing_')
#
# def add_logging_arguments(parser):
# parser.add_argument('--verbose', '-v', dest='verbose',
# action='count',
# help='display some extra information by default (does not impact --verbose-log-file)')
# parser.add_argument('--quiet', '-q', dest='quiet',
# action='count',
# help='the inverse of --verbose')
# parser.add_argument('--log-file', '-l', dest='log_files', nargs='+', type=argparse.FileType('w'),
# default=[sys.stderr],
# help='The files to log output to. Use - for stdout.')
# parser.add_argument('--verbose-log-file', dest='verbose_log_files', nargs='+', type=TupleType(int, argparse.FileType('w')),
# default=[],
# help=(('The files to log output to at verbosity other than the default verbosity (%d if no -v/-q arguments are passed); ' +
# 'each argument should be a pair of a verbosity level and a file name. '
# 'Use - for stdout.') % DEFAULT_VERBOSITY))
#
# def process_logging_arguments(args):
# if args.verbose is None: args.verbose = DEFAULT_VERBOSITY
# if args.quiet is None: args.quiet = 0
# args.verbose -= args.quiet
# args.log = make_logger([(args.verbose, f) for f in args.log_files]
# + args.verbose_log_files)
# del args.quiet
# del args.verbose
# return args
#
# LOG_ALWAYS=None
#
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
#
# Path: file_util.py
# def read_from_file(file_name):
# return util.normalize_newlines(read_bytes_from_file(file_name).decode('utf-8'))
#
# def write_to_file(file_name, contents, *args, **kwargs):
# return write_bytes_to_file(file_name, contents.replace('\n', os.linesep).encode('utf-8'), *args, **kwargs)
. Output only the next line. | return FOUND_BUT_UNCHANGED # already correct |
Based on the snippet: <|code_start|>COMMENT='comment'
STRING='string'
def get_end_of_first_line_location(term, **env):
stack = []
i = 0
while i < len(term):
env['log']('DEBUG: stack: %s, pre: %s' % (str(stack), repr(term[:i])), level=3)
if len(stack) == 0:
if term[i] == '.' and (len(term) == i + 1 or (term[i+1] in ' \t\r\n')):
return i+1
if term[i] == '.':
while i < len(term) and term[i] == '.':
i += 1
else:
i += 1
elif stack[-1] == STRING:
if term[i] == '"':
stack.pop()
i += 1
elif stack[-1] == COMMENT:
if term[i:i+2] == '(*':
stack.extend(COMMENT)
i += 2
elif term[i:i+2] == '*)':
stack.pop()
i += 2
elif term[i] == '"':
stack.extend(STRING)
i += 1
else:
<|code_end|>
, predict the immediate next line with the help of imports:
import os, sys, re
from argparse_compat import argparse
from custom_arguments import add_libname_arguments, update_env_with_libnames, add_logging_arguments, process_logging_arguments, LOG_ALWAYS
from memoize import memoize
from file_util import read_from_file, write_to_file
and context (classes, functions, sometimes code) from other files:
# Path: argparse_compat.py
#
# Path: custom_arguments.py
# def add_libname_arguments(parser): add_libname_arguments_gen(parser, passing='')
#
# def update_env_with_libnames(env, args, default=(('.', 'Top'), ), include_passing=False, use_default=True, use_passing_default=True):
# all_keys = ('libnames', 'non_recursive_libnames', 'ocaml_dirnames', '_CoqProject', '_CoqProject_v_files', '_CoqProject_unknown')
# passing_opts = ('', ) if not include_passing else ('', 'passing_', 'nonpassing_')
# for passing in passing_opts:
# for key in all_keys:
# env[passing + key] = []
# if getattr(args, passing + 'CoqProjectFile'):
# for f in getattr(args, passing + 'CoqProjectFile'):
# env[passing + '_CoqProject'] = f.read()
# f.close()
# process_CoqProject(env, env[passing + '_CoqProject'], passing=passing)
# env[passing + 'libnames'].extend(getattr(args, passing + 'libnames'))
# env[passing + 'non_recursive_libnames'].extend(getattr(args, passing + 'non_recursive_libnames'))
# env[passing + 'ocaml_dirnames'].extend(getattr(args, passing + 'ocaml_dirnames'))
# if include_passing:
# # The nonpassing_ prefix is actually temporary; the semantics
# # are that, e.g., libnames = libnames + nonpassing_libnames,
# # while passing_libnames = libnames + passing_libnames
# for key in all_keys:
# env['passing_' + key] = env[key] + env['passing_' + key]
# env[key] = env[key] + env['nonpassing_' + key]
# del env['nonpassing_' + key]
# if use_default:
# update_env_with_libname_default(env, args, default=default)
# if use_passing_default and include_passing:
# update_env_with_libname_default(env, args, default=default, passing='passing_')
#
# def add_logging_arguments(parser):
# parser.add_argument('--verbose', '-v', dest='verbose',
# action='count',
# help='display some extra information by default (does not impact --verbose-log-file)')
# parser.add_argument('--quiet', '-q', dest='quiet',
# action='count',
# help='the inverse of --verbose')
# parser.add_argument('--log-file', '-l', dest='log_files', nargs='+', type=argparse.FileType('w'),
# default=[sys.stderr],
# help='The files to log output to. Use - for stdout.')
# parser.add_argument('--verbose-log-file', dest='verbose_log_files', nargs='+', type=TupleType(int, argparse.FileType('w')),
# default=[],
# help=(('The files to log output to at verbosity other than the default verbosity (%d if no -v/-q arguments are passed); ' +
# 'each argument should be a pair of a verbosity level and a file name. '
# 'Use - for stdout.') % DEFAULT_VERBOSITY))
#
# def process_logging_arguments(args):
# if args.verbose is None: args.verbose = DEFAULT_VERBOSITY
# if args.quiet is None: args.quiet = 0
# args.verbose -= args.quiet
# args.log = make_logger([(args.verbose, f) for f in args.log_files]
# + args.verbose_log_files)
# del args.quiet
# del args.verbose
# return args
#
# LOG_ALWAYS=None
#
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
#
# Path: file_util.py
# def read_from_file(file_name):
# return util.normalize_newlines(read_bytes_from_file(file_name).decode('utf-8'))
#
# def write_to_file(file_name, contents, *args, **kwargs):
# return write_bytes_to_file(file_name, contents.replace('\n', os.linesep).encode('utf-8'), *args, **kwargs)
. Output only the next line. | i += 1 |
Given the code snippet: <|code_start|>#!/usr/bin/env python
from __future__ import with_statement
# TODO:
# - handle fake ambiguities from [Definition foo] in a comment
# - handle theorems inside proof blocks
# - do the right thing for [Theorem foo. Theorem bar. Proof. Qed. Qed.] (we do the wrong thing right now)
# - make use of glob file?
parser = argparse.ArgumentParser(description='Implement the suggestions of [Set Suggest Proof Using.]')
parser.add_argument('source', metavar='SOURCE_FILE', type=argparse.FileType('r'), nargs='?', default=sys.stdin,
help='the source of set suggest proof using messages; use - for stdin.')
parser.add_argument('--hide', dest='hide_reg', nargs='*', type=str,
default=['.*_subproof[0-9]*$'], #, '.*_Proper$'],
help=('Regular expressions to not display warnings about on low verbosity. ' +
'[Set Suggest Proof Using] can give suggestions about hard-to-find ' +
'identifiers, and we might want to surpress them.'))
<|code_end|>
, generate the next line using the imports in this file:
import os, sys, re
from argparse_compat import argparse
from custom_arguments import add_libname_arguments, update_env_with_libnames, add_logging_arguments, process_logging_arguments, LOG_ALWAYS
from memoize import memoize
from file_util import read_from_file, write_to_file
and context (functions, classes, or occasionally code) from other files:
# Path: argparse_compat.py
#
# Path: custom_arguments.py
# def add_libname_arguments(parser): add_libname_arguments_gen(parser, passing='')
#
# def update_env_with_libnames(env, args, default=(('.', 'Top'), ), include_passing=False, use_default=True, use_passing_default=True):
# all_keys = ('libnames', 'non_recursive_libnames', 'ocaml_dirnames', '_CoqProject', '_CoqProject_v_files', '_CoqProject_unknown')
# passing_opts = ('', ) if not include_passing else ('', 'passing_', 'nonpassing_')
# for passing in passing_opts:
# for key in all_keys:
# env[passing + key] = []
# if getattr(args, passing + 'CoqProjectFile'):
# for f in getattr(args, passing + 'CoqProjectFile'):
# env[passing + '_CoqProject'] = f.read()
# f.close()
# process_CoqProject(env, env[passing + '_CoqProject'], passing=passing)
# env[passing + 'libnames'].extend(getattr(args, passing + 'libnames'))
# env[passing + 'non_recursive_libnames'].extend(getattr(args, passing + 'non_recursive_libnames'))
# env[passing + 'ocaml_dirnames'].extend(getattr(args, passing + 'ocaml_dirnames'))
# if include_passing:
# # The nonpassing_ prefix is actually temporary; the semantics
# # are that, e.g., libnames = libnames + nonpassing_libnames,
# # while passing_libnames = libnames + passing_libnames
# for key in all_keys:
# env['passing_' + key] = env[key] + env['passing_' + key]
# env[key] = env[key] + env['nonpassing_' + key]
# del env['nonpassing_' + key]
# if use_default:
# update_env_with_libname_default(env, args, default=default)
# if use_passing_default and include_passing:
# update_env_with_libname_default(env, args, default=default, passing='passing_')
#
# def add_logging_arguments(parser):
# parser.add_argument('--verbose', '-v', dest='verbose',
# action='count',
# help='display some extra information by default (does not impact --verbose-log-file)')
# parser.add_argument('--quiet', '-q', dest='quiet',
# action='count',
# help='the inverse of --verbose')
# parser.add_argument('--log-file', '-l', dest='log_files', nargs='+', type=argparse.FileType('w'),
# default=[sys.stderr],
# help='The files to log output to. Use - for stdout.')
# parser.add_argument('--verbose-log-file', dest='verbose_log_files', nargs='+', type=TupleType(int, argparse.FileType('w')),
# default=[],
# help=(('The files to log output to at verbosity other than the default verbosity (%d if no -v/-q arguments are passed); ' +
# 'each argument should be a pair of a verbosity level and a file name. '
# 'Use - for stdout.') % DEFAULT_VERBOSITY))
#
# def process_logging_arguments(args):
# if args.verbose is None: args.verbose = DEFAULT_VERBOSITY
# if args.quiet is None: args.quiet = 0
# args.verbose -= args.quiet
# args.log = make_logger([(args.verbose, f) for f in args.log_files]
# + args.verbose_log_files)
# del args.quiet
# del args.verbose
# return args
#
# LOG_ALWAYS=None
#
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
#
# Path: file_util.py
# def read_from_file(file_name):
# return util.normalize_newlines(read_bytes_from_file(file_name).decode('utf-8'))
#
# def write_to_file(file_name, contents, *args, **kwargs):
# return write_bytes_to_file(file_name, contents.replace('\n', os.linesep).encode('utf-8'), *args, **kwargs)
. Output only the next line. | parser.add_argument('--no-hide', dest='hide_reg', action='store_const', const=[]) |
Given the following code snippet before the placeholder: <|code_start|> prepare_cmds_for_coq_output_printed_cmd_already.add(sanitize_cmd(cmd_to_print))
kwargs['log']('\nContents:\n%s\n' % contents,
level=kwargs['verbose_base']+1)
return key, file_name, cmds, input_val, cleaner
def reset_coq_output_cache(coqc_prog, coqc_prog_args, contents, timeout_val, cwd=None, is_coqtop=False, pass_on_stdin=False, verbose_base=1, **kwargs):
key, file_name, cmds, input_val, cleaner = prepare_cmds_for_coq_output(coqc_prog, coqc_prog_args, contents, cwd=cwd, timeout_val=timeout_val, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, **kwargs)
cleaner()
if key in COQ_OUTPUT.keys(): del COQ_OUTPUT[key]
def get_coq_output(coqc_prog, coqc_prog_args, contents, timeout_val, cwd=None, is_coqtop=False, pass_on_stdin=False, verbose_base=1, retry_with_debug_when=(lambda output: 'is not a compiled interface for this version of OCaml' in output), **kwargs):
"""Returns the coqc output of running through the given
contents. Pass timeout_val = None for no timeout."""
if timeout_val is not None and timeout_val < 0 and get_timeout(coqc_prog) is not None:
return get_coq_output(coqc_prog, coqc_prog_args, contents, get_timeout(coqc_prog), cwd=cwd, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, retry_with_debug_when=retry_with_debug_when, **kwargs)
key, file_name, cmds, input_val, cleaner = prepare_cmds_for_coq_output(coqc_prog, coqc_prog_args, contents, cwd=cwd, timeout_val=timeout_val, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, **kwargs)
if key in COQ_OUTPUT.keys():
cleaner()
return COQ_OUTPUT[key][1]
start = time.time()
((stdout, stderr), returncode) = memory_robust_timeout_Popen_communicate(kwargs['log'], cmds, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, stdin=subprocess.PIPE, timeout=(timeout_val if timeout_val is not None and timeout_val > 0 else None), input=input_val, cwd=cwd)
finish = time.time()
runtime = finish - start
kwargs['log']('\nretcode: %d\nstdout:\n%s\n\nstderr:\n%s\nruntime:\n%f\n\n' % (returncode, util.s(stdout), util.s(stderr), runtime),
level=verbose_base + 1)
if get_timeout(coqc_prog) is None and timeout_val is not None:
<|code_end|>
, predict the next line using imports from the current file:
import os, sys, tempfile, subprocess, re, time, math, glob, threading, shutil, traceback
import util
from Popen_noblock import Popen_async, Empty
from memoize import memoize
from file_util import clean_v_file
from util import re_escape
from custom_arguments import LOG_ALWAYS
from coq_version import group_coq_args, get_coqc_help
and context including class names, function names, and sometimes code from other files:
# Path: Popen_noblock.py
# ON_POSIX = 'posix' in sys.builtin_module_names
# def enqueue_output(out, queue):
# def __init__(self, *args, **kwargs):
# class Popen_async(object):
#
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
#
# Path: file_util.py
# def clean_v_file(file_name):
# clean_extra_coq_files(file_name, extra_exts=('.v',))
#
# Path: util.py
# def re_escape(*args, **kwargs):
# ret = re.escape(*args, **kwargs)
# for ch in ':"':
# ret = ret.replace('\\' + ch, ch)
# return ret
#
# Path: custom_arguments.py
# LOG_ALWAYS=None
#
# Path: coq_version.py
# def group_coq_args(args, coqc_help, topname=None, is_coq_makefile=False):
# bindings, unrecognized_bindings = group_coq_args_split_recognized(args, coqc_help, topname=topname, is_coq_makefile=is_coq_makefile)
# return bindings + [tuple([v]) for v in unrecognized_bindings]
#
# def get_coqc_help(coqc_prog, **kwargs):
# kwargs['log']('Running command: "%s"' % '" "'.join([coqc_prog, "-q", "--help"]), level=2)
# return get_coqc_help_helper(coqc_prog)
. Output only the next line. | set_timeout(coqc_prog, 3 * max((1, int(math.ceil(finish - start)))), **kwargs) |
Given the code snippet: <|code_start|> else:
cmds.extend([file_name, '-q'])
cmd_to_print = '"%s%s"' % ('" "'.join(cmds), pseudocmds)
kwargs['log']('\nRunning command: %s' % cmd_to_print,
level=(kwargs['verbose_base']
- (1 if sanitize_cmd(cmd_to_print) not in prepare_cmds_for_coq_output_printed_cmd_already else 0)))
prepare_cmds_for_coq_output_printed_cmd_already.add(sanitize_cmd(cmd_to_print))
kwargs['log']('\nContents:\n%s\n' % contents,
level=kwargs['verbose_base']+1)
return key, file_name, cmds, input_val, cleaner
def reset_coq_output_cache(coqc_prog, coqc_prog_args, contents, timeout_val, cwd=None, is_coqtop=False, pass_on_stdin=False, verbose_base=1, **kwargs):
key, file_name, cmds, input_val, cleaner = prepare_cmds_for_coq_output(coqc_prog, coqc_prog_args, contents, cwd=cwd, timeout_val=timeout_val, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, **kwargs)
cleaner()
if key in COQ_OUTPUT.keys(): del COQ_OUTPUT[key]
def get_coq_output(coqc_prog, coqc_prog_args, contents, timeout_val, cwd=None, is_coqtop=False, pass_on_stdin=False, verbose_base=1, retry_with_debug_when=(lambda output: 'is not a compiled interface for this version of OCaml' in output), **kwargs):
"""Returns the coqc output of running through the given
contents. Pass timeout_val = None for no timeout."""
if timeout_val is not None and timeout_val < 0 and get_timeout(coqc_prog) is not None:
return get_coq_output(coqc_prog, coqc_prog_args, contents, get_timeout(coqc_prog), cwd=cwd, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, retry_with_debug_when=retry_with_debug_when, **kwargs)
key, file_name, cmds, input_val, cleaner = prepare_cmds_for_coq_output(coqc_prog, coqc_prog_args, contents, cwd=cwd, timeout_val=timeout_val, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, **kwargs)
if key in COQ_OUTPUT.keys():
cleaner()
return COQ_OUTPUT[key][1]
start = time.time()
<|code_end|>
, generate the next line using the imports in this file:
import os, sys, tempfile, subprocess, re, time, math, glob, threading, shutil, traceback
import util
from Popen_noblock import Popen_async, Empty
from memoize import memoize
from file_util import clean_v_file
from util import re_escape
from custom_arguments import LOG_ALWAYS
from coq_version import group_coq_args, get_coqc_help
and context (functions, classes, or occasionally code) from other files:
# Path: Popen_noblock.py
# ON_POSIX = 'posix' in sys.builtin_module_names
# def enqueue_output(out, queue):
# def __init__(self, *args, **kwargs):
# class Popen_async(object):
#
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
#
# Path: file_util.py
# def clean_v_file(file_name):
# clean_extra_coq_files(file_name, extra_exts=('.v',))
#
# Path: util.py
# def re_escape(*args, **kwargs):
# ret = re.escape(*args, **kwargs)
# for ch in ':"':
# ret = ret.replace('\\' + ch, ch)
# return ret
#
# Path: custom_arguments.py
# LOG_ALWAYS=None
#
# Path: coq_version.py
# def group_coq_args(args, coqc_help, topname=None, is_coq_makefile=False):
# bindings, unrecognized_bindings = group_coq_args_split_recognized(args, coqc_help, topname=topname, is_coq_makefile=is_coq_makefile)
# return bindings + [tuple([v]) for v in unrecognized_bindings]
#
# def get_coqc_help(coqc_prog, **kwargs):
# kwargs['log']('Running command: "%s"' % '" "'.join([coqc_prog, "-q", "--help"]), level=2)
# return get_coqc_help_helper(coqc_prog)
. Output only the next line. | ((stdout, stderr), returncode) = memory_robust_timeout_Popen_communicate(kwargs['log'], cmds, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, stdin=subprocess.PIPE, timeout=(timeout_val if timeout_val is not None and timeout_val > 0 else None), input=input_val, cwd=cwd) |
Based on the snippet: <|code_start|>from __future__ import with_statement, print_function
__all__ = ["has_error", "get_error_line_number", "get_error_byte_locations", "make_reg_string", "get_coq_output", "get_error_string", "get_timeout", "reset_timeout", "reset_coq_output_cache", "is_timeout"]
ACTUAL_ERROR_REG_STRING = '(?!Warning)(?!The command has indeed failed with message:)' # maybe we should just require Error or Timeout?
DEFAULT_PRE_PRE_ERROR_REG_STRING = 'File "[^"]+", line ([0-9]+), characters [0-9-]+:\n'
DEFAULT_PRE_ERROR_REG_STRING = DEFAULT_PRE_PRE_ERROR_REG_STRING + ACTUAL_ERROR_REG_STRING
DEFAULT_PRE_ERROR_REG_STRING_WITH_BYTES = 'File "[^"]+", line ([0-9]+), characters ([0-9]+)-([0-9]+):\n' + ACTUAL_ERROR_REG_STRING
DEFAULT_ERROR_REG_STRING = DEFAULT_PRE_ERROR_REG_STRING + '((?:.|\n)+)'
DEFAULT_ERROR_REG_STRING_WITH_BYTES = DEFAULT_PRE_ERROR_REG_STRING_WITH_BYTES + '((?:.|\n)+)'
DEFAULT_ERROR_REG_STRING_GENERIC = DEFAULT_PRE_PRE_ERROR_REG_STRING + '(%s)'
def clean_output(output):
return util.normalize_newlines(output)
@memoize
def get_coq_accepts_fine_grained_debug(coqc, debug_kind):
temp_file = tempfile.NamedTemporaryFile(suffix='.v', dir='.', delete=True)
temp_file_name = temp_file.name
<|code_end|>
, predict the immediate next line with the help of imports:
import os, sys, tempfile, subprocess, re, time, math, glob, threading, shutil, traceback
import util
from Popen_noblock import Popen_async, Empty
from memoize import memoize
from file_util import clean_v_file
from util import re_escape
from custom_arguments import LOG_ALWAYS
from coq_version import group_coq_args, get_coqc_help
and context (classes, functions, sometimes code) from other files:
# Path: Popen_noblock.py
# ON_POSIX = 'posix' in sys.builtin_module_names
# def enqueue_output(out, queue):
# def __init__(self, *args, **kwargs):
# class Popen_async(object):
#
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
#
# Path: file_util.py
# def clean_v_file(file_name):
# clean_extra_coq_files(file_name, extra_exts=('.v',))
#
# Path: util.py
# def re_escape(*args, **kwargs):
# ret = re.escape(*args, **kwargs)
# for ch in ':"':
# ret = ret.replace('\\' + ch, ch)
# return ret
#
# Path: custom_arguments.py
# LOG_ALWAYS=None
#
# Path: coq_version.py
# def group_coq_args(args, coqc_help, topname=None, is_coq_makefile=False):
# bindings, unrecognized_bindings = group_coq_args_split_recognized(args, coqc_help, topname=topname, is_coq_makefile=is_coq_makefile)
# return bindings + [tuple([v]) for v in unrecognized_bindings]
#
# def get_coqc_help(coqc_prog, **kwargs):
# kwargs['log']('Running command: "%s"' % '" "'.join([coqc_prog, "-q", "--help"]), level=2)
# return get_coqc_help_helper(coqc_prog)
. Output only the next line. | p = subprocess.Popen([coqc, "-q", "-d", debug_kind, temp_file_name], stderr=subprocess.STDOUT, stdout=subprocess.PIPE) |
Based on the snippet: <|code_start|>from __future__ import with_statement, print_function
__all__ = ["has_error", "get_error_line_number", "get_error_byte_locations", "make_reg_string", "get_coq_output", "get_error_string", "get_timeout", "reset_timeout", "reset_coq_output_cache", "is_timeout"]
ACTUAL_ERROR_REG_STRING = '(?!Warning)(?!The command has indeed failed with message:)' # maybe we should just require Error or Timeout?
DEFAULT_PRE_PRE_ERROR_REG_STRING = 'File "[^"]+", line ([0-9]+), characters [0-9-]+:\n'
DEFAULT_PRE_ERROR_REG_STRING = DEFAULT_PRE_PRE_ERROR_REG_STRING + ACTUAL_ERROR_REG_STRING
DEFAULT_PRE_ERROR_REG_STRING_WITH_BYTES = 'File "[^"]+", line ([0-9]+), characters ([0-9]+)-([0-9]+):\n' + ACTUAL_ERROR_REG_STRING
DEFAULT_ERROR_REG_STRING = DEFAULT_PRE_ERROR_REG_STRING + '((?:.|\n)+)'
<|code_end|>
, predict the immediate next line with the help of imports:
import os, sys, tempfile, subprocess, re, time, math, glob, threading, shutil, traceback
import util
from Popen_noblock import Popen_async, Empty
from memoize import memoize
from file_util import clean_v_file
from util import re_escape
from custom_arguments import LOG_ALWAYS
from coq_version import group_coq_args, get_coqc_help
and context (classes, functions, sometimes code) from other files:
# Path: Popen_noblock.py
# ON_POSIX = 'posix' in sys.builtin_module_names
# def enqueue_output(out, queue):
# def __init__(self, *args, **kwargs):
# class Popen_async(object):
#
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
#
# Path: file_util.py
# def clean_v_file(file_name):
# clean_extra_coq_files(file_name, extra_exts=('.v',))
#
# Path: util.py
# def re_escape(*args, **kwargs):
# ret = re.escape(*args, **kwargs)
# for ch in ':"':
# ret = ret.replace('\\' + ch, ch)
# return ret
#
# Path: custom_arguments.py
# LOG_ALWAYS=None
#
# Path: coq_version.py
# def group_coq_args(args, coqc_help, topname=None, is_coq_makefile=False):
# bindings, unrecognized_bindings = group_coq_args_split_recognized(args, coqc_help, topname=topname, is_coq_makefile=is_coq_makefile)
# return bindings + [tuple([v]) for v in unrecognized_bindings]
#
# def get_coqc_help(coqc_prog, **kwargs):
# kwargs['log']('Running command: "%s"' % '" "'.join([coqc_prog, "-q", "--help"]), level=2)
# return get_coqc_help_helper(coqc_prog)
. Output only the next line. | DEFAULT_ERROR_REG_STRING_WITH_BYTES = DEFAULT_PRE_ERROR_REG_STRING_WITH_BYTES + '((?:.|\n)+)' |
Predict the next line for this snippet: <|code_start|> pseudocmds = '" < "%s' % file_name
else:
cmds.extend(['-load-vernac-source', file_name_root, '-q'])
else:
cmds.extend([file_name, '-q'])
cmd_to_print = '"%s%s"' % ('" "'.join(cmds), pseudocmds)
kwargs['log']('\nRunning command: %s' % cmd_to_print,
level=(kwargs['verbose_base']
- (1 if sanitize_cmd(cmd_to_print) not in prepare_cmds_for_coq_output_printed_cmd_already else 0)))
prepare_cmds_for_coq_output_printed_cmd_already.add(sanitize_cmd(cmd_to_print))
kwargs['log']('\nContents:\n%s\n' % contents,
level=kwargs['verbose_base']+1)
return key, file_name, cmds, input_val, cleaner
def reset_coq_output_cache(coqc_prog, coqc_prog_args, contents, timeout_val, cwd=None, is_coqtop=False, pass_on_stdin=False, verbose_base=1, **kwargs):
key, file_name, cmds, input_val, cleaner = prepare_cmds_for_coq_output(coqc_prog, coqc_prog_args, contents, cwd=cwd, timeout_val=timeout_val, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, **kwargs)
cleaner()
if key in COQ_OUTPUT.keys(): del COQ_OUTPUT[key]
def get_coq_output(coqc_prog, coqc_prog_args, contents, timeout_val, cwd=None, is_coqtop=False, pass_on_stdin=False, verbose_base=1, retry_with_debug_when=(lambda output: 'is not a compiled interface for this version of OCaml' in output), **kwargs):
"""Returns the coqc output of running through the given
contents. Pass timeout_val = None for no timeout."""
if timeout_val is not None and timeout_val < 0 and get_timeout(coqc_prog) is not None:
return get_coq_output(coqc_prog, coqc_prog_args, contents, get_timeout(coqc_prog), cwd=cwd, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, retry_with_debug_when=retry_with_debug_when, **kwargs)
key, file_name, cmds, input_val, cleaner = prepare_cmds_for_coq_output(coqc_prog, coqc_prog_args, contents, cwd=cwd, timeout_val=timeout_val, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, **kwargs)
if key in COQ_OUTPUT.keys():
cleaner()
<|code_end|>
with the help of current file imports:
import os, sys, tempfile, subprocess, re, time, math, glob, threading, shutil, traceback
import util
from Popen_noblock import Popen_async, Empty
from memoize import memoize
from file_util import clean_v_file
from util import re_escape
from custom_arguments import LOG_ALWAYS
from coq_version import group_coq_args, get_coqc_help
and context from other files:
# Path: Popen_noblock.py
# ON_POSIX = 'posix' in sys.builtin_module_names
# def enqueue_output(out, queue):
# def __init__(self, *args, **kwargs):
# class Popen_async(object):
#
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
#
# Path: file_util.py
# def clean_v_file(file_name):
# clean_extra_coq_files(file_name, extra_exts=('.v',))
#
# Path: util.py
# def re_escape(*args, **kwargs):
# ret = re.escape(*args, **kwargs)
# for ch in ':"':
# ret = ret.replace('\\' + ch, ch)
# return ret
#
# Path: custom_arguments.py
# LOG_ALWAYS=None
#
# Path: coq_version.py
# def group_coq_args(args, coqc_help, topname=None, is_coq_makefile=False):
# bindings, unrecognized_bindings = group_coq_args_split_recognized(args, coqc_help, topname=topname, is_coq_makefile=is_coq_makefile)
# return bindings + [tuple([v]) for v in unrecognized_bindings]
#
# def get_coqc_help(coqc_prog, **kwargs):
# kwargs['log']('Running command: "%s"' % '" "'.join([coqc_prog, "-q", "--help"]), level=2)
# return get_coqc_help_helper(coqc_prog)
, which may contain function names, class names, or code. Output only the next line. | return COQ_OUTPUT[key][1] |
Using the snippet: <|code_start|># file)
__all__ = ["get_proof_term_works_with_time", "get_ltac_support_snippet"]
def get_proof_term_works_with_time(coqc_prog, **kwargs):
contents = r"""Lemma foo : forall _ : Type, Type.
Proof (fun x => x)."""
output, cmds, retcode, runtime = get_coq_output(coqc_prog, ('-time', '-q'), contents, 1, verbose_base=3, **kwargs)
return 'Error: Attempt to save an incomplete proof' not in output
LTAC_SUPPORT_SNIPPET = {}
def get_ltac_support_snippet(coqc, **kwargs):
if coqc in LTAC_SUPPORT_SNIPPET.keys():
return LTAC_SUPPORT_SNIPPET[coqc]
test = r'''Inductive False : Prop := .
Axiom proof_admitted : False.
Tactic Notation "admit" := abstract case proof_admitted.
Goal False. admit. Qed.'''
errinfo = {}
native_ondemand_args = list(get_coq_native_compiler_ondemand_fragment(coqc, **kwargs))
for before, after in (('Declare ML Module "coq-core.plugins.ltac".\n', ''),
('Declare ML Module "coq-core.plugins.ltac".\n', 'Global Set Default Proof Mode "Classic".\n'),
('Declare ML Module "ltac_plugin".\n', ''),
('Declare ML Module "ltac_plugin".\n', 'Global Set Default Proof Mode "Classic".\n'),
('Require Coq.Init.Ltac.\n', 'Import Coq.Init.Ltac.\n'),
('Require Coq.Init.Notations.\n', 'Import Coq.Init.Notations.\n')):
contents = '%s\n%s\n%s' % (before, after, test)
output, cmds, retcode, runtime = get_coq_output(coqc, tuple(['-q', '-nois'] + native_ondemand_args), contents, timeout_val=None, verbose_base=3, is_coqtop=kwargs['coqc_is_coqtop'], **kwargs)
if retcode == 0:
LTAC_SUPPORT_SNIPPET[coqc] = (before, after)
<|code_end|>
, determine the next line of code. You have imports:
from diagnose_error import get_coq_output
from coq_version import get_coq_native_compiler_ondemand_fragment
and context (class names, function names, or code) available:
# Path: diagnose_error.py
# def get_coq_output(coqc_prog, coqc_prog_args, contents, timeout_val, cwd=None, is_coqtop=False, pass_on_stdin=False, verbose_base=1, retry_with_debug_when=(lambda output: 'is not a compiled interface for this version of OCaml' in output), **kwargs):
# """Returns the coqc output of running through the given
# contents. Pass timeout_val = None for no timeout."""
# if timeout_val is not None and timeout_val < 0 and get_timeout(coqc_prog) is not None:
# return get_coq_output(coqc_prog, coqc_prog_args, contents, get_timeout(coqc_prog), cwd=cwd, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, retry_with_debug_when=retry_with_debug_when, **kwargs)
#
# key, file_name, cmds, input_val, cleaner = prepare_cmds_for_coq_output(coqc_prog, coqc_prog_args, contents, cwd=cwd, timeout_val=timeout_val, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, **kwargs)
#
# if key in COQ_OUTPUT.keys():
# cleaner()
# return COQ_OUTPUT[key][1]
#
# start = time.time()
# ((stdout, stderr), returncode) = memory_robust_timeout_Popen_communicate(kwargs['log'], cmds, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, stdin=subprocess.PIPE, timeout=(timeout_val if timeout_val is not None and timeout_val > 0 else None), input=input_val, cwd=cwd)
# finish = time.time()
# runtime = finish - start
# kwargs['log']('\nretcode: %d\nstdout:\n%s\n\nstderr:\n%s\nruntime:\n%f\n\n' % (returncode, util.s(stdout), util.s(stderr), runtime),
# level=verbose_base + 1)
# if get_timeout(coqc_prog) is None and timeout_val is not None:
# set_timeout(coqc_prog, 3 * max((1, int(math.ceil(finish - start)))), **kwargs)
# cleaner()
# COQ_OUTPUT[key] = (file_name, (clean_output(util.s(stdout)), tuple(cmds), returncode, runtime))
# kwargs['log']('Storing result: COQ_OUTPUT[%s]:\n%s' % (repr(key), repr(COQ_OUTPUT[key])),
# level=verbose_base + 2)
# if retry_with_debug_when(COQ_OUTPUT[key][1][0]):
# debug_args = get_coq_debug_native_compiler_args(coqc_prog)
# kwargs['log']('Retrying with %s...' % ' '.join(debug_args),
# level=verbose_base - 1)
# return get_coq_output(coqc_prog, list(debug_args) + list(coqc_prog_args), contents, timeout_val, cwd=cwd, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, retry_with_debug_when=(lambda output: False), **kwargs)
# return COQ_OUTPUT[key][1]
#
# Path: coq_version.py
# def get_coq_native_compiler_ondemand_fragment(coqc_prog, **kwargs):
# help_lines = get_coqc_help(coqc_prog, **kwargs).split('\n')
# if any('ondemand' in line for line in help_lines if line.strip().startswith('-native-compiler')):
# if get_coq_accepts_w(coqc_prog, **kwargs):
# return ('-w', '-deprecated-native-compiler-option,-native-compiler-disabled', '-native-compiler', 'ondemand')
# elif not get_coqc_native_compiler_ondemand_errors(coqc_prog):
# return ('-native-compiler', 'ondemand')
# return tuple()
. Output only the next line. | return (before, after) |
Given the following code snippet before the placeholder: <|code_start|># file)
__all__ = ["get_proof_term_works_with_time", "get_ltac_support_snippet"]
def get_proof_term_works_with_time(coqc_prog, **kwargs):
contents = r"""Lemma foo : forall _ : Type, Type.
Proof (fun x => x)."""
output, cmds, retcode, runtime = get_coq_output(coqc_prog, ('-time', '-q'), contents, 1, verbose_base=3, **kwargs)
return 'Error: Attempt to save an incomplete proof' not in output
LTAC_SUPPORT_SNIPPET = {}
def get_ltac_support_snippet(coqc, **kwargs):
if coqc in LTAC_SUPPORT_SNIPPET.keys():
return LTAC_SUPPORT_SNIPPET[coqc]
test = r'''Inductive False : Prop := .
Axiom proof_admitted : False.
Tactic Notation "admit" := abstract case proof_admitted.
Goal False. admit. Qed.'''
errinfo = {}
native_ondemand_args = list(get_coq_native_compiler_ondemand_fragment(coqc, **kwargs))
for before, after in (('Declare ML Module "coq-core.plugins.ltac".\n', ''),
('Declare ML Module "coq-core.plugins.ltac".\n', 'Global Set Default Proof Mode "Classic".\n'),
('Declare ML Module "ltac_plugin".\n', ''),
('Declare ML Module "ltac_plugin".\n', 'Global Set Default Proof Mode "Classic".\n'),
('Require Coq.Init.Ltac.\n', 'Import Coq.Init.Ltac.\n'),
('Require Coq.Init.Notations.\n', 'Import Coq.Init.Notations.\n')):
contents = '%s\n%s\n%s' % (before, after, test)
output, cmds, retcode, runtime = get_coq_output(coqc, tuple(['-q', '-nois'] + native_ondemand_args), contents, timeout_val=None, verbose_base=3, is_coqtop=kwargs['coqc_is_coqtop'], **kwargs)
if retcode == 0:
LTAC_SUPPORT_SNIPPET[coqc] = (before, after)
<|code_end|>
, predict the next line using imports from the current file:
from diagnose_error import get_coq_output
from coq_version import get_coq_native_compiler_ondemand_fragment
and context including class names, function names, and sometimes code from other files:
# Path: diagnose_error.py
# def get_coq_output(coqc_prog, coqc_prog_args, contents, timeout_val, cwd=None, is_coqtop=False, pass_on_stdin=False, verbose_base=1, retry_with_debug_when=(lambda output: 'is not a compiled interface for this version of OCaml' in output), **kwargs):
# """Returns the coqc output of running through the given
# contents. Pass timeout_val = None for no timeout."""
# if timeout_val is not None and timeout_val < 0 and get_timeout(coqc_prog) is not None:
# return get_coq_output(coqc_prog, coqc_prog_args, contents, get_timeout(coqc_prog), cwd=cwd, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, retry_with_debug_when=retry_with_debug_when, **kwargs)
#
# key, file_name, cmds, input_val, cleaner = prepare_cmds_for_coq_output(coqc_prog, coqc_prog_args, contents, cwd=cwd, timeout_val=timeout_val, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, **kwargs)
#
# if key in COQ_OUTPUT.keys():
# cleaner()
# return COQ_OUTPUT[key][1]
#
# start = time.time()
# ((stdout, stderr), returncode) = memory_robust_timeout_Popen_communicate(kwargs['log'], cmds, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, stdin=subprocess.PIPE, timeout=(timeout_val if timeout_val is not None and timeout_val > 0 else None), input=input_val, cwd=cwd)
# finish = time.time()
# runtime = finish - start
# kwargs['log']('\nretcode: %d\nstdout:\n%s\n\nstderr:\n%s\nruntime:\n%f\n\n' % (returncode, util.s(stdout), util.s(stderr), runtime),
# level=verbose_base + 1)
# if get_timeout(coqc_prog) is None and timeout_val is not None:
# set_timeout(coqc_prog, 3 * max((1, int(math.ceil(finish - start)))), **kwargs)
# cleaner()
# COQ_OUTPUT[key] = (file_name, (clean_output(util.s(stdout)), tuple(cmds), returncode, runtime))
# kwargs['log']('Storing result: COQ_OUTPUT[%s]:\n%s' % (repr(key), repr(COQ_OUTPUT[key])),
# level=verbose_base + 2)
# if retry_with_debug_when(COQ_OUTPUT[key][1][0]):
# debug_args = get_coq_debug_native_compiler_args(coqc_prog)
# kwargs['log']('Retrying with %s...' % ' '.join(debug_args),
# level=verbose_base - 1)
# return get_coq_output(coqc_prog, list(debug_args) + list(coqc_prog_args), contents, timeout_val, cwd=cwd, is_coqtop=is_coqtop, pass_on_stdin=pass_on_stdin, verbose_base=verbose_base, retry_with_debug_when=(lambda output: False), **kwargs)
# return COQ_OUTPUT[key][1]
#
# Path: coq_version.py
# def get_coq_native_compiler_ondemand_fragment(coqc_prog, **kwargs):
# help_lines = get_coqc_help(coqc_prog, **kwargs).split('\n')
# if any('ondemand' in line for line in help_lines if line.strip().startswith('-native-compiler')):
# if get_coq_accepts_w(coqc_prog, **kwargs):
# return ('-w', '-deprecated-native-compiler-option,-native-compiler-disabled', '-native-compiler', 'ondemand')
# elif not get_coqc_native_compiler_ondemand_errors(coqc_prog):
# return ('-native-compiler', 'ondemand')
# return tuple()
. Output only the next line. | return (before, after) |
Here is a snippet: <|code_start|> backup(file_name, ext=backup_ext)
backed_up = True
except IOError as e:
print('Warning: f.write(%s) failed with %s\nTrying again in 10s' % (file_name, repr(e)))
time.sleep(10)
written = False
while not written:
try:
with open(file_name, 'wb') as f:
f.write(contents)
written = True
FILE_CACHE[file_name] = (os.stat(file_name).st_mtime, contents)
except IOError as e:
print('Warning: f.write(%s) failed with %s\nTrying again in 10s' % (file_name, repr(e)))
time.sleep(10)
def write_to_file(file_name, contents, *args, **kwargs):
return write_bytes_to_file(file_name, contents.replace('\n', os.linesep).encode('utf-8'), *args, **kwargs)
def restore_file(file_name, backup_ext='.bak', backup_backup_ext='.unbak'):
if not os.path.exists(file_name + backup_ext):
raise IOError
if os.path.exists(file_name):
if backup_backup_ext:
backup(file_name, backup_backup_ext)
else:
os.remove(file_name)
os.rename(file_name + backup_ext, file_name)
def read_bytes_from_file(file_name):
<|code_end|>
. Write the next line using the current file imports:
import os, time
import util
from memoize import memoize
and context from other files:
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
, which may include functions, classes, or code. Output only the next line. | if file_name in FILE_CACHE.keys() and os.stat(file_name).st_mtime == FILE_CACHE[file_name][0]: |
Here is a snippet: <|code_start|>parser.add_argument('--quiet', '-q', dest='quiet',
action='count',
help='the inverse of --verbose')
parser.add_argument('--log-file', '-l', dest='log_files', nargs='*', type=argparse.FileType('w'),
default=[sys.stderr],
help='The files to log output to. Use - for stdout.')
DEFAULT_VERBOSITY=1
def make_logger(log_files):
def log(text):
for i in log_files:
i.write(str(text) + '\n')
i.flush()
if i.fileno() > 2: # stderr
os.fsync(i.fileno())
return log
DEFAULT_LOG = make_logger([sys.stderr])
def backup(file_name, ext='.bak'):
if not ext:
raise ValueError
if os.path.exists(file_name):
backup(file_name + ext)
os.rename(file_name, file_name + ext)
def write_to_file(file_name, contents, do_backup=False, ext='.bak'):
if do_backup:
backup(file_name, ext=ext)
<|code_end|>
. Write the next line using the current file imports:
import os, sys, shutil, re
from argparse_compat import argparse
and context from other files:
# Path: argparse_compat.py
, which may include functions, classes, or code. Output only the next line. | try: |
Next line prediction: <|code_start|> if f(arg[start:end]) == GOOD:
orig_end = end
return arg[start:orig_end]
@memoize
def check_grep_for(in_str, search_for):
# print("echo %s | grep -q %s" % (repr(in_str), repr(search_for)))
p = subprocess.Popen(["timeout", "0.5s", "grep", search_for], universal_newlines=False, stderr=subprocess.PIPE, stdout=subprocess.PIPE, stdin=subprocess.PIPE)
# print(search_for)
(stdout, stderr) = p.communicate(input=b(in_str))
p.stdin.close()
p.wait()
if stderr != b('') or p.returncode == 124: # timeout
return INVALID
return (GOOD if p.returncode == 0 else BAD)
if __name__ == '__main__':
if len(sys.argv) != 3:
sys.stderr.write("USAGE: %s SEARCH_IN SEARCH_FOR\n" % sys.argv[0])
sys.exit(1)
def check_grep(search_for):
return check_grep_for(sys.argv[1], search_for)
search_for = binary_search_on_string(check_grep, sys.argv[2])
p = subprocess.Popen(["grep", "--color=auto", search_for], universal_newlines=False, stdin=subprocess.PIPE)
p.communicate(input=b(sys.argv[1]))
p.stdin.close()
p.wait()
if len(search_for) < len(sys.argv[2]):
print("Mismatch: good prefix:")
p = subprocess.Popen(["grep", "-o", "--color=auto", search_for], universal_newlines=False, stdin=subprocess.PIPE)
<|code_end|>
. Use current file imports:
(import subprocess, sys
from memoize import memoize)
and context including class names, function names, or small code snippets from other files:
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
. Output only the next line. | p.communicate(input=b(sys.argv[1])) |
Given snippet: <|code_start|>from __future__ import print_function
__all__ = ["has_dir_binding", "deduplicate_trailing_dir_bindings", "process_maybe_list"]
def topname_of_filename(file_name):
return os.path.splitext(os.path.basename(file_name))[0].replace('-', '_DASH_')
def has_dir_binding(args, coqc_help, file_name=None):
kwargs = dict()
if file_name is not None: kwargs['topname'] = topname_of_filename(file_name)
bindings = group_coq_args(args, coqc_help, **kwargs)
return any(i[0] in ('-R', '-Q') for i in bindings)
def deduplicate_trailing_dir_bindings(args, coqc_help, coq_accepts_top, file_name=None):
kwargs = dict()
if file_name is not None: kwargs['topname'] = topname_of_filename(file_name)
bindings = group_coq_args(args, coqc_help, **kwargs)
ret = []
for binding in bindings:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
from coq_version import group_coq_args
from custom_arguments import DEFAULT_LOG
and context:
# Path: coq_version.py
# def group_coq_args(args, coqc_help, topname=None, is_coq_makefile=False):
# bindings, unrecognized_bindings = group_coq_args_split_recognized(args, coqc_help, topname=topname, is_coq_makefile=is_coq_makefile)
# return bindings + [tuple([v]) for v in unrecognized_bindings]
#
# Path: custom_arguments.py
# DEFAULT_LOG = make_logger([(DEFAULT_VERBOSITY, sys.stderr)])
which might include code, classes, or functions. Output only the next line. | if coq_accepts_top or binding[0] != '-top': |
Using the snippet: <|code_start|>from __future__ import print_function
__all__ = ["has_dir_binding", "deduplicate_trailing_dir_bindings", "process_maybe_list"]
def topname_of_filename(file_name):
return os.path.splitext(os.path.basename(file_name))[0].replace('-', '_DASH_')
def has_dir_binding(args, coqc_help, file_name=None):
kwargs = dict()
if file_name is not None: kwargs['topname'] = topname_of_filename(file_name)
bindings = group_coq_args(args, coqc_help, **kwargs)
return any(i[0] in ('-R', '-Q') for i in bindings)
def deduplicate_trailing_dir_bindings(args, coqc_help, coq_accepts_top, file_name=None):
kwargs = dict()
if file_name is not None: kwargs['topname'] = topname_of_filename(file_name)
bindings = group_coq_args(args, coqc_help, **kwargs)
<|code_end|>
, determine the next line of code. You have imports:
import os
from coq_version import group_coq_args
from custom_arguments import DEFAULT_LOG
and context (class names, function names, or code) available:
# Path: coq_version.py
# def group_coq_args(args, coqc_help, topname=None, is_coq_makefile=False):
# bindings, unrecognized_bindings = group_coq_args_split_recognized(args, coqc_help, topname=topname, is_coq_makefile=is_coq_makefile)
# return bindings + [tuple([v]) for v in unrecognized_bindings]
#
# Path: custom_arguments.py
# DEFAULT_LOG = make_logger([(DEFAULT_VERBOSITY, sys.stderr)])
. Output only the next line. | ret = [] |
Given the following code snippet before the placeholder: <|code_start|>from __future__ import division
__all__ = ["run_binary_search"]
@memoize
def apply_as_many_times_as_possible(f, x):
if x is None: return None
fx = apply_as_many_times_as_possible(f, f(x))
if fx is None: return x
return fx
def make_states(init, step):
init = step(init)
while init != None:
yield init
<|code_end|>
, predict the next line using imports from the current file:
from memoize import memoize
and context including class names, function names, and sometimes code from other files:
# Path: memoize.py
# def memoize(f):
# """ Memoization decorator for a function taking one or more arguments. """
# class memodict(dict):
# def __getitem__(self, *key, **kwkey):
# return dict.__getitem__(self, (tuple(key), tuple((k, kwkey[k]) for k in sorted(kwkey.keys()))))
#
# def __missing__(self, key):
# args, kwargs = key
# self[key] = ret = f(*args, **dict(kwargs))
# return ret
#
# return memodict().__getitem__
. Output only the next line. | init = step(init) |
Here is a snippet: <|code_start|>
__all__ = ["join_definitions", "split_statements_to_definitions"]
DEFAULT_VERBOSITY=1
def DEFAULT_LOG(text, level=DEFAULT_VERBOSITY):
if level <= DEFAULT_VERBOSITY:
print(text)
def get_all_nowait_iter(q):
try:
<|code_end|>
. Write the next line using the current file imports:
import re, time
from Popen_noblock import Popen_async, PIPE, STDOUT, Empty
and context from other files:
# Path: Popen_noblock.py
# ON_POSIX = 'posix' in sys.builtin_module_names
# def enqueue_output(out, queue):
# def __init__(self, *args, **kwargs):
# class Popen_async(object):
, which may include functions, classes, or code. Output only the next line. | while True: |
Using the snippet: <|code_start|>
__all__ = ["join_definitions", "split_statements_to_definitions"]
DEFAULT_VERBOSITY=1
def DEFAULT_LOG(text, level=DEFAULT_VERBOSITY):
if level <= DEFAULT_VERBOSITY:
print(text)
def get_all_nowait_iter(q):
try:
while True:
yield q.get_nowait()
except Empty:
pass
def get_all_nowait(q):
return ''.join(get_all_nowait_iter(q))
def get_all_semiwait_iter(q, log=DEFAULT_LOG):
def log_and_return(val):
log(val, level=5)
<|code_end|>
, determine the next line of code. You have imports:
import re, time
from Popen_noblock import Popen_async, PIPE, STDOUT, Empty
and context (class names, function names, or code) available:
# Path: Popen_noblock.py
# ON_POSIX = 'posix' in sys.builtin_module_names
# def enqueue_output(out, queue):
# def __init__(self, *args, **kwargs):
# class Popen_async(object):
. Output only the next line. | return val |
Continue the code snippet: <|code_start|> cur_name, line_num1, cur_definition_names, line_num2, unknown = prompt_reg.search(stderr).groups()
definitions_removed, definitions_shared, definitions_added = get_definitions_diff(last_definitions, cur_definition_names)
# first, to be on the safe side, we add the new
# definitions key to the dict, if it wasn't already there.
if cur_definition_names.strip('|') and cur_definition_names not in cur_definition:
cur_definition[cur_definition_names] = {'statements':[], 'terms_defined':[]}
log((statement, terms_defined, last_definitions, cur_definition_names, cur_definition.get(last_definitions, []), cur_definition.get(cur_definition_names, [])), level=2)
# first, we handle the case where we have just finished
# defining something. This should correspond to
# len(definitions_removed) > 0 and len(terms_defined) > 0.
# If only len(definitions_removed) > 0, then we have
# aborted something. If only len(terms_defined) > 0, then
# we have defined something with a one-liner.
if definitions_removed:
cur_definition[last_definitions]['statements'].append(statement)
cur_definition[last_definitions]['terms_defined'] += terms_defined
if cur_definition_names.strip('|'):
# we are still inside a definition. For now, we
# flatten all definitions.
#
# TODO(jgross): Come up with a better story for
# nested definitions.
cur_definition[cur_definition_names]['statements'] += cur_definition[last_definitions]['statements']
cur_definition[cur_definition_names]['terms_defined'] += cur_definition[last_definitions]['terms_defined']
del cur_definition[last_definitions]
<|code_end|>
. Use current file imports:
import re, time
from Popen_noblock import Popen_async, PIPE, STDOUT, Empty
and context (classes, functions, or code) from other files:
# Path: Popen_noblock.py
# ON_POSIX = 'posix' in sys.builtin_module_names
# def enqueue_output(out, queue):
# def __init__(self, *args, **kwargs):
# class Popen_async(object):
. Output only the next line. | else: |
Given snippet: <|code_start|># 'times': <a list of times for each statement>
# 'output': <a string of the response from coqtop>
# }"""
# p = Popen_async([coqtop, '-q', '-emacs', '-time'], stdout=PIPE, stderr=STDOUT, stdin=PIPE)
# time.sleep(1)
def split_statements_to_definitions(statements, log=DEFAULT_LOG, coqtop='coqtop', coqtop_args=tuple()):
"""Splits a list of statements into chunks which make up
independent definitions/hints/etc."""
p = Popen_async([coqtop, '-q', '-emacs'] + list(coqtop_args), stdout=PIPE, stderr=STDOUT, stdin=PIPE)
time.sleep(1)
prompt_reg = re.compile(r'<prompt>([^<]*?) < ([0-9]+) ([^<]*?) ([0-9]+) < ([^<]*?)</prompt>'.replace(' ', r'\s*'))
defined_reg = re.compile(r'^([^\s]+) is (?:defined|assumed)$', re.MULTILINE)
# aborted_reg = re.compile(r'^Current goal aborted$', re.MULTILINE)
# goal_reg = re.compile(r'^\s*=+\s*$', re.MULTILINE)
# goals and definitions are on stdout, prompts are on stderr
# clear stdout
get_all_semiwait(p.stdout, log=log)
# clear stderr
# get_all_nowait(p.stderr)
rtn = []
cur_definition = {}
last_definitions = '||'
cur_definition_names = '||'
for statement in statements:
if not statement.strip():
continue
log('Write: %s\n\nWait to read...' % statement, level=4)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import re, time
from Popen_noblock import Popen_async, PIPE, STDOUT, Empty
and context:
# Path: Popen_noblock.py
# ON_POSIX = 'posix' in sys.builtin_module_names
# def enqueue_output(out, queue):
# def __init__(self, *args, **kwargs):
# class Popen_async(object):
which might include code, classes, or functions. Output only the next line. | p.stdin.write(statement + '\n\n') |
Given the following code snippet before the placeholder: <|code_start|>
__all__ = ["split_coq_file_contents", "split_coq_file_contents_with_comments", "get_coq_statement_byte_ranges", "UnsupportedCoqVersionError", "postprocess_split_proof_term", "split_leading_comments_and_whitespace"]
def fill_kwargs(kwargs):
ret = {
'log' : DEFAULT_LOG,
'coqc' : 'coqc',
'coqc_args' : tuple(),
}
ret.update(kwargs)
return ret
class UnsupportedCoqVersionError(Exception):
pass
def merge_quotations(statements, sp=' '):
"""If there are an odd number of "s in a statement, assume that we
broke the middle of a string. We recombine that string."""
cur = None
for i in statements:
<|code_end|>
, predict the next line using imports from the current file:
from strip_comments import strip_comments
from custom_arguments import DEFAULT_LOG
from coq_version import get_coq_accepts_time
from util import PY3
if PY3: from util import raw_input
import subprocess
import re
import util
and context including class names, function names, and sometimes code from other files:
# Path: strip_comments.py
# def strip_comments(contents):
# """Strips the comments from coq code in contents.
#
# The strings in contents are only preserved if there are no
# comment-like tokens inside of strings. Stripping should be
# successful and correct, regardless of whether or not there are
# comment-like tokens in strings.
#
# The behavior of this method is undefined if there are any
# notations which change the meaning of '(*', '*)', or '"'.
#
# Note that we take some extra care to leave *) untouched when it
# does not terminate a comment.
# """
# contents = contents.replace('(*', ' (* ').replace('*)', ' *) ')
# tokens = contents.split(' ')
# rtn = []
# is_string = False
# comment_level = 0
# for token in tokens:
# do_append = (comment_level == 0)
# if is_string:
# if token.count('"') % 2 == 1: # there are an odd number of '"' characters, indicating that we've ended the string
# is_string = False
# elif token.count('"') % 2 == 1: # there are an odd number of '"' characters, so we're starting a string
# is_string = True
# elif token == '(*':
# comment_level += 1
# do_append = False
# elif comment_level > 0 and token == '*)':
# comment_level -= 1
# if do_append:
# rtn.append(token)
# return ' '.join(rtn).replace(' (* ', '(*').replace(' *) ', '*)').strip('\n\t ')
#
# Path: custom_arguments.py
# DEFAULT_LOG = make_logger([(DEFAULT_VERBOSITY, sys.stderr)])
#
# Path: coq_version.py
# def get_coq_accepts_time(coqc_prog, **kwargs):
# return get_coq_accepts_option(coqc_prog, '-time', **kwargs)
#
# Path: util.py
# PY3 = False
. Output only the next line. | if i.count('"') % 2 != 0: |
Predict the next line for this snippet: <|code_start|> cur = ''.join(curs) if curs else None
if cur is not None and is_genuine_ending(cur) and comment_level == 0: # clear out cur, if we're done with it
yield cur
cur = None
if cur is not None:
print('Unterminated comment')
yield cur
def split_coq_file_contents(contents):
"""Splits the contents of a coq file into multiple statements.
This is done by finding one or three periods followed by
whitespace. This is a dumb algorithm, but it seems to be (nearly)
the one that ProofGeneral and CoqIDE use.
We additionally merge lines inside of quotations."""
return list(merge_quotations(re.split('(?<=[^\.]\.\.\.)\s|(?<=[^\.]\.)\s', strip_comments(contents))))
def split_coq_file_contents_with_comments(contents):
statements = re.split(r'(?<=[^\.]\.\.\.) |(?<=[^\.]\.) ',
re.sub(r'((?<=[^\.]\.\.\.)\s|(?<=[^\.]\.)\s)', r' \1', contents))
#if contents != ''.join(statements):
# print('Splitting failed (initial split)!')
#qstatements = list(merge_quotations(statements, sp=''))
#if contents != ''.join(qstatements):
# print('Splitting failed (quote merge)!')
#cstatements = list(split_merge_comments(qstatements))
#if contents != ''.join(cstatements):
# print('Splitting failed (comment merge)!')
<|code_end|>
with the help of current file imports:
from strip_comments import strip_comments
from custom_arguments import DEFAULT_LOG
from coq_version import get_coq_accepts_time
from util import PY3
if PY3: from util import raw_input
import subprocess
import re
import util
and context from other files:
# Path: strip_comments.py
# def strip_comments(contents):
# """Strips the comments from coq code in contents.
#
# The strings in contents are only preserved if there are no
# comment-like tokens inside of strings. Stripping should be
# successful and correct, regardless of whether or not there are
# comment-like tokens in strings.
#
# The behavior of this method is undefined if there are any
# notations which change the meaning of '(*', '*)', or '"'.
#
# Note that we take some extra care to leave *) untouched when it
# does not terminate a comment.
# """
# contents = contents.replace('(*', ' (* ').replace('*)', ' *) ')
# tokens = contents.split(' ')
# rtn = []
# is_string = False
# comment_level = 0
# for token in tokens:
# do_append = (comment_level == 0)
# if is_string:
# if token.count('"') % 2 == 1: # there are an odd number of '"' characters, indicating that we've ended the string
# is_string = False
# elif token.count('"') % 2 == 1: # there are an odd number of '"' characters, so we're starting a string
# is_string = True
# elif token == '(*':
# comment_level += 1
# do_append = False
# elif comment_level > 0 and token == '*)':
# comment_level -= 1
# if do_append:
# rtn.append(token)
# return ' '.join(rtn).replace(' (* ', '(*').replace(' *) ', '*)').strip('\n\t ')
#
# Path: custom_arguments.py
# DEFAULT_LOG = make_logger([(DEFAULT_VERBOSITY, sys.stderr)])
#
# Path: coq_version.py
# def get_coq_accepts_time(coqc_prog, **kwargs):
# return get_coq_accepts_option(coqc_prog, '-time', **kwargs)
#
# Path: util.py
# PY3 = False
, which may contain function names, class names, or code. Output only the next line. | return list(split_merge_comments(merge_quotations(statements, sp=''))) |
Based on the snippet: <|code_start|> return ret
class UnsupportedCoqVersionError(Exception):
pass
def merge_quotations(statements, sp=' '):
"""If there are an odd number of "s in a statement, assume that we
broke the middle of a string. We recombine that string."""
cur = None
for i in statements:
if i.count('"') % 2 != 0:
if cur is None:
cur = i
else:
yield (cur + sp + i)
cur = None
elif cur is None:
yield i
else:
cur += sp + i
BRACES = '{}-*+'
def split_leading_braces(statement):
while statement.strip() and statement.strip()[0] in BRACES:
idx = statement.index(statement.strip()[0]) + 1
first, rest = statement[:idx], statement[idx:]
#if 'not_reachable_iff' in statement or 'not_reachable_iff' in first:
# print((first, rest))
<|code_end|>
, predict the immediate next line with the help of imports:
from strip_comments import strip_comments
from custom_arguments import DEFAULT_LOG
from coq_version import get_coq_accepts_time
from util import PY3
if PY3: from util import raw_input
import subprocess
import re
import util
and context (classes, functions, sometimes code) from other files:
# Path: strip_comments.py
# def strip_comments(contents):
# """Strips the comments from coq code in contents.
#
# The strings in contents are only preserved if there are no
# comment-like tokens inside of strings. Stripping should be
# successful and correct, regardless of whether or not there are
# comment-like tokens in strings.
#
# The behavior of this method is undefined if there are any
# notations which change the meaning of '(*', '*)', or '"'.
#
# Note that we take some extra care to leave *) untouched when it
# does not terminate a comment.
# """
# contents = contents.replace('(*', ' (* ').replace('*)', ' *) ')
# tokens = contents.split(' ')
# rtn = []
# is_string = False
# comment_level = 0
# for token in tokens:
# do_append = (comment_level == 0)
# if is_string:
# if token.count('"') % 2 == 1: # there are an odd number of '"' characters, indicating that we've ended the string
# is_string = False
# elif token.count('"') % 2 == 1: # there are an odd number of '"' characters, so we're starting a string
# is_string = True
# elif token == '(*':
# comment_level += 1
# do_append = False
# elif comment_level > 0 and token == '*)':
# comment_level -= 1
# if do_append:
# rtn.append(token)
# return ' '.join(rtn).replace(' (* ', '(*').replace(' *) ', '*)').strip('\n\t ')
#
# Path: custom_arguments.py
# DEFAULT_LOG = make_logger([(DEFAULT_VERBOSITY, sys.stderr)])
#
# Path: coq_version.py
# def get_coq_accepts_time(coqc_prog, **kwargs):
# return get_coq_accepts_option(coqc_prog, '-time', **kwargs)
#
# Path: util.py
# PY3 = False
. Output only the next line. | yield first |
Based on the snippet: <|code_start|> else:
comment_level += i2.count('(*') - i2.count('*)')
if cur is None:
cur = i
else:
cur += i
if cur is not None:
curs = list(split_leading_braces(cur))
while curs and curs[0].strip() in BRACES:
yield curs.pop(0)
cur = ''.join(curs) if curs else None
if cur is not None and is_genuine_ending(cur) and comment_level == 0: # clear out cur, if we're done with it
yield cur
cur = None
if cur is not None:
print('Unterminated comment')
yield cur
def split_coq_file_contents(contents):
"""Splits the contents of a coq file into multiple statements.
This is done by finding one or three periods followed by
whitespace. This is a dumb algorithm, but it seems to be (nearly)
the one that ProofGeneral and CoqIDE use.
We additionally merge lines inside of quotations."""
return list(merge_quotations(re.split('(?<=[^\.]\.\.\.)\s|(?<=[^\.]\.)\s', strip_comments(contents))))
def split_coq_file_contents_with_comments(contents):
<|code_end|>
, predict the immediate next line with the help of imports:
from strip_comments import strip_comments
from custom_arguments import DEFAULT_LOG
from coq_version import get_coq_accepts_time
from util import PY3
if PY3: from util import raw_input
import subprocess
import re
import util
and context (classes, functions, sometimes code) from other files:
# Path: strip_comments.py
# def strip_comments(contents):
# """Strips the comments from coq code in contents.
#
# The strings in contents are only preserved if there are no
# comment-like tokens inside of strings. Stripping should be
# successful and correct, regardless of whether or not there are
# comment-like tokens in strings.
#
# The behavior of this method is undefined if there are any
# notations which change the meaning of '(*', '*)', or '"'.
#
# Note that we take some extra care to leave *) untouched when it
# does not terminate a comment.
# """
# contents = contents.replace('(*', ' (* ').replace('*)', ' *) ')
# tokens = contents.split(' ')
# rtn = []
# is_string = False
# comment_level = 0
# for token in tokens:
# do_append = (comment_level == 0)
# if is_string:
# if token.count('"') % 2 == 1: # there are an odd number of '"' characters, indicating that we've ended the string
# is_string = False
# elif token.count('"') % 2 == 1: # there are an odd number of '"' characters, so we're starting a string
# is_string = True
# elif token == '(*':
# comment_level += 1
# do_append = False
# elif comment_level > 0 and token == '*)':
# comment_level -= 1
# if do_append:
# rtn.append(token)
# return ' '.join(rtn).replace(' (* ', '(*').replace(' *) ', '*)').strip('\n\t ')
#
# Path: custom_arguments.py
# DEFAULT_LOG = make_logger([(DEFAULT_VERBOSITY, sys.stderr)])
#
# Path: coq_version.py
# def get_coq_accepts_time(coqc_prog, **kwargs):
# return get_coq_accepts_option(coqc_prog, '-time', **kwargs)
#
# Path: util.py
# PY3 = False
. Output only the next line. | statements = re.split(r'(?<=[^\.]\.\.\.) |(?<=[^\.]\.) ', |
Here is a snippet: <|code_start|>#!/usr/bin/env python2
from __future__ import with_statement
SCRIPT_DIRECTORY = os.path.dirname(os.path.realpath(__file__))
parser = argparse.ArgumentParser(description='Move various statements out of proof blocks')
parser.add_argument('input_files', metavar='INFILE', nargs='+', type=str,
help='.v files to update')
parser.add_argument('--in-place', '-i', metavar='SUFFIX', dest='suffix', nargs='?', type=str, default='',
help='update files in place (makes backup if SUFFIX supplied)')
add_logging_arguments(parser)
ALL_DEFINITIONS_REG = re.compile(r'^\s*(?:(?:Global|Local|Polymorphic|Monomorphic|Time|Timeout)\s+)?(?:' +
r'Theorem|Lemma|Fact|Remark|Corollary|Proposition|Property' +
r'|Definition|Example|SubClass' +
<|code_end|>
. Write the next line using the current file imports:
import os, sys, shutil, re
from argparse_compat import argparse
from split_file import split_coq_file_contents_with_comments
from strip_comments import strip_comments
from custom_arguments import add_logging_arguments, process_logging_arguments, LOG_ALWAYS
from file_util import write_to_file
from util import PY3
if PY3: from util import raw_input
and context from other files:
# Path: argparse_compat.py
#
# Path: split_file.py
# def split_coq_file_contents_with_comments(contents):
# statements = re.split(r'(?<=[^\.]\.\.\.) |(?<=[^\.]\.) ',
# re.sub(r'((?<=[^\.]\.\.\.)\s|(?<=[^\.]\.)\s)', r' \1', contents))
# #if contents != ''.join(statements):
# # print('Splitting failed (initial split)!')
# #qstatements = list(merge_quotations(statements, sp=''))
# #if contents != ''.join(qstatements):
# # print('Splitting failed (quote merge)!')
# #cstatements = list(split_merge_comments(qstatements))
# #if contents != ''.join(cstatements):
# # print('Splitting failed (comment merge)!')
# return list(split_merge_comments(merge_quotations(statements, sp='')))
#
# Path: strip_comments.py
# def strip_comments(contents):
# """Strips the comments from coq code in contents.
#
# The strings in contents are only preserved if there are no
# comment-like tokens inside of strings. Stripping should be
# successful and correct, regardless of whether or not there are
# comment-like tokens in strings.
#
# The behavior of this method is undefined if there are any
# notations which change the meaning of '(*', '*)', or '"'.
#
# Note that we take some extra care to leave *) untouched when it
# does not terminate a comment.
# """
# contents = contents.replace('(*', ' (* ').replace('*)', ' *) ')
# tokens = contents.split(' ')
# rtn = []
# is_string = False
# comment_level = 0
# for token in tokens:
# do_append = (comment_level == 0)
# if is_string:
# if token.count('"') % 2 == 1: # there are an odd number of '"' characters, indicating that we've ended the string
# is_string = False
# elif token.count('"') % 2 == 1: # there are an odd number of '"' characters, so we're starting a string
# is_string = True
# elif token == '(*':
# comment_level += 1
# do_append = False
# elif comment_level > 0 and token == '*)':
# comment_level -= 1
# if do_append:
# rtn.append(token)
# return ' '.join(rtn).replace(' (* ', '(*').replace(' *) ', '*)').strip('\n\t ')
#
# Path: custom_arguments.py
# def add_logging_arguments(parser):
# parser.add_argument('--verbose', '-v', dest='verbose',
# action='count',
# help='display some extra information by default (does not impact --verbose-log-file)')
# parser.add_argument('--quiet', '-q', dest='quiet',
# action='count',
# help='the inverse of --verbose')
# parser.add_argument('--log-file', '-l', dest='log_files', nargs='+', type=argparse.FileType('w'),
# default=[sys.stderr],
# help='The files to log output to. Use - for stdout.')
# parser.add_argument('--verbose-log-file', dest='verbose_log_files', nargs='+', type=TupleType(int, argparse.FileType('w')),
# default=[],
# help=(('The files to log output to at verbosity other than the default verbosity (%d if no -v/-q arguments are passed); ' +
# 'each argument should be a pair of a verbosity level and a file name. '
# 'Use - for stdout.') % DEFAULT_VERBOSITY))
#
# def process_logging_arguments(args):
# if args.verbose is None: args.verbose = DEFAULT_VERBOSITY
# if args.quiet is None: args.quiet = 0
# args.verbose -= args.quiet
# args.log = make_logger([(args.verbose, f) for f in args.log_files]
# + args.verbose_log_files)
# del args.quiet
# del args.verbose
# return args
#
# LOG_ALWAYS=None
#
# Path: file_util.py
# def write_to_file(file_name, contents, *args, **kwargs):
# return write_bytes_to_file(file_name, contents.replace('\n', os.linesep).encode('utf-8'), *args, **kwargs)
#
# Path: util.py
# PY3 = False
, which may include functions, classes, or code. Output only the next line. | r'|Let|Fixpoint|CoFixpoint' + |
Given snippet: <|code_start|>#!/usr/bin/env python2
from __future__ import with_statement
SCRIPT_DIRECTORY = os.path.dirname(os.path.realpath(__file__))
parser = argparse.ArgumentParser(description='Move various statements out of proof blocks')
parser.add_argument('input_files', metavar='INFILE', nargs='+', type=str,
help='.v files to update')
parser.add_argument('--in-place', '-i', metavar='SUFFIX', dest='suffix', nargs='?', type=str, default='',
help='update files in place (makes backup if SUFFIX supplied)')
add_logging_arguments(parser)
ALL_DEFINITIONS_REG = re.compile(r'^\s*(?:(?:Global|Local|Polymorphic|Monomorphic|Time|Timeout)\s+)?(?:' +
r'Theorem|Lemma|Fact|Remark|Corollary|Proposition|Property' +
r'|Definition|Example|SubClass' +
r'|Let|Fixpoint|CoFixpoint' +
r'|Structure|Coercion|Instance' +
r'|Add Parametric Morphism' +
r')\s', re.MULTILINE)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os, sys, shutil, re
from argparse_compat import argparse
from split_file import split_coq_file_contents_with_comments
from strip_comments import strip_comments
from custom_arguments import add_logging_arguments, process_logging_arguments, LOG_ALWAYS
from file_util import write_to_file
from util import PY3
if PY3: from util import raw_input
and context:
# Path: argparse_compat.py
#
# Path: split_file.py
# def split_coq_file_contents_with_comments(contents):
# statements = re.split(r'(?<=[^\.]\.\.\.) |(?<=[^\.]\.) ',
# re.sub(r'((?<=[^\.]\.\.\.)\s|(?<=[^\.]\.)\s)', r' \1', contents))
# #if contents != ''.join(statements):
# # print('Splitting failed (initial split)!')
# #qstatements = list(merge_quotations(statements, sp=''))
# #if contents != ''.join(qstatements):
# # print('Splitting failed (quote merge)!')
# #cstatements = list(split_merge_comments(qstatements))
# #if contents != ''.join(cstatements):
# # print('Splitting failed (comment merge)!')
# return list(split_merge_comments(merge_quotations(statements, sp='')))
#
# Path: strip_comments.py
# def strip_comments(contents):
# """Strips the comments from coq code in contents.
#
# The strings in contents are only preserved if there are no
# comment-like tokens inside of strings. Stripping should be
# successful and correct, regardless of whether or not there are
# comment-like tokens in strings.
#
# The behavior of this method is undefined if there are any
# notations which change the meaning of '(*', '*)', or '"'.
#
# Note that we take some extra care to leave *) untouched when it
# does not terminate a comment.
# """
# contents = contents.replace('(*', ' (* ').replace('*)', ' *) ')
# tokens = contents.split(' ')
# rtn = []
# is_string = False
# comment_level = 0
# for token in tokens:
# do_append = (comment_level == 0)
# if is_string:
# if token.count('"') % 2 == 1: # there are an odd number of '"' characters, indicating that we've ended the string
# is_string = False
# elif token.count('"') % 2 == 1: # there are an odd number of '"' characters, so we're starting a string
# is_string = True
# elif token == '(*':
# comment_level += 1
# do_append = False
# elif comment_level > 0 and token == '*)':
# comment_level -= 1
# if do_append:
# rtn.append(token)
# return ' '.join(rtn).replace(' (* ', '(*').replace(' *) ', '*)').strip('\n\t ')
#
# Path: custom_arguments.py
# def add_logging_arguments(parser):
# parser.add_argument('--verbose', '-v', dest='verbose',
# action='count',
# help='display some extra information by default (does not impact --verbose-log-file)')
# parser.add_argument('--quiet', '-q', dest='quiet',
# action='count',
# help='the inverse of --verbose')
# parser.add_argument('--log-file', '-l', dest='log_files', nargs='+', type=argparse.FileType('w'),
# default=[sys.stderr],
# help='The files to log output to. Use - for stdout.')
# parser.add_argument('--verbose-log-file', dest='verbose_log_files', nargs='+', type=TupleType(int, argparse.FileType('w')),
# default=[],
# help=(('The files to log output to at verbosity other than the default verbosity (%d if no -v/-q arguments are passed); ' +
# 'each argument should be a pair of a verbosity level and a file name. '
# 'Use - for stdout.') % DEFAULT_VERBOSITY))
#
# def process_logging_arguments(args):
# if args.verbose is None: args.verbose = DEFAULT_VERBOSITY
# if args.quiet is None: args.quiet = 0
# args.verbose -= args.quiet
# args.log = make_logger([(args.verbose, f) for f in args.log_files]
# + args.verbose_log_files)
# del args.quiet
# del args.verbose
# return args
#
# LOG_ALWAYS=None
#
# Path: file_util.py
# def write_to_file(file_name, contents, *args, **kwargs):
# return write_bytes_to_file(file_name, contents.replace('\n', os.linesep).encode('utf-8'), *args, **kwargs)
#
# Path: util.py
# PY3 = False
which might include code, classes, or functions. Output only the next line. | ONELINE_DEFINITIONS_REG = re.compile(r'^\s*(?:(?:Global|Local|Polymorphic|Monomorphic|Time|Timeout)\s+)?(?:' + |
Based on the snippet: <|code_start|>
class PackageController:
user_dir = None
def __init__(self):
sublime_dir = os.path.dirname(sublime.packages_path())
installed_packages_dir = os.path.join(sublime_dir, 'Installed Packages')
packages_dir = os.path.join(sublime_dir, 'Packages')
self.user_dir = os.path.join(packages_dir, 'User')
package_control = os.path.join(installed_packages_dir, "Package Control.sublime-package")
sys.path.append(package_control)
<|code_end|>
, predict the immediate next line with the help of imports:
import sys
import os
import sublime
from .package_resolver import PackageResolver
from package_control.package_manager import PackageManager
from package_control.package_cleanup import PackageCleanup
and context (classes, functions, sometimes code) from other files:
# Path: lib/package_resolver.py
# class PackageResolver(threading.Thread):
# def __init__(self, package_control, packages, to_remove, callback):
# self.package_control = package_control
# self.packages = packages
# self.to_remove = to_remove
# self.callback = callback
# threading.Thread.__init__(self)
#
# def run(self):
# for pkg in self.to_remove:
# self.package_control.remove_package(pkg)
#
# for pkg in self.packages:
# self.package_control.install_package(pkg)
#
# self.callback()
. Output only the next line. | self.package_control = PackageManager() |
Given snippet: <|code_start|> shutil.copyfileobj(templ, target)
target.close()
else:
template_path = "%s/%s" % (sublimious_dir, "templates/.sublimious")
shutil.copyfile(template_path, config_path)
print("[sublimious] no config found. Copied template.")
config_file = load_python_file(config_path)
# Collect all layers and layer configurations
for layer in config_file.layers:
try:
if self.is_zip:
layer_init = __import__("layers.%s.layer" % layer, globals(), locals(), ['Layer'])
else:
layer_init_file = "%s/%s/layer.py" % (sublimious_dir, "layers/%s" % layer)
layer_init = load_python_file(layer_init_file)
except ImportError:
print("[sublimious] tried to load layer '%s' but couldn't import it. Does it exist?" % layer)
continue
self.layers.append(layer_init.Layer())
self.commands.append("layers.%s.commands" % layer)
if self.is_zip:
settings = eval(self.zip_file.read("layers/%s/settings.py" % layer))
else:
layer_settings_file = "%s/%s/settings.py" % (sublimious_dir, "layers/%s" % layer)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import itertools
import os
import shutil
import zipfile
from .io import load_python_file
from .helpers import mergedicts
and context:
# Path: lib/io.py
# def load_python_file(path):
# return SourceFileLoader("", path).load_module()
#
# Path: lib/helpers.py
# def mergedicts(a, b, path=None):
# "merges b into a"
# if path is None:
# path = []
#
# for key in b:
# if key in a:
# if isinstance(a[key], dict) and isinstance(b[key], dict):
# mergedicts(a[key], b[key], path + [str(key)])
# elif a[key] == b[key]:
# pass # same leaf value
# else:
# a[key] = b[key]
# else:
# a[key] = b[key]
# return a
which might include code, classes, or functions. Output only the next line. | settings = eval(open(layer_settings_file, 'r').read()) |
Predict the next line after this snippet: <|code_start|> self.commands = []
self.collected_config = {}
self.user_config = {}
self.is_zip = False
self.zip_file = None
if "sublime-package" in sublimious_dir:
self.is_zip = True
self.zip_file = zipfile.ZipFile(sublimious_dir)
config_path = os.path.expanduser("~/.sublimious")
if not os.path.exists(config_path):
if self.is_zip:
templ = self.zip_file.open("templates/.sublimious")
target = open(config_path, "wb")
shutil.copyfileobj(templ, target)
target.close()
else:
template_path = "%s/%s" % (sublimious_dir, "templates/.sublimious")
shutil.copyfile(template_path, config_path)
print("[sublimious] no config found. Copied template.")
config_file = load_python_file(config_path)
# Collect all layers and layer configurations
for layer in config_file.layers:
try:
if self.is_zip:
<|code_end|>
using the current file's imports:
import itertools
import os
import shutil
import zipfile
from .io import load_python_file
from .helpers import mergedicts
and any relevant context from other files:
# Path: lib/io.py
# def load_python_file(path):
# return SourceFileLoader("", path).load_module()
#
# Path: lib/helpers.py
# def mergedicts(a, b, path=None):
# "merges b into a"
# if path is None:
# path = []
#
# for key in b:
# if key in a:
# if isinstance(a[key], dict) and isinstance(b[key], dict):
# mergedicts(a[key], b[key], path + [str(key)])
# elif a[key] == b[key]:
# pass # same leaf value
# else:
# a[key] = b[key]
# else:
# a[key] = b[key]
# return a
. Output only the next line. | layer_init = __import__("layers.%s.layer" % layer, globals(), locals(), ['Layer']) |
Predict the next line for this snippet: <|code_start|> mu: int,
i_50: float,
tissue_correction: float,
m_reference_adjusted=None):
super().__init__(temp=temp, press=press, chamber=chamber, n_dw=n_dw, p_elec=p_elec,
voltage_reference=voltage_reference, voltage_reduced=voltage_reduced, m_reference=m_reference,
m_opposite=m_opposite, m_reduced=m_reduced, clinical_pdd=clinical_pdd, mu=mu,
i_50=i_50, tissue_correction=tissue_correction,
institution=institution, physicist=physicist, unit=unit,
measurement_date=measurement_date, electrometer=electrometer,
m_reference_adjusted=m_reference_adjusted, cone=cone, energy=energy,
)
@property
def r_50(self) -> float:
"""Depth of the 50% dose value."""
return r_50(i_50=self.i_50)
@property
def dref(self) -> float:
"""Depth of the reference point."""
return d_ref(i_50=self.i_50)
@property
def kq(self) -> float:
"""The kQ value using the updated Muir & Rogers values from their 2014 paper, equation 11, or classically
if kecal is passed."""
return kq_electron(chamber=self.chamber, r_50=self.r_50)
@property
<|code_end|>
with the help of current file imports:
from datetime import datetime
from typing import Optional
from ..core.pdf import PylinacCanvas
from ..core.typing import NumberLike, NumberOrArray
from ..core.utilities import Structure, open_path
import argue
import numpy as np
and context from other files:
# Path: pylinac/core/pdf.py
# class PylinacCanvas:
#
# def __init__(self, filename: str, page_title: str, font: str="Helvetica", metadata: dict=None, metadata_location: tuple=(2, 25.5)):
# self.canvas = Canvas(filename, pagesize=A4)
# self._font = font
# self._title = page_title
# self._metadata = metadata
# self._metadata_location = metadata_location
# self._generate_pylinac_template_theme()
# self._add_metadata()
#
# def add_new_page(self) -> None:
# self.canvas.showPage()
# self._generate_pylinac_template_theme()
# self._add_metadata()
#
# def _add_metadata(self) -> None:
# if self._metadata is None:
# return
# else:
# text = ['Metadata:']
# for key, value in self._metadata.items():
# text.append(f"{key}: {value}")
# self.add_text(text=text, location=self._metadata_location)
#
# def _generate_pylinac_template_theme(self) -> None:
# # draw logo and header separation line
# self.canvas.drawImage(osp.join(osp.dirname(osp.dirname(osp.abspath(__file__))), 'files', 'Pylinac Full cropped.png'),
# 1 * cm, 26.5 * cm, width=5 * cm, height=3 * cm, preserveAspectRatio=True)
# self.canvas.line(1 * cm, 26.5 * cm, 20 * cm, 26.5 * cm)
# # draw title
# self.add_text(text=self._title, location=(7, 28), font_size=24)
# # draw "generated by pylinac" tag
# date = datetime.now().strftime("%B %d, %Y, %H:%M")
# self.add_text(f"Generated with Pylinac v{__version__} on {date}", location=(0.5, 0.5), font_size=8)
#
# def add_text(self, text: Union[str, List[str]], location: Tuple[NumberLike, NumberLike], font_size: int=10) -> None:
# """Generic text drawing function.
#
# Parameters
# ----------
# location : Sequence of two numbers
# The first item is the distance from left edge in cm
# The second item is the distance from bottom edge in cm.
# text : str, list of strings
# Text data; if str, prints single line.
# If list of strings, each list item is printed on its own line.
# font_size : int
# Text font size.
# """
# textobj = self.canvas.beginText()
# textobj.setTextOrigin(location[0]*cm, location[1]*cm)
# textobj.setFont(self._font, int(font_size))
# if isinstance(text, str):
# textobj.textLine(text)
# elif isinstance(text, list):
# for line in text:
# textobj.textLine(line)
# self.canvas.drawText(textobj)
#
# def add_image(self, image_data: io.BytesIO, location: Sequence, dimensions: Sequence, preserve_aspect_ratio: bool=True) -> None:
# image_data.seek(0)
# image = ImageReader(Image.open(image_data))
# self.canvas.drawImage(image, location[0]*cm, location[1]*cm, width=dimensions[0]*cm,
# height=dimensions[1]*cm, preserveAspectRatio=preserve_aspect_ratio)
#
# def finish(self) -> None:
# self.canvas.showPage()
# self.canvas.save()
#
# Path: pylinac/core/typing.py
#
# Path: pylinac/core/utilities.py
# class Structure:
# """A simple structure that assigns the arguments to the object."""
# def __init__(self, **kwargs):
# self.__dict__.update(**kwargs)
#
# def update(self, **kwargs):
# self.__dict__.update(**kwargs)
#
# def open_path(path: str) -> None:
# """Open the specified path in the system default viewer."""
#
# if os.name == 'darwin':
# launcher = "open"
# elif os.name == 'posix':
# launcher = "xdg-open"
# elif os.name == 'nt':
# launcher = "explorer"
# subprocess.call([launcher, path])
, which may contain function names, class names, or code. Output only the next line. | def dose_mu_dref(self) -> float: |
Next line prediction: <|code_start|> cone: str,
mu: int,
i_50: float,
tissue_correction: float,
m_reference_adjusted=None):
super().__init__(temp=temp, press=press, chamber=chamber, n_dw=n_dw, p_elec=p_elec,
voltage_reference=voltage_reference, voltage_reduced=voltage_reduced, m_reference=m_reference,
m_opposite=m_opposite, m_reduced=m_reduced, clinical_pdd=clinical_pdd, mu=mu,
i_50=i_50, tissue_correction=tissue_correction,
institution=institution, physicist=physicist, unit=unit,
measurement_date=measurement_date, electrometer=electrometer,
m_reference_adjusted=m_reference_adjusted, cone=cone, energy=energy,
)
@property
def r_50(self) -> float:
"""Depth of the 50% dose value."""
return r_50(i_50=self.i_50)
@property
def dref(self) -> float:
"""Depth of the reference point."""
return d_ref(i_50=self.i_50)
@property
def kq(self) -> float:
"""The kQ value using the updated Muir & Rogers values from their 2014 paper, equation 11, or classically
if kecal is passed."""
return kq_electron(chamber=self.chamber, r_50=self.r_50)
<|code_end|>
. Use current file imports:
(from datetime import datetime
from typing import Optional
from ..core.pdf import PylinacCanvas
from ..core.typing import NumberLike, NumberOrArray
from ..core.utilities import Structure, open_path
import argue
import numpy as np)
and context including class names, function names, or small code snippets from other files:
# Path: pylinac/core/pdf.py
# class PylinacCanvas:
#
# def __init__(self, filename: str, page_title: str, font: str="Helvetica", metadata: dict=None, metadata_location: tuple=(2, 25.5)):
# self.canvas = Canvas(filename, pagesize=A4)
# self._font = font
# self._title = page_title
# self._metadata = metadata
# self._metadata_location = metadata_location
# self._generate_pylinac_template_theme()
# self._add_metadata()
#
# def add_new_page(self) -> None:
# self.canvas.showPage()
# self._generate_pylinac_template_theme()
# self._add_metadata()
#
# def _add_metadata(self) -> None:
# if self._metadata is None:
# return
# else:
# text = ['Metadata:']
# for key, value in self._metadata.items():
# text.append(f"{key}: {value}")
# self.add_text(text=text, location=self._metadata_location)
#
# def _generate_pylinac_template_theme(self) -> None:
# # draw logo and header separation line
# self.canvas.drawImage(osp.join(osp.dirname(osp.dirname(osp.abspath(__file__))), 'files', 'Pylinac Full cropped.png'),
# 1 * cm, 26.5 * cm, width=5 * cm, height=3 * cm, preserveAspectRatio=True)
# self.canvas.line(1 * cm, 26.5 * cm, 20 * cm, 26.5 * cm)
# # draw title
# self.add_text(text=self._title, location=(7, 28), font_size=24)
# # draw "generated by pylinac" tag
# date = datetime.now().strftime("%B %d, %Y, %H:%M")
# self.add_text(f"Generated with Pylinac v{__version__} on {date}", location=(0.5, 0.5), font_size=8)
#
# def add_text(self, text: Union[str, List[str]], location: Tuple[NumberLike, NumberLike], font_size: int=10) -> None:
# """Generic text drawing function.
#
# Parameters
# ----------
# location : Sequence of two numbers
# The first item is the distance from left edge in cm
# The second item is the distance from bottom edge in cm.
# text : str, list of strings
# Text data; if str, prints single line.
# If list of strings, each list item is printed on its own line.
# font_size : int
# Text font size.
# """
# textobj = self.canvas.beginText()
# textobj.setTextOrigin(location[0]*cm, location[1]*cm)
# textobj.setFont(self._font, int(font_size))
# if isinstance(text, str):
# textobj.textLine(text)
# elif isinstance(text, list):
# for line in text:
# textobj.textLine(line)
# self.canvas.drawText(textobj)
#
# def add_image(self, image_data: io.BytesIO, location: Sequence, dimensions: Sequence, preserve_aspect_ratio: bool=True) -> None:
# image_data.seek(0)
# image = ImageReader(Image.open(image_data))
# self.canvas.drawImage(image, location[0]*cm, location[1]*cm, width=dimensions[0]*cm,
# height=dimensions[1]*cm, preserveAspectRatio=preserve_aspect_ratio)
#
# def finish(self) -> None:
# self.canvas.showPage()
# self.canvas.save()
#
# Path: pylinac/core/typing.py
#
# Path: pylinac/core/utilities.py
# class Structure:
# """A simple structure that assigns the arguments to the object."""
# def __init__(self, **kwargs):
# self.__dict__.update(**kwargs)
#
# def update(self, **kwargs):
# self.__dict__.update(**kwargs)
#
# def open_path(path: str) -> None:
# """Open the specified path in the system default viewer."""
#
# if os.name == 'darwin':
# launcher = "open"
# elif os.name == 'posix':
# launcher = "xdg-open"
# elif os.name == 'nt':
# launcher = "explorer"
# subprocess.call([launcher, path])
. Output only the next line. | @property |
Given snippet: <|code_start|> cone: str,
mu: int,
i_50: float,
tissue_correction: float,
m_reference_adjusted=None):
super().__init__(temp=temp, press=press, chamber=chamber, n_dw=n_dw, p_elec=p_elec,
voltage_reference=voltage_reference, voltage_reduced=voltage_reduced, m_reference=m_reference,
m_opposite=m_opposite, m_reduced=m_reduced, clinical_pdd=clinical_pdd, mu=mu,
i_50=i_50, tissue_correction=tissue_correction,
institution=institution, physicist=physicist, unit=unit,
measurement_date=measurement_date, electrometer=electrometer,
m_reference_adjusted=m_reference_adjusted, cone=cone, energy=energy,
)
@property
def r_50(self) -> float:
"""Depth of the 50% dose value."""
return r_50(i_50=self.i_50)
@property
def dref(self) -> float:
"""Depth of the reference point."""
return d_ref(i_50=self.i_50)
@property
def kq(self) -> float:
"""The kQ value using the updated Muir & Rogers values from their 2014 paper, equation 11, or classically
if kecal is passed."""
return kq_electron(chamber=self.chamber, r_50=self.r_50)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from datetime import datetime
from typing import Optional
from ..core.pdf import PylinacCanvas
from ..core.typing import NumberLike, NumberOrArray
from ..core.utilities import Structure, open_path
import argue
import numpy as np
and context:
# Path: pylinac/core/pdf.py
# class PylinacCanvas:
#
# def __init__(self, filename: str, page_title: str, font: str="Helvetica", metadata: dict=None, metadata_location: tuple=(2, 25.5)):
# self.canvas = Canvas(filename, pagesize=A4)
# self._font = font
# self._title = page_title
# self._metadata = metadata
# self._metadata_location = metadata_location
# self._generate_pylinac_template_theme()
# self._add_metadata()
#
# def add_new_page(self) -> None:
# self.canvas.showPage()
# self._generate_pylinac_template_theme()
# self._add_metadata()
#
# def _add_metadata(self) -> None:
# if self._metadata is None:
# return
# else:
# text = ['Metadata:']
# for key, value in self._metadata.items():
# text.append(f"{key}: {value}")
# self.add_text(text=text, location=self._metadata_location)
#
# def _generate_pylinac_template_theme(self) -> None:
# # draw logo and header separation line
# self.canvas.drawImage(osp.join(osp.dirname(osp.dirname(osp.abspath(__file__))), 'files', 'Pylinac Full cropped.png'),
# 1 * cm, 26.5 * cm, width=5 * cm, height=3 * cm, preserveAspectRatio=True)
# self.canvas.line(1 * cm, 26.5 * cm, 20 * cm, 26.5 * cm)
# # draw title
# self.add_text(text=self._title, location=(7, 28), font_size=24)
# # draw "generated by pylinac" tag
# date = datetime.now().strftime("%B %d, %Y, %H:%M")
# self.add_text(f"Generated with Pylinac v{__version__} on {date}", location=(0.5, 0.5), font_size=8)
#
# def add_text(self, text: Union[str, List[str]], location: Tuple[NumberLike, NumberLike], font_size: int=10) -> None:
# """Generic text drawing function.
#
# Parameters
# ----------
# location : Sequence of two numbers
# The first item is the distance from left edge in cm
# The second item is the distance from bottom edge in cm.
# text : str, list of strings
# Text data; if str, prints single line.
# If list of strings, each list item is printed on its own line.
# font_size : int
# Text font size.
# """
# textobj = self.canvas.beginText()
# textobj.setTextOrigin(location[0]*cm, location[1]*cm)
# textobj.setFont(self._font, int(font_size))
# if isinstance(text, str):
# textobj.textLine(text)
# elif isinstance(text, list):
# for line in text:
# textobj.textLine(line)
# self.canvas.drawText(textobj)
#
# def add_image(self, image_data: io.BytesIO, location: Sequence, dimensions: Sequence, preserve_aspect_ratio: bool=True) -> None:
# image_data.seek(0)
# image = ImageReader(Image.open(image_data))
# self.canvas.drawImage(image, location[0]*cm, location[1]*cm, width=dimensions[0]*cm,
# height=dimensions[1]*cm, preserveAspectRatio=preserve_aspect_ratio)
#
# def finish(self) -> None:
# self.canvas.showPage()
# self.canvas.save()
#
# Path: pylinac/core/typing.py
#
# Path: pylinac/core/utilities.py
# class Structure:
# """A simple structure that assigns the arguments to the object."""
# def __init__(self, **kwargs):
# self.__dict__.update(**kwargs)
#
# def update(self, **kwargs):
# self.__dict__.update(**kwargs)
#
# def open_path(path: str) -> None:
# """Open the specified path in the system default viewer."""
#
# if os.name == 'darwin':
# launcher = "open"
# elif os.name == 'posix':
# launcher = "xdg-open"
# elif os.name == 'nt':
# launcher = "explorer"
# subprocess.call([launcher, path])
which might include code, classes, or functions. Output only the next line. | @property |
Given the code snippet: <|code_start|> mu: int,
i_50: float,
tissue_correction: float,
m_reference_adjusted=None):
super().__init__(temp=temp, press=press, chamber=chamber, n_dw=n_dw, p_elec=p_elec,
voltage_reference=voltage_reference, voltage_reduced=voltage_reduced, m_reference=m_reference,
m_opposite=m_opposite, m_reduced=m_reduced, clinical_pdd=clinical_pdd, mu=mu,
i_50=i_50, tissue_correction=tissue_correction,
institution=institution, physicist=physicist, unit=unit,
measurement_date=measurement_date, electrometer=electrometer,
m_reference_adjusted=m_reference_adjusted, cone=cone, energy=energy,
)
@property
def r_50(self) -> float:
"""Depth of the 50% dose value."""
return r_50(i_50=self.i_50)
@property
def dref(self) -> float:
"""Depth of the reference point."""
return d_ref(i_50=self.i_50)
@property
def kq(self) -> float:
"""The kQ value using the updated Muir & Rogers values from their 2014 paper, equation 11, or classically
if kecal is passed."""
return kq_electron(chamber=self.chamber, r_50=self.r_50)
@property
<|code_end|>
, generate the next line using the imports in this file:
from datetime import datetime
from typing import Optional
from ..core.pdf import PylinacCanvas
from ..core.typing import NumberLike, NumberOrArray
from ..core.utilities import Structure, open_path
import argue
import numpy as np
and context (functions, classes, or occasionally code) from other files:
# Path: pylinac/core/pdf.py
# class PylinacCanvas:
#
# def __init__(self, filename: str, page_title: str, font: str="Helvetica", metadata: dict=None, metadata_location: tuple=(2, 25.5)):
# self.canvas = Canvas(filename, pagesize=A4)
# self._font = font
# self._title = page_title
# self._metadata = metadata
# self._metadata_location = metadata_location
# self._generate_pylinac_template_theme()
# self._add_metadata()
#
# def add_new_page(self) -> None:
# self.canvas.showPage()
# self._generate_pylinac_template_theme()
# self._add_metadata()
#
# def _add_metadata(self) -> None:
# if self._metadata is None:
# return
# else:
# text = ['Metadata:']
# for key, value in self._metadata.items():
# text.append(f"{key}: {value}")
# self.add_text(text=text, location=self._metadata_location)
#
# def _generate_pylinac_template_theme(self) -> None:
# # draw logo and header separation line
# self.canvas.drawImage(osp.join(osp.dirname(osp.dirname(osp.abspath(__file__))), 'files', 'Pylinac Full cropped.png'),
# 1 * cm, 26.5 * cm, width=5 * cm, height=3 * cm, preserveAspectRatio=True)
# self.canvas.line(1 * cm, 26.5 * cm, 20 * cm, 26.5 * cm)
# # draw title
# self.add_text(text=self._title, location=(7, 28), font_size=24)
# # draw "generated by pylinac" tag
# date = datetime.now().strftime("%B %d, %Y, %H:%M")
# self.add_text(f"Generated with Pylinac v{__version__} on {date}", location=(0.5, 0.5), font_size=8)
#
# def add_text(self, text: Union[str, List[str]], location: Tuple[NumberLike, NumberLike], font_size: int=10) -> None:
# """Generic text drawing function.
#
# Parameters
# ----------
# location : Sequence of two numbers
# The first item is the distance from left edge in cm
# The second item is the distance from bottom edge in cm.
# text : str, list of strings
# Text data; if str, prints single line.
# If list of strings, each list item is printed on its own line.
# font_size : int
# Text font size.
# """
# textobj = self.canvas.beginText()
# textobj.setTextOrigin(location[0]*cm, location[1]*cm)
# textobj.setFont(self._font, int(font_size))
# if isinstance(text, str):
# textobj.textLine(text)
# elif isinstance(text, list):
# for line in text:
# textobj.textLine(line)
# self.canvas.drawText(textobj)
#
# def add_image(self, image_data: io.BytesIO, location: Sequence, dimensions: Sequence, preserve_aspect_ratio: bool=True) -> None:
# image_data.seek(0)
# image = ImageReader(Image.open(image_data))
# self.canvas.drawImage(image, location[0]*cm, location[1]*cm, width=dimensions[0]*cm,
# height=dimensions[1]*cm, preserveAspectRatio=preserve_aspect_ratio)
#
# def finish(self) -> None:
# self.canvas.showPage()
# self.canvas.save()
#
# Path: pylinac/core/typing.py
#
# Path: pylinac/core/utilities.py
# class Structure:
# """A simple structure that assigns the arguments to the object."""
# def __init__(self, **kwargs):
# self.__dict__.update(**kwargs)
#
# def update(self, **kwargs):
# self.__dict__.update(**kwargs)
#
# def open_path(path: str) -> None:
# """Open the specified path in the system default viewer."""
#
# if os.name == 'darwin':
# launcher = "open"
# elif os.name == 'posix':
# launcher = "xdg-open"
# elif os.name == 'nt':
# launcher = "explorer"
# subprocess.call([launcher, path])
. Output only the next line. | def dose_mu_dref(self) -> float: |
Predict the next line for this snippet: <|code_start|> m_opposite: NumberOrArray,
m_reduced: NumberOrArray,
cone: str,
mu: int,
i_50: float,
tissue_correction: float,
m_reference_adjusted=None):
super().__init__(temp=temp, press=press, chamber=chamber, n_dw=n_dw, p_elec=p_elec,
voltage_reference=voltage_reference, voltage_reduced=voltage_reduced, m_reference=m_reference,
m_opposite=m_opposite, m_reduced=m_reduced, clinical_pdd=clinical_pdd, mu=mu,
i_50=i_50, tissue_correction=tissue_correction,
institution=institution, physicist=physicist, unit=unit,
measurement_date=measurement_date, electrometer=electrometer,
m_reference_adjusted=m_reference_adjusted, cone=cone, energy=energy,
)
@property
def r_50(self) -> float:
"""Depth of the 50% dose value."""
return r_50(i_50=self.i_50)
@property
def dref(self) -> float:
"""Depth of the reference point."""
return d_ref(i_50=self.i_50)
@property
def kq(self) -> float:
"""The kQ value using the updated Muir & Rogers values from their 2014 paper, equation 11, or classically
if kecal is passed."""
<|code_end|>
with the help of current file imports:
from datetime import datetime
from typing import Optional
from ..core.pdf import PylinacCanvas
from ..core.typing import NumberLike, NumberOrArray
from ..core.utilities import Structure, open_path
import argue
import numpy as np
and context from other files:
# Path: pylinac/core/pdf.py
# class PylinacCanvas:
#
# def __init__(self, filename: str, page_title: str, font: str="Helvetica", metadata: dict=None, metadata_location: tuple=(2, 25.5)):
# self.canvas = Canvas(filename, pagesize=A4)
# self._font = font
# self._title = page_title
# self._metadata = metadata
# self._metadata_location = metadata_location
# self._generate_pylinac_template_theme()
# self._add_metadata()
#
# def add_new_page(self) -> None:
# self.canvas.showPage()
# self._generate_pylinac_template_theme()
# self._add_metadata()
#
# def _add_metadata(self) -> None:
# if self._metadata is None:
# return
# else:
# text = ['Metadata:']
# for key, value in self._metadata.items():
# text.append(f"{key}: {value}")
# self.add_text(text=text, location=self._metadata_location)
#
# def _generate_pylinac_template_theme(self) -> None:
# # draw logo and header separation line
# self.canvas.drawImage(osp.join(osp.dirname(osp.dirname(osp.abspath(__file__))), 'files', 'Pylinac Full cropped.png'),
# 1 * cm, 26.5 * cm, width=5 * cm, height=3 * cm, preserveAspectRatio=True)
# self.canvas.line(1 * cm, 26.5 * cm, 20 * cm, 26.5 * cm)
# # draw title
# self.add_text(text=self._title, location=(7, 28), font_size=24)
# # draw "generated by pylinac" tag
# date = datetime.now().strftime("%B %d, %Y, %H:%M")
# self.add_text(f"Generated with Pylinac v{__version__} on {date}", location=(0.5, 0.5), font_size=8)
#
# def add_text(self, text: Union[str, List[str]], location: Tuple[NumberLike, NumberLike], font_size: int=10) -> None:
# """Generic text drawing function.
#
# Parameters
# ----------
# location : Sequence of two numbers
# The first item is the distance from left edge in cm
# The second item is the distance from bottom edge in cm.
# text : str, list of strings
# Text data; if str, prints single line.
# If list of strings, each list item is printed on its own line.
# font_size : int
# Text font size.
# """
# textobj = self.canvas.beginText()
# textobj.setTextOrigin(location[0]*cm, location[1]*cm)
# textobj.setFont(self._font, int(font_size))
# if isinstance(text, str):
# textobj.textLine(text)
# elif isinstance(text, list):
# for line in text:
# textobj.textLine(line)
# self.canvas.drawText(textobj)
#
# def add_image(self, image_data: io.BytesIO, location: Sequence, dimensions: Sequence, preserve_aspect_ratio: bool=True) -> None:
# image_data.seek(0)
# image = ImageReader(Image.open(image_data))
# self.canvas.drawImage(image, location[0]*cm, location[1]*cm, width=dimensions[0]*cm,
# height=dimensions[1]*cm, preserveAspectRatio=preserve_aspect_ratio)
#
# def finish(self) -> None:
# self.canvas.showPage()
# self.canvas.save()
#
# Path: pylinac/core/typing.py
#
# Path: pylinac/core/utilities.py
# class Structure:
# """A simple structure that assigns the arguments to the object."""
# def __init__(self, **kwargs):
# self.__dict__.update(**kwargs)
#
# def update(self, **kwargs):
# self.__dict__.update(**kwargs)
#
# def open_path(path: str) -> None:
# """Open the specified path in the system default viewer."""
#
# if os.name == 'darwin':
# launcher = "open"
# elif os.name == 'posix':
# launcher = "xdg-open"
# elif os.name == 'nt':
# launcher = "explorer"
# subprocess.call([launcher, path])
, which may contain function names, class names, or code. Output only the next line. | return kq_electron(chamber=self.chamber, r_50=self.r_50) |
Given the code snippet: <|code_start|> bb_shift_vector = Vector(x=0.3, y=-0.2, z=0.3)
class KatyiX2(WinstonLutzMixin, TestCase):
file_path = ['Katy iX', '2.zip']
num_images = 17
gantry_iso_size = 0.9
collimator_iso_size = 0.8
couch_iso_size = 1.5
cax2bb_max_distance = 1.1
cax2bb_median_distance = 0.5
bb_shift_vector = Vector(x=0.4, y=-0.1, z=0.1)
class KatyiX3(WinstonLutzMixin, TestCase):
file_path = ['Katy iX', '3 (with crosshair).zip']
num_images = 17
gantry_iso_size = 1.1
collimator_iso_size = 1.3
couch_iso_size = 1.8
cax2bb_max_distance = 1.25
cax2bb_median_distance = 0.8
bb_shift_vector = Vector(x=-0.3, y=0.4, z=-0.5)
class KatyTB0(WinstonLutzMixin, TestCase):
file_path = ['Katy TB', '0.zip']
num_images = 17
gantry_iso_size = 0.9
collimator_iso_size = 0.8
<|code_end|>
, generate the next line using the imports in this file:
from unittest import TestCase
from tests_basic.test_winstonlutz import WinstonLutzMixin, Vector
import numpy as np
and context (functions, classes, or occasionally code) from other files:
# Path: tests_basic/test_winstonlutz.py
# TEST_DIR = 'Winston-Lutz'
# class TestWLLoading(TestCase, FromDemoImageTesterMixin, FromURLTesterMixin):
# class GeneralTests(TestCase):
# class TestPublishPDF(TestCase):
# class TestPlottingSaving(TestCase):
# class WinstonLutzMixin(CloudFileMixin):
# class WLDemo(WinstonLutzMixin, TestCase):
# class WLPerfect30x8(WinstonLutzMixin, TestCase):
# class WLPerfect30x2(WinstonLutzMixin, TestCase):
# class WLPerfect10x4(WinstonLutzMixin, TestCase):
# class WLNoisy30x5(WinstonLutzMixin, TestCase):
# class WLLateral3mm(WinstonLutzMixin, TestCase):
# class WLLongitudinal3mm(WinstonLutzMixin, TestCase):
# class WLVertical3mm(WinstonLutzMixin, TestCase):
# class WLDontUseFileNames(WinstonLutzMixin, TestCase):
# class WLUseFileNames(WinstonLutzMixin, TestCase):
# class WLBadFilenames(TestCase):
# def test_loading_1_image_fails(self):
# def test_invalid_dir(self):
# def test_load_from_file_object(self):
# def test_load_from_stream(self):
# def test_load_2d_from_stream(self):
# def setUpClass(cls):
# def test_run_demo(self):
# def test_results(self):
# def test_not_yet_analyzed(self):
# def test_str_or_enum(self):
# def test_bb_override(self):
# def test_bb_shift_instructions(self):
# def test_results_data(self):
# def test_bb_too_far_away_fails(self):
# def setUpClass(cls):
# def test_publish_pdf(self):
# def test_publish_w_metadata_and_notes(self):
# def setUp(self):
# def tearDownClass(cls):
# def test_plot(self):
# def test_save(self):
# def test_plot_wo_all_axes(self):
# def setUpClass(cls):
# def test_number_of_images(self):
# def test_gantry_iso(self):
# def test_collimator_iso(self):
# def test_couch_iso(self):
# def test_epid_deviation(self):
# def test_bb_max_distance(self):
# def test_bb_median_distance(self):
# def test_bb_shift_vector(self):
# def test_known_axis_of_rotation(self):
# def setUpClass(cls):
# def test_bad_filenames(self):
. Output only the next line. | couch_iso_size = 1.3 |
Next line prediction: <|code_start|>
class KatyTB2(WinstonLutzMixin, TestCase):
file_path = ['Katy TB', '2.zip']
num_images = 17
gantry_iso_size = 1
collimator_iso_size = 0.7
couch_iso_size = 0.7
cax2bb_max_distance = 1.1
cax2bb_median_distance = 0.4
bb_shift_vector = Vector(x=0.0, y=-0.2, z=-0.6)
class ChicagoTBFinal(WinstonLutzMixin, TestCase):
# verified independently
file_path = ['Chicago', 'WL-Final_C&G&C_Final.zip']
num_images = 17
gantry_iso_size = 0.91
collimator_iso_size = 0.1
couch_iso_size = 0.3
cax2bb_max_distance = 0.5
cax2bb_median_distance = 0.3
bb_shift_vector = Vector(y=0.1)
class ChicagoTB52915(WinstonLutzMixin, TestCase):
file_path = ['Chicago', 'WL_05-29-15_Final.zip']
num_images = 16
gantry_iso_size = 0.6
collimator_iso_size = 0.3
<|code_end|>
. Use current file imports:
(from unittest import TestCase
from tests_basic.test_winstonlutz import WinstonLutzMixin, Vector
import numpy as np)
and context including class names, function names, or small code snippets from other files:
# Path: tests_basic/test_winstonlutz.py
# TEST_DIR = 'Winston-Lutz'
# class TestWLLoading(TestCase, FromDemoImageTesterMixin, FromURLTesterMixin):
# class GeneralTests(TestCase):
# class TestPublishPDF(TestCase):
# class TestPlottingSaving(TestCase):
# class WinstonLutzMixin(CloudFileMixin):
# class WLDemo(WinstonLutzMixin, TestCase):
# class WLPerfect30x8(WinstonLutzMixin, TestCase):
# class WLPerfect30x2(WinstonLutzMixin, TestCase):
# class WLPerfect10x4(WinstonLutzMixin, TestCase):
# class WLNoisy30x5(WinstonLutzMixin, TestCase):
# class WLLateral3mm(WinstonLutzMixin, TestCase):
# class WLLongitudinal3mm(WinstonLutzMixin, TestCase):
# class WLVertical3mm(WinstonLutzMixin, TestCase):
# class WLDontUseFileNames(WinstonLutzMixin, TestCase):
# class WLUseFileNames(WinstonLutzMixin, TestCase):
# class WLBadFilenames(TestCase):
# def test_loading_1_image_fails(self):
# def test_invalid_dir(self):
# def test_load_from_file_object(self):
# def test_load_from_stream(self):
# def test_load_2d_from_stream(self):
# def setUpClass(cls):
# def test_run_demo(self):
# def test_results(self):
# def test_not_yet_analyzed(self):
# def test_str_or_enum(self):
# def test_bb_override(self):
# def test_bb_shift_instructions(self):
# def test_results_data(self):
# def test_bb_too_far_away_fails(self):
# def setUpClass(cls):
# def test_publish_pdf(self):
# def test_publish_w_metadata_and_notes(self):
# def setUp(self):
# def tearDownClass(cls):
# def test_plot(self):
# def test_save(self):
# def test_plot_wo_all_axes(self):
# def setUpClass(cls):
# def test_number_of_images(self):
# def test_gantry_iso(self):
# def test_collimator_iso(self):
# def test_couch_iso(self):
# def test_epid_deviation(self):
# def test_bb_max_distance(self):
# def test_bb_median_distance(self):
# def test_bb_shift_vector(self):
# def test_known_axis_of_rotation(self):
# def setUpClass(cls):
# def test_bad_filenames(self):
. Output only the next line. | couch_iso_size = 0.3 |
Using the snippet: <|code_start|> assert c == co
assert ro == 355
g = 355
c = 355
r = 355
go, co, ro = convert(input_scale=MachineScale.IEC61217, output_scale=MachineScale.VARIAN_IEC, gantry=g, collimator=c, rotation=r)
assert g == go
assert c == co
assert ro == 5
def test_varian_iec_to_iec():
g = 5
c = 5
r = 5
go, co, ro = convert(input_scale=MachineScale.VARIAN_IEC, output_scale=MachineScale.IEC61217, gantry=g, collimator=c, rotation=r)
assert g == go
assert c == co
assert ro == 355
g = 355
c = 355
r = 355
go, co, ro = convert(input_scale=MachineScale.VARIAN_IEC, output_scale=MachineScale.IEC61217, gantry=g, collimator=c, rotation=r)
assert g == go
assert c == co
assert ro == 5
<|code_end|>
, determine the next line of code. You have imports:
from pylinac.core.scale import MachineScale, convert
and context (class names, function names, or code) available:
# Path: pylinac/core/scale.py
# class MachineScale(Enum):
# """Possible machine scales. Used for specifying input and and output scales for conversion.
# The enum keys are conversion functions for each axis relative to IEC 61217"""
#
# IEC61217 = {
# "gantry_to_iec": noop,
# "collimator_to_iec": noop,
# "rotation_to_iec": noop,
# "gantry_from_iec": noop,
# "collimator_from_iec": noop,
# "rotation_from_iec": noop,
# }
# ELEKTA_IEC = {
# "gantry_to_iec": noop,
# "collimator_to_iec": noop,
# "rotation_to_iec": mirror_360,
# "gantry_from_iec": noop,
# "collimator_from_iec": noop,
# "rotation_from_iec": mirror_360,
# }
# VARIAN_IEC = {
# "gantry_to_iec": noop,
# "collimator_to_iec": noop,
# "rotation_to_iec": mirror_360,
# "gantry_from_iec": noop,
# "collimator_from_iec": noop,
# "rotation_from_iec": mirror_360,
# }
# VARIAN_STANDARD = {
# "gantry_to_iec": shift_and_mirror_360,
# "collimator_to_iec": shift_and_mirror_360,
# "rotation_to_iec": shift_and_mirror_360,
# "gantry_from_iec": inv_shift_and_mirror_360,
# "collimator_from_iec": inv_shift_and_mirror_360,
# "rotation_from_iec": inv_shift_and_mirror_360,
# }
#
# def convert(
# input_scale: MachineScale,
# output_scale: MachineScale,
# gantry: float,
# collimator: float,
# rotation: float,
# ) -> Tuple[float, float, float]:
# """Convert from one coordinate scale to another. Returns gantry, collimator, rotation."""
# # convert to IEC61217 since everything is defined relative to it
# g = input_scale.value["gantry_to_iec"](gantry)
# c = input_scale.value["collimator_to_iec"](collimator)
# r = input_scale.value["rotation_to_iec"](rotation)
# # now apply the inverse to go from 61217 to output scale
# g_out = output_scale.value["gantry_from_iec"](g)
# c_out = output_scale.value["collimator_from_iec"](c)
# r_out = output_scale.value["rotation_from_iec"](r)
# return g_out, c_out, r_out
. Output only the next line. | def test_iec_to_varian_standard(): |
Continue the code snippet: <|code_start|>
def test_iec_to_iec():
# should return the same values
g = 5
c = 5
r = 5
go, co, ro = convert(input_scale=MachineScale.IEC61217, output_scale=MachineScale.IEC61217, gantry=g, collimator=c, rotation=r)
assert g == go
assert c == co
assert r == ro
g = 355
c = 355
r = 355
go, co, ro = convert(input_scale=MachineScale.IEC61217, output_scale=MachineScale.IEC61217, gantry=g, collimator=c, rotation=r)
assert g == go
assert c == co
assert r == ro
def test_iec_to_varian_iec():
g = 5
c = 5
<|code_end|>
. Use current file imports:
from pylinac.core.scale import MachineScale, convert
and context (classes, functions, or code) from other files:
# Path: pylinac/core/scale.py
# class MachineScale(Enum):
# """Possible machine scales. Used for specifying input and and output scales for conversion.
# The enum keys are conversion functions for each axis relative to IEC 61217"""
#
# IEC61217 = {
# "gantry_to_iec": noop,
# "collimator_to_iec": noop,
# "rotation_to_iec": noop,
# "gantry_from_iec": noop,
# "collimator_from_iec": noop,
# "rotation_from_iec": noop,
# }
# ELEKTA_IEC = {
# "gantry_to_iec": noop,
# "collimator_to_iec": noop,
# "rotation_to_iec": mirror_360,
# "gantry_from_iec": noop,
# "collimator_from_iec": noop,
# "rotation_from_iec": mirror_360,
# }
# VARIAN_IEC = {
# "gantry_to_iec": noop,
# "collimator_to_iec": noop,
# "rotation_to_iec": mirror_360,
# "gantry_from_iec": noop,
# "collimator_from_iec": noop,
# "rotation_from_iec": mirror_360,
# }
# VARIAN_STANDARD = {
# "gantry_to_iec": shift_and_mirror_360,
# "collimator_to_iec": shift_and_mirror_360,
# "rotation_to_iec": shift_and_mirror_360,
# "gantry_from_iec": inv_shift_and_mirror_360,
# "collimator_from_iec": inv_shift_and_mirror_360,
# "rotation_from_iec": inv_shift_and_mirror_360,
# }
#
# def convert(
# input_scale: MachineScale,
# output_scale: MachineScale,
# gantry: float,
# collimator: float,
# rotation: float,
# ) -> Tuple[float, float, float]:
# """Convert from one coordinate scale to another. Returns gantry, collimator, rotation."""
# # convert to IEC61217 since everything is defined relative to it
# g = input_scale.value["gantry_to_iec"](gantry)
# c = input_scale.value["collimator_to_iec"](collimator)
# r = input_scale.value["rotation_to_iec"](rotation)
# # now apply the inverse to go from 61217 to output scale
# g_out = output_scale.value["gantry_from_iec"](g)
# c_out = output_scale.value["collimator_from_iec"](c)
# r_out = output_scale.value["rotation_from_iec"](r)
# return g_out, c_out, r_out
. Output only the next line. | r = 5 |
Predict the next line for this snippet: <|code_start|>
class TestMTF(unittest.TestCase):
def test_normal_mtf(self):
pair_units = (0.1, 0.2, 0.3)
maxs = (500, 300, 100)
mins = (25, 50, 75)
m = MTF(pair_units, maxs, mins)
rm = m.relative_resolution(x=50)
self.assertAlmostEqual(rm, 0.24, delta=0.03)
<|code_end|>
with the help of current file imports:
import unittest
from pylinac.core.mtf import MTF
and context from other files:
# Path: pylinac/core/mtf.py
# class MTF:
# """This class will calculate relative MTF"""
#
# def __init__(self, lp_spacings: Sequence[float], lp_maximums: Sequence[float], lp_minimums: Sequence[float]):
# """
#
# Parameters
# ----------
# lp_spacings : sequence of floats
# These are the physical spacings per unit distance. E.g. 0.1 line pairs/mm.
# lp_maximums : sequence of floats
# These are the maximum values of the sample ROIs.
# lp_minimums : sequence of floats
# These are the minimum values of the sample ROIs.
# """
# self.spacings = lp_spacings
# self.maximums = lp_maximums
# self.minimums = lp_minimums
# self.mtfs = {}
# self.norm_mtfs = {}
# for (spacing, max, min) in zip(lp_spacings, lp_maximums, lp_minimums):
# self.mtfs[spacing] = (max - min) / (max + min)
# # sort according to spacings
# self.mtfs = {k: v for k, v in sorted(self.mtfs.items(), key=lambda x: x[0])}
# for key, value in self.mtfs.items():
# self.norm_mtfs[key] = value / self.mtfs[lp_spacings[0]] # normalize to first region
#
# # check that the MTF drops monotonically by measuring the deltas between MTFs
# # if the delta is increasing it means the MTF rose on a subsequent value
# max_delta = np.max(np.diff(list(self.norm_mtfs.values())))
# if max_delta > 0:
# warnings.warn("The MTF does not drop monotonically; be sure the ROIs are correctly aligned.")
#
# @argue.bounds(x=(0, 100))
# def relative_resolution(self, x=50) -> float:
# """Return the line pair value at the given rMTF resolution value.
#
# Parameters
# ----------
# x : float
# The percentage of the rMTF to determine the line pair value. Must be between 0 and 100.
# """
# f = interp1d(list(self.norm_mtfs.values()), list(self.norm_mtfs.keys()), fill_value='extrapolate')
# mtf = f(x / 100)
# if mtf > max(self.spacings):
# warnings.warn(f"MTF resolution wasn't calculated for {x}% that was asked for. The value returned is an extrapolation. Use a higher % MTF to get a non-interpolated value.")
# return float(mtf)
#
# @classmethod
# def from_high_contrast_diskset(cls, spacings: Sequence[float], diskset: Sequence[HighContrastDiskROI]):
# """Construct the MTF using high contrast disks from the ROI module."""
# maximums = [roi.max for roi in diskset]
# minimums = [roi.min for roi in diskset]
# return cls(spacings, maximums, minimums)
, which may contain function names, class names, or code. Output only the next line. | rm = m.relative_resolution(x=90) |
Continue the code snippet: <|code_start|># Copyright 2011 Fred Hatfull
#
# This file is part of Partify.
#
# Partify is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Partify is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Partify. If not, see <http://www.gnu.org/licenses/>.
# Be careful with this...
try:
idle_event_queue
except NameError:
<|code_end|>
. Use current file imports:
import time
from multiprocessing import Event, Manager, Queue
from partify import ipc
from partify.models import PlayQueueEntry
from testing.data.sample_tracks import sample_tracks
and context (classes, functions, or code) from other files:
# Path: partify/ipc.py
# def init_desired_player_state():
# def update_desired_player_state(state, transition_fn):
# def get_desired_player_state():
# def init_times():
# def update_time(key, time):
# def get_time(key):
# def init_mpd_lock():
# def get_mpd_lock():
# def release_mpd_lock():
#
# Path: partify/models.py
# class PlayQueueEntry(db.Model):
# """Represents a playlist queue entry. These only live until the track they represent is played,
# then they are deleted.
#
# * **id**: The :class:`PlayQueueEntry`'s unique ID
# * **track, track_id**: The track that is represented by this :class:`PlayQueueEntry`
# * **user, user_id**: The user that queued this track
# * **mpd_id**: The ID used by Mopidy internally for this queue entry
# * **time_added**: The datetime that this track was queued
# * **user_priority**: The priority of this track in the user's queue
# * **playback_priority**: The playback priority in the global queue
# """
# __tablename__ = "play_queue_entry"
#
# id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# track_id = db.Column(db.Integer, db.ForeignKey('track.id'))
# track = db.relationship("Track")
# user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
# user = db.relationship("User")
# mpd_id = db.Column(db.Integer) # This SHOULD be unique... but since ensuring consistency isn't atomic yet we'll have to just best-effort it
# time_added = db.Column(db.DateTime, default=datetime.datetime.now)
# user_priority = db.Column(db.Integer, default=lambda: (db.session.query(db.func.max(PlayQueueEntry.user_priority)).first()[0] or 0) + 1)
# playback_priority = db.Column(db.BigInteger, default=lambda: (db.session.query(db.func.max(PlayQueueEntry.playback_priority)).first()[0] or 0) + 1)
#
# def __repr__(self):
# return "<Track %r (MPD %r) queued by %r at %r with priority %r (queue position %r)>" % (self.track, self.mpd_id, self.user, self.time_added, self.user_priority, self.playback_priority)
#
# def as_dict(self):
# # I'm not sure why a list comprehension into a dict doesn't work here...
# d = {}
# for attr in ('title', 'artist', 'album', 'spotify_url', 'date', 'length'):
# d[attr] = getattr(self.track, attr)
# for attr in ('id', 'mpd_id', 'playback_priority', 'user_priority'):
# d[attr] = getattr(self, attr)
# d['time_added'] = self.time_added.ctime()
# d['user'] = getattr(self.user, 'name', 'Anonymous')
# d['username'] = getattr(self.user, 'username', 'anonymous')
# d['user_id'] = self.user_id
# return d
#
# Path: testing/data/sample_tracks.py
. Output only the next line. | idle_event_queue = Queue() |
Given snippet: <|code_start|>
@app.before_request
def load_viewer():
g.viewer = get_viewer_session()
if g.viewer and sentry:
sentry.user_context({
'id': g.viewer.account.id,
'username': g.viewer.account.screen_name,
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from app import app, db, sentry
from flask import g, render_template, make_response, redirect, request
from libforget.auth import get_viewer_session, set_session_cookie
import version
import libforget.version
and context:
# Path: app.py
# def inject_static():
# def static(filename, **kwargs):
# def install_security_headers(resp):
#
# Path: libforget/auth.py
# def get_viewer_session():
# from model import Session
# sid = request.cookies.get('forget_sid', None)
# if sid:
# return Session.query.get(sid)
#
# def set_session_cookie(session, response, secure=True):
# response.set_cookie(
# 'forget_sid', session.id,
# max_age=60*60*48,
# httponly=True,
# secure=secure)
which might include code, classes, or functions. Output only the next line. | 'service': g.viewer.account.service |
Continue the code snippet: <|code_start|>
@app.before_request
def load_viewer():
g.viewer = get_viewer_session()
if g.viewer and sentry:
sentry.user_context({
'id': g.viewer.account.id,
'username': g.viewer.account.screen_name,
'service': g.viewer.account.service
})
@app.context_processor
def inject_version():
v = version.get_versions()
return dict(
version=v['version'],
repo_url=libforget.version.url_for_version(v),
)
@app.context_processor
def inject_sentry():
if sentry:
return dict(sentry=True)
return dict()
@app.after_request
<|code_end|>
. Use current file imports:
from app import app, db, sentry
from flask import g, render_template, make_response, redirect, request
from libforget.auth import get_viewer_session, set_session_cookie
import version
import libforget.version
and context (classes, functions, or code) from other files:
# Path: app.py
# def inject_static():
# def static(filename, **kwargs):
# def install_security_headers(resp):
#
# Path: libforget/auth.py
# def get_viewer_session():
# from model import Session
# sid = request.cookies.get('forget_sid', None)
# if sid:
# return Session.query.get(sid)
#
# def set_session_cookie(session, response, secure=True):
# response.set_cookie(
# 'forget_sid', session.id,
# max_age=60*60*48,
# httponly=True,
# secure=secure)
. Output only the next line. | def touch_viewer(resp): |
Given the code snippet: <|code_start|> 'service': g.viewer.account.service
})
@app.context_processor
def inject_version():
v = version.get_versions()
return dict(
version=v['version'],
repo_url=libforget.version.url_for_version(v),
)
@app.context_processor
def inject_sentry():
if sentry:
return dict(sentry=True)
return dict()
@app.after_request
def touch_viewer(resp):
if 'viewer' in g and g.viewer:
set_session_cookie(g.viewer, resp, app.config.get('HTTPS'))
g.viewer.touch()
db.session.commit()
return resp
@app.errorhandler(404)
<|code_end|>
, generate the next line using the imports in this file:
from app import app, db, sentry
from flask import g, render_template, make_response, redirect, request
from libforget.auth import get_viewer_session, set_session_cookie
import version
import libforget.version
and context (functions, classes, or occasionally code) from other files:
# Path: app.py
# def inject_static():
# def static(filename, **kwargs):
# def install_security_headers(resp):
#
# Path: libforget/auth.py
# def get_viewer_session():
# from model import Session
# sid = request.cookies.get('forget_sid', None)
# if sid:
# return Session.query.get(sid)
#
# def set_session_cookie(session, response, secure=True):
# response.set_cookie(
# 'forget_sid', session.id,
# max_age=60*60*48,
# httponly=True,
# secure=secure)
. Output only the next line. | def not_found(e): |
Continue the code snippet: <|code_start|>
@app.before_request
def load_viewer():
g.viewer = get_viewer_session()
if g.viewer and sentry:
sentry.user_context({
'id': g.viewer.account.id,
'username': g.viewer.account.screen_name,
'service': g.viewer.account.service
})
@app.context_processor
def inject_version():
v = version.get_versions()
<|code_end|>
. Use current file imports:
from app import app, db, sentry
from flask import g, render_template, make_response, redirect, request
from libforget.auth import get_viewer_session, set_session_cookie
import version
import libforget.version
and context (classes, functions, or code) from other files:
# Path: app.py
# def inject_static():
# def static(filename, **kwargs):
# def install_security_headers(resp):
#
# Path: libforget/auth.py
# def get_viewer_session():
# from model import Session
# sid = request.cookies.get('forget_sid', None)
# if sid:
# return Session.query.get(sid)
#
# def set_session_cookie(session, response, secure=True):
# response.set_cookie(
# 'forget_sid', session.id,
# max_age=60*60*48,
# httponly=True,
# secure=secure)
. Output only the next line. | return dict( |
Based on the snippet: <|code_start|>
@app.before_request
def load_viewer():
g.viewer = get_viewer_session()
if g.viewer and sentry:
sentry.user_context({
'id': g.viewer.account.id,
'username': g.viewer.account.screen_name,
'service': g.viewer.account.service
})
@app.context_processor
def inject_version():
v = version.get_versions()
return dict(
version=v['version'],
<|code_end|>
, predict the immediate next line with the help of imports:
from app import app, db, sentry
from flask import g, render_template, make_response, redirect, request
from libforget.auth import get_viewer_session, set_session_cookie
import version
import libforget.version
and context (classes, functions, sometimes code) from other files:
# Path: app.py
# def inject_static():
# def static(filename, **kwargs):
# def install_security_headers(resp):
#
# Path: libforget/auth.py
# def get_viewer_session():
# from model import Session
# sid = request.cookies.get('forget_sid', None)
# if sid:
# return Session.query.get(sid)
#
# def set_session_cookie(session, response, secure=True):
# response.set_cookie(
# 'forget_sid', session.id,
# max_age=60*60*48,
# httponly=True,
# secure=secure)
. Output only the next line. | repo_url=libforget.version.url_for_version(v), |
Next line prediction: <|code_start|>
if 'CELERY_BROKER' not in app.config:
uri = app.config['REDIS_URI']
if uri.startswith('unix://'):
uri = uri.replace('unix', 'redis+socket', 1)
app.config['CELERY_BROKER'] = uri
sentry = None
if 'SENTRY_DSN' in app.config:
app.config['SENTRY_CONFIG']['release'] = version.get_versions()['version']
sentry = Sentry(app, dsn=app.config['SENTRY_DSN'])
url_for = cachebust(app)
@app.context_processor
def inject_static():
def static(filename, **kwargs):
return url_for('static', filename=filename, **kwargs)
return {'st': static}
@app.after_request
def install_security_headers(resp):
csp = ("default-src 'none';"
"img-src 'self';"
"style-src 'self' 'unsafe-inline';"
"frame-ancestors 'none';"
)
if 'SENTRY_DSN' in app.config:
<|code_end|>
. Use current file imports:
(from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy import MetaData
from flask_migrate import Migrate
from libforget.cachebust import cachebust
from werkzeug.middleware.proxy_fix import ProxyFix
from raven.contrib.flask import Sentry
import version
import mimetypes
import libforget.brotli
import libforget.img_proxy)
and context including class names, function names, or small code snippets from other files:
# Path: libforget/cachebust.py
# def cachebust(app):
# # pylint: disable=unused-variable
#
# @app.route('/static-cb/<int:timestamp>/<path:filename>')
# def static_cachebust(timestamp, filename):
# path = os.path.join(app.static_folder, filename)
# try:
# mtime = os.stat(path).st_mtime
# except Exception:
# return abort(404)
# if abs(mtime - timestamp) > 1:
# abort(404)
# else:
# resp = app.view_functions['static'](filename=filename)
# resp.headers.set(
# 'cache-control',
# 'public, immutable, max-age={}'.format(60*60*24*365))
# if 'expires' in resp.headers:
# resp.headers.remove('expires')
# return resp
#
# @app.context_processor
# def replace_url_for():
# return dict(url_for=cachebust_url_for)
#
# def cachebust_url_for(endpoint, **kwargs):
# if endpoint == 'static':
# endpoint = 'static_cachebust'
# path = os.path.join(app.static_folder, kwargs.get('filename'))
# kwargs['timestamp'] = int(os.stat(path).st_mtime)
# return url_for(endpoint, **kwargs)
#
# return cachebust_url_for
. Output only the next line. | csp += "script-src 'self' https://cdn.ravenjs.com/;" |
Here is a snippet: <|code_start|>
class TimestampMixin(object):
created_at = db.Column(
db.DateTime(timezone=True), server_default=db.func.now(),
nullable=False)
updated_at = db.Column(
db.DateTime(timezone=True), server_default=db.func.now(),
onupdate=db.func.now(), nullable=False)
def touch(self):
self.updated_at = db.func.now()
class RemoteIDMixin(object):
@property
def service(self):
if not self.id:
return None
<|code_end|>
. Write the next line using the current file imports:
from datetime import timedelta, datetime, timezone
from app import db
from libforget.interval import decompose_interval
from sqlalchemy.ext.declarative import declared_attr
from app import imgproxy
from flask import url_for
import secrets
import random
and context from other files:
# Path: app.py
# def inject_static():
# def static(filename, **kwargs):
# def install_security_headers(resp):
#
# Path: libforget/interval.py
# def decompose_interval(attrname):
# scales = [scale[1] for scale in SCALES]
# scales.reverse()
#
# def decorator(cls):
# scl_name = '{}_scale'.format(attrname)
# sig_name = '{}_significand'.format(attrname)
#
# @property
# def scale(self):
#
# if getattr(self, attrname) == timedelta(0):
# return timedelta(minutes=1)
#
# for m in scales:
# if getattr(self, attrname) % m == timedelta(0):
# return m
#
# return timedelta(minutes=1)
#
# @scale.setter
# def scale(self, value):
# if not isinstance(value, timedelta):
# value = timedelta(seconds=float(value))
# setattr(self, attrname, max(1, getattr(self, sig_name)) * value)
#
# @property
# def significand(self):
# return int(getattr(self, attrname) / getattr(self, scl_name))
#
# @significand.setter
# def significand(self, value):
# if isinstance(value, str) and value.strip() == '':
# value = 0
#
# try:
# value = int(value)
# if not value >= 0:
# raise ValueError(value)
# except ValueError as e:
# raise ValueError("Incorrect time interval", e)
# setattr(self, attrname, value * getattr(self, scl_name))
#
# setattr(cls, scl_name, scale)
# setattr(cls, sig_name, significand)
#
# return cls
#
# return decorator
, which may include functions, classes, or code. Output only the next line. | return self.id.split(":")[0] |
Continue the code snippet: <|code_start|>
# pylint: disable=R0201
@db.validates('policy_keep_latest')
def validate_empty_string_is_zero(self, key, value):
if isinstance(value, str) and value.strip() == '':
return 0
return value
@db.validates('policy_enabled')
def on_policy_enable(self, key, enable):
if not self.policy_enabled and enable:
self.next_delete = (
datetime.now(timezone.utc) + self.policy_delete_every)
self.reason = None
self.dormant = False
return enable
@db.validates('policy_keep_direct')
def validate_bool_accept_string(self, key, value):
if isinstance(value, str):
return value.lower() == 'true'
return value
# backref: tokens
# backref: twitter_archives
# backref: posts
# backref: sessions
def post_count(self):
<|code_end|>
. Use current file imports:
from datetime import timedelta, datetime, timezone
from app import db
from libforget.interval import decompose_interval
from sqlalchemy.ext.declarative import declared_attr
from app import imgproxy
from flask import url_for
import secrets
import random
and context (classes, functions, or code) from other files:
# Path: app.py
# def inject_static():
# def static(filename, **kwargs):
# def install_security_headers(resp):
#
# Path: libforget/interval.py
# def decompose_interval(attrname):
# scales = [scale[1] for scale in SCALES]
# scales.reverse()
#
# def decorator(cls):
# scl_name = '{}_scale'.format(attrname)
# sig_name = '{}_significand'.format(attrname)
#
# @property
# def scale(self):
#
# if getattr(self, attrname) == timedelta(0):
# return timedelta(minutes=1)
#
# for m in scales:
# if getattr(self, attrname) % m == timedelta(0):
# return m
#
# return timedelta(minutes=1)
#
# @scale.setter
# def scale(self, value):
# if not isinstance(value, timedelta):
# value = timedelta(seconds=float(value))
# setattr(self, attrname, max(1, getattr(self, sig_name)) * value)
#
# @property
# def significand(self):
# return int(getattr(self, attrname) / getattr(self, scl_name))
#
# @significand.setter
# def significand(self, value):
# if isinstance(value, str) and value.strip() == '':
# value = 0
#
# try:
# value = int(value)
# if not value >= 0:
# raise ValueError(value)
# except ValueError as e:
# raise ValueError("Incorrect time interval", e)
# setattr(self, attrname, value * getattr(self, scl_name))
#
# setattr(cls, scl_name, scale)
# setattr(cls, sig_name, significand)
#
# return cls
#
# return decorator
. Output only the next line. | return Post.query.with_parent(self, 'posts').count() |
Here is a snippet: <|code_start|> def significand(self, value):
if isinstance(value, str) and value.strip() == '':
value = 0
try:
value = int(value)
if not value >= 0:
raise ValueError(value)
except ValueError as e:
raise ValueError("Incorrect time interval", e)
setattr(self, attrname, value * getattr(self, scl_name))
setattr(cls, scl_name, scale)
setattr(cls, sig_name, significand)
return cls
return decorator
def relative(interval):
# special cases
if interval > timedelta(seconds=-15) and interval < timedelta(0):
return "just now"
elif interval > timedelta(0) and interval < timedelta(seconds=15):
return "in a few seconds"
else:
output = None
for name, scale in reversed(SCALES):
if abs(interval) > scale:
<|code_end|>
. Write the next line using the current file imports:
from datetime import timedelta, datetime, timezone
from .timescales import SCALES
and context from other files:
# Path: libforget/timescales.py
# SCALES = [
# ('minutes', timedelta(minutes=1)),
# ('hours', timedelta(hours=1)),
# ('days', timedelta(days=1)),
# ('weeks', timedelta(days=7)),
# ('months', timedelta(days=
# # you, a fool: a month is 30 days
# # me, wise:
# mean((31,
# mean((29 if year % 400 == 0
# or (year % 100 != 0 and year % 4 == 0)
# else 28
# for year in range(400)))
# ,31,30,31,30,31,31,30,31,30,31))
# )),
# ('years', timedelta(days=
# # you, a fool: ok. a year is 365.25 days. happy?
# # me, wise: absolutely not
# mean((366 if year % 400 == 0
# or (year % 100 != 0 and year % 4 == 0)
# else 365
# for year in range(400)))
# )),
# ]
, which may include functions, classes, or code. Output only the next line. | value = abs(interval) // scale |
Using the snippet: <|code_start|>
assert app
assert routes
assert routes.misc
<|code_end|>
, determine the next line of code. You have imports:
from app import app
import routes
import routes.misc
import routes.api
and context (class names, function names, or code) available:
# Path: app.py
# def inject_static():
# def static(filename, **kwargs):
# def install_security_headers(resp):
. Output only the next line. | assert routes.api |
Continue the code snippet: <|code_start|># -*- coding: utf-8 -*-
def findGeoIPDB():
dbs = [Settings.value(Settings.GEOIP2DB_LOCATION),
os.path.join(os.getcwd(), 'GeoLite2-City.mmdb'),
packagePathJoin('GeoLite2-City.mmdb'),
os.path.join(os.getcwd(), 'GeoLite2-Country.mmdb'),
packagePathJoin('GeoLite2-Country.mmdb')]
for db in dbs:
if db and os.path.isfile(db):
return db
def freegeoip(ip):
url = 'http://freegeoip.net/json/'
try:
response = urllib2.urlopen(url + ip, timeout=1).read().strip()
return json.loads(response)
except urllib2.URLError:
return {'areacode': '',
'city': '',
'country_code': '',
'country_name': '',
'ip': ip,
'latitude': '',
'longitude': '',
'metro_code': '',
'region_code': '',
'region_name': '',
<|code_end|>
. Use current file imports:
import json
import os
import urllib2
from ggpo.common.runtime import *
from ggpo.common.settings import Settings
from ggpo.common.util import packagePathJoin
and context (classes, functions, or code) from other files:
# Path: ggpo/common/settings.py
# class Settings:
# # list of saved setting for autocomplete and avoid typos
# IGNORED = 'ignored'
# SELECTED_CHANNEL = 'channel'
# AUTOLOGIN = 'autoLogin'
# USERNAME = 'username'
# PASSWORD = 'password'
# SMOOTHING = 'smoothing'
# MUTE_CHALLENGE_SOUND = 'mute'
# NOTIFY_PLAYER_STATE_CHANGE = 'notifyPlayerStateChange'
# SHOW_COUNTRY_FLAG_IN_CHAT = 'showCountryFlagInChat'
# SHOW_TIMESTAMP_IN_CHAT = 'ShowTimestampInChat'
# WINDOW_GEOMETRY = 'mainWindowGeometry'
# WINDOW_STATE = 'mainWindowState'
# SPLITTER_STATE = 'splitterState'
# TABLE_HEADER_STATE = 'tableHeaderState'
# EMOTICON_DIALOG_GEOMETRY = 'emoticonDialogGeometry'
# SAVESTATES_DIALOG_GEOMETRY = 'savestatesDialogGeometry'
# SAVESTATES_DIALOG_TABLE_HEADER_STATE = 'savestatesDialogTableHeaderState'
# COLORTHEME = 'colortheme'
# CUSTOM_THEME_FILENAME = 'customThemeFilename'
# CUSTOM_EMOTICONS = 'customEmoticons'
# CHAT_HISTORY_FONT = 'chatFont'
# DEBUG_LOG = 'debuglog'
# USER_LOG_CHAT = 'userlogchat'
# USER_LOG_PLAYHISTORY = 'userlogplayhistory'
# SAVE_USERNAME_PASSWORD = 'saveUsernameAndPassword'
# GGPOFBA_LOCATION = 'ggpofbaLocation'
# WINE_LOCATION = 'wineLocation'
# GEOIP2DB_LOCATION = 'geoip2dbLocation'
# CUSTOM_CHALLENGE_SOUND_LOCATION = 'customChallengeSoundLocation'
# UNSUPPORTED_GAMESAVES_DIR = 'unsupportedGamesavesDir'
# DISABLE_AUTO_ANNOUNCE_UNSUPPORTED = 'disableAutoAnnounceUnsupported'
# SERVER_ADDRESS = 'serverAddress'
#
# _settings = QSettings(os.path.join(os.path.expanduser("~"), 'ggpo.ini'), QSettings.IniFormat)
#
# @staticmethod
# def setBoolean(key, val):
# if val:
# val = '1'
# else:
# val = ''
# Settings._settings.setValue(key, val)
#
# @staticmethod
# def setPythonValue(key, val):
# try:
# Settings._settings.setValue(key, pickle.dumps(val))
# except pickle.PickleError:
# pass
#
# @staticmethod
# def pythonValue(key):
# # noinspection PyBroadException
# try:
# return pickle.loads(Settings._settings.value(key))
# except:
# return None
#
# @staticmethod
# def setValue(key, val):
# Settings._settings.setValue(key, val)
#
# @staticmethod
# def value(key):
# return Settings._settings.value(key)
#
# Path: ggpo/common/util.py
# def packagePathJoin(*args):
# return os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir, *args))
. Output only the next line. | 'zipcode': ''} |
Here is a snippet: <|code_start|> os.path.join(os.getcwd(), 'GeoLite2-City.mmdb'),
packagePathJoin('GeoLite2-City.mmdb'),
os.path.join(os.getcwd(), 'GeoLite2-Country.mmdb'),
packagePathJoin('GeoLite2-Country.mmdb')]
for db in dbs:
if db and os.path.isfile(db):
return db
def freegeoip(ip):
url = 'http://freegeoip.net/json/'
try:
response = urllib2.urlopen(url + ip, timeout=1).read().strip()
return json.loads(response)
except urllib2.URLError:
return {'areacode': '',
'city': '',
'country_code': '',
'country_name': '',
'ip': ip,
'latitude': '',
'longitude': '',
'metro_code': '',
'region_code': '',
'region_name': '',
'zipcode': ''}
_geoIP2Reader = False
<|code_end|>
. Write the next line using the current file imports:
import json
import os
import urllib2
from ggpo.common.runtime import *
from ggpo.common.settings import Settings
from ggpo.common.util import packagePathJoin
and context from other files:
# Path: ggpo/common/settings.py
# class Settings:
# # list of saved setting for autocomplete and avoid typos
# IGNORED = 'ignored'
# SELECTED_CHANNEL = 'channel'
# AUTOLOGIN = 'autoLogin'
# USERNAME = 'username'
# PASSWORD = 'password'
# SMOOTHING = 'smoothing'
# MUTE_CHALLENGE_SOUND = 'mute'
# NOTIFY_PLAYER_STATE_CHANGE = 'notifyPlayerStateChange'
# SHOW_COUNTRY_FLAG_IN_CHAT = 'showCountryFlagInChat'
# SHOW_TIMESTAMP_IN_CHAT = 'ShowTimestampInChat'
# WINDOW_GEOMETRY = 'mainWindowGeometry'
# WINDOW_STATE = 'mainWindowState'
# SPLITTER_STATE = 'splitterState'
# TABLE_HEADER_STATE = 'tableHeaderState'
# EMOTICON_DIALOG_GEOMETRY = 'emoticonDialogGeometry'
# SAVESTATES_DIALOG_GEOMETRY = 'savestatesDialogGeometry'
# SAVESTATES_DIALOG_TABLE_HEADER_STATE = 'savestatesDialogTableHeaderState'
# COLORTHEME = 'colortheme'
# CUSTOM_THEME_FILENAME = 'customThemeFilename'
# CUSTOM_EMOTICONS = 'customEmoticons'
# CHAT_HISTORY_FONT = 'chatFont'
# DEBUG_LOG = 'debuglog'
# USER_LOG_CHAT = 'userlogchat'
# USER_LOG_PLAYHISTORY = 'userlogplayhistory'
# SAVE_USERNAME_PASSWORD = 'saveUsernameAndPassword'
# GGPOFBA_LOCATION = 'ggpofbaLocation'
# WINE_LOCATION = 'wineLocation'
# GEOIP2DB_LOCATION = 'geoip2dbLocation'
# CUSTOM_CHALLENGE_SOUND_LOCATION = 'customChallengeSoundLocation'
# UNSUPPORTED_GAMESAVES_DIR = 'unsupportedGamesavesDir'
# DISABLE_AUTO_ANNOUNCE_UNSUPPORTED = 'disableAutoAnnounceUnsupported'
# SERVER_ADDRESS = 'serverAddress'
#
# _settings = QSettings(os.path.join(os.path.expanduser("~"), 'ggpo.ini'), QSettings.IniFormat)
#
# @staticmethod
# def setBoolean(key, val):
# if val:
# val = '1'
# else:
# val = ''
# Settings._settings.setValue(key, val)
#
# @staticmethod
# def setPythonValue(key, val):
# try:
# Settings._settings.setValue(key, pickle.dumps(val))
# except pickle.PickleError:
# pass
#
# @staticmethod
# def pythonValue(key):
# # noinspection PyBroadException
# try:
# return pickle.loads(Settings._settings.value(key))
# except:
# return None
#
# @staticmethod
# def setValue(key, val):
# Settings._settings.setValue(key, val)
#
# @staticmethod
# def value(key):
# return Settings._settings.value(key)
#
# Path: ggpo/common/util.py
# def packagePathJoin(*args):
# return os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir, *args))
, which may include functions, classes, or code. Output only the next line. | def geolookup(ip): |
Using the snippet: <|code_start|>_loggerInitialzed = False
def logdebug():
global _loggerInitialzed
if not _loggerInitialzed:
_loggerInitialzed = True
loggerInit()
return logging.getLogger('GGPODebug')
def loguser():
global _loggerInitialzed
if not _loggerInitialzed:
_loggerInitialzed = True
loggerInit()
return logging.getLogger('GGPOUser')
def loggerInit():
debuglog = logging.getLogger('GGPODebug')
debuglog.setLevel(logging.INFO)
fh = logging.handlers.RotatingFileHandler(
os.path.join(expanduser("~"), 'ggpodebug.log'), mode='a', maxBytes=500000, backupCount=10)
if Settings.value(Settings.DEBUG_LOG):
fh.setLevel(logging.INFO)
else:
fh.setLevel(logging.ERROR)
ch = logging.StreamHandler()
ch.setLevel(logging.ERROR)
<|code_end|>
, determine the next line of code. You have imports:
import hashlib
import logging
import logging.handlers
import os
import re
import sys
import urllib2
from collections import defaultdict
from PyQt4 import QtGui, QtCore
from ggpo.common.runtime import *
from ggpo.common.settings import Settings
from ggpo.common import copyright
from os.path import expanduser
and context (class names, function names, or code) available:
# Path: ggpo/common/settings.py
# class Settings:
# # list of saved setting for autocomplete and avoid typos
# IGNORED = 'ignored'
# SELECTED_CHANNEL = 'channel'
# AUTOLOGIN = 'autoLogin'
# USERNAME = 'username'
# PASSWORD = 'password'
# SMOOTHING = 'smoothing'
# MUTE_CHALLENGE_SOUND = 'mute'
# NOTIFY_PLAYER_STATE_CHANGE = 'notifyPlayerStateChange'
# SHOW_COUNTRY_FLAG_IN_CHAT = 'showCountryFlagInChat'
# SHOW_TIMESTAMP_IN_CHAT = 'ShowTimestampInChat'
# WINDOW_GEOMETRY = 'mainWindowGeometry'
# WINDOW_STATE = 'mainWindowState'
# SPLITTER_STATE = 'splitterState'
# TABLE_HEADER_STATE = 'tableHeaderState'
# EMOTICON_DIALOG_GEOMETRY = 'emoticonDialogGeometry'
# SAVESTATES_DIALOG_GEOMETRY = 'savestatesDialogGeometry'
# SAVESTATES_DIALOG_TABLE_HEADER_STATE = 'savestatesDialogTableHeaderState'
# COLORTHEME = 'colortheme'
# CUSTOM_THEME_FILENAME = 'customThemeFilename'
# CUSTOM_EMOTICONS = 'customEmoticons'
# CHAT_HISTORY_FONT = 'chatFont'
# DEBUG_LOG = 'debuglog'
# USER_LOG_CHAT = 'userlogchat'
# USER_LOG_PLAYHISTORY = 'userlogplayhistory'
# SAVE_USERNAME_PASSWORD = 'saveUsernameAndPassword'
# GGPOFBA_LOCATION = 'ggpofbaLocation'
# WINE_LOCATION = 'wineLocation'
# GEOIP2DB_LOCATION = 'geoip2dbLocation'
# CUSTOM_CHALLENGE_SOUND_LOCATION = 'customChallengeSoundLocation'
# UNSUPPORTED_GAMESAVES_DIR = 'unsupportedGamesavesDir'
# DISABLE_AUTO_ANNOUNCE_UNSUPPORTED = 'disableAutoAnnounceUnsupported'
# SERVER_ADDRESS = 'serverAddress'
#
# _settings = QSettings(os.path.join(os.path.expanduser("~"), 'ggpo.ini'), QSettings.IniFormat)
#
# @staticmethod
# def setBoolean(key, val):
# if val:
# val = '1'
# else:
# val = ''
# Settings._settings.setValue(key, val)
#
# @staticmethod
# def setPythonValue(key, val):
# try:
# Settings._settings.setValue(key, pickle.dumps(val))
# except pickle.PickleError:
# pass
#
# @staticmethod
# def pythonValue(key):
# # noinspection PyBroadException
# try:
# return pickle.loads(Settings._settings.value(key))
# except:
# return None
#
# @staticmethod
# def setValue(key, val):
# Settings._settings.setValue(key, val)
#
# @staticmethod
# def value(key):
# return Settings._settings.value(key)
#
# Path: ggpo/common/copyright.py
# def versionString():
# def about():
. Output only the next line. | debuglog.addHandler(fh) |
Predict the next line for this snippet: <|code_start|># -*- coding: utf-8 -*-
def readLocalJsonDigest():
localJsonDigest = {}
d = findUnsupportedGamesavesDir()
if d:
localjson = os.path.join(d, SyncWorker.JSON_INDEX_FILENAME)
if os.path.isfile(localjson):
# noinspection PyBroadException
try:
localJsonDigest = json.load(file(localjson).read())
except:
pass
if not localJsonDigest:
return writeLocalJsonDigest()
return localJsonDigest
def writeLocalJsonDigest():
<|code_end|>
with the help of current file imports:
import glob
import hashlib
import json
import os
import re
import urllib
import urllib2
import time
from PyQt4 import QtCore
from ggpo.common.util import logdebug, findUnsupportedGamesavesDir, sha256digest
and context from other files:
# Path: ggpo/common/util.py
# def logdebug():
# global _loggerInitialzed
# if not _loggerInitialzed:
# _loggerInitialzed = True
# loggerInit()
# return logging.getLogger('GGPODebug')
#
# def findUnsupportedGamesavesDir():
# d = Settings.value(Settings.UNSUPPORTED_GAMESAVES_DIR)
# if d and os.path.isdir(d):
# return d
# d = os.path.abspath(os.path.join(expanduser("~"), "ggpoUnsupportedGamesavestates"))
# if d and os.path.isdir(d):
# return d
# # noinspection PyBroadException
# try:
# os.makedirs(d)
# return d
# except:
# pass
#
# def sha256digest(fname):
# return hashlib.sha256(open(fname, 'rb').read()).hexdigest()
, which may contain function names, class names, or code. Output only the next line. | localJsonDigest = {} |
Given snippet: <|code_start|> else:
self.added += 1
if not self.checkonly:
time.sleep(0.05)
localfile = os.path.join(d, filename)
fileurl = self.SAVESTATES_GITHUB_BASE_URL + urllib.quote(filename)
urllib.urlretrieve(fileurl, localfile)
self.sigStatusMessage.emit('Downloaded {}'.format(localfile))
if not self.checkonly:
if not self.added and not self.updated:
self.sigStatusMessage.emit('All files are up to date')
else:
writeLocalJsonDigest()
self.sigStatusMessage.emit(
'{} files are current, added {}, updated {}'.format(
self.nochange, self.added, self.updated))
except Exception, ex:
logdebug().error(str(ex))
self.sigFinished.emit(self.added, self.updated, self.nochange)
# noinspection PyClassHasNoInit
class UnsupportedSavestates(QtCore.QObject):
sigRemoteHasUpdates = QtCore.pyqtSignal(int, int, int)
_thread = None
_worker = None
@classmethod
def check(cls, mainWindow, statusMsgCallback=None, finishedCallback=None):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import glob
import hashlib
import json
import os
import re
import urllib
import urllib2
import time
from PyQt4 import QtCore
from ggpo.common.util import logdebug, findUnsupportedGamesavesDir, sha256digest
and context:
# Path: ggpo/common/util.py
# def logdebug():
# global _loggerInitialzed
# if not _loggerInitialzed:
# _loggerInitialzed = True
# loggerInit()
# return logging.getLogger('GGPODebug')
#
# def findUnsupportedGamesavesDir():
# d = Settings.value(Settings.UNSUPPORTED_GAMESAVES_DIR)
# if d and os.path.isdir(d):
# return d
# d = os.path.abspath(os.path.join(expanduser("~"), "ggpoUnsupportedGamesavestates"))
# if d and os.path.isdir(d):
# return d
# # noinspection PyBroadException
# try:
# os.makedirs(d)
# return d
# except:
# pass
#
# def sha256digest(fname):
# return hashlib.sha256(open(fname, 'rb').read()).hexdigest()
which might include code, classes, or functions. Output only the next line. | cls.run(True, statusMsgCallback, finishedCallback) |
Here is a snippet: <|code_start|># -*- coding: utf-8 -*-
class Backend(object):
__metaclass__ = abc.ABCMeta
def __init__(self):
pass
@staticmethod
def wavfile():
filename = Settings.value(Settings.CUSTOM_CHALLENGE_SOUND_LOCATION)
if filename and os.path.isfile(filename):
return filename
fba = Settings.value(Settings.GGPOFBA_LOCATION)
if fba:
filename = os.path.join(os.path.dirname(fba), "assets", "challenger-comes.wav")
if os.path.isfile(filename):
return filename
@abc.abstractmethod
def play(self):
pass
<|code_end|>
. Write the next line using the current file imports:
import abc
import os
from subprocess import Popen
from ggpo.common.runtime import *
from ggpo.common.settings import Settings
and context from other files:
# Path: ggpo/common/settings.py
# class Settings:
# # list of saved setting for autocomplete and avoid typos
# IGNORED = 'ignored'
# SELECTED_CHANNEL = 'channel'
# AUTOLOGIN = 'autoLogin'
# USERNAME = 'username'
# PASSWORD = 'password'
# SMOOTHING = 'smoothing'
# MUTE_CHALLENGE_SOUND = 'mute'
# NOTIFY_PLAYER_STATE_CHANGE = 'notifyPlayerStateChange'
# SHOW_COUNTRY_FLAG_IN_CHAT = 'showCountryFlagInChat'
# SHOW_TIMESTAMP_IN_CHAT = 'ShowTimestampInChat'
# WINDOW_GEOMETRY = 'mainWindowGeometry'
# WINDOW_STATE = 'mainWindowState'
# SPLITTER_STATE = 'splitterState'
# TABLE_HEADER_STATE = 'tableHeaderState'
# EMOTICON_DIALOG_GEOMETRY = 'emoticonDialogGeometry'
# SAVESTATES_DIALOG_GEOMETRY = 'savestatesDialogGeometry'
# SAVESTATES_DIALOG_TABLE_HEADER_STATE = 'savestatesDialogTableHeaderState'
# COLORTHEME = 'colortheme'
# CUSTOM_THEME_FILENAME = 'customThemeFilename'
# CUSTOM_EMOTICONS = 'customEmoticons'
# CHAT_HISTORY_FONT = 'chatFont'
# DEBUG_LOG = 'debuglog'
# USER_LOG_CHAT = 'userlogchat'
# USER_LOG_PLAYHISTORY = 'userlogplayhistory'
# SAVE_USERNAME_PASSWORD = 'saveUsernameAndPassword'
# GGPOFBA_LOCATION = 'ggpofbaLocation'
# WINE_LOCATION = 'wineLocation'
# GEOIP2DB_LOCATION = 'geoip2dbLocation'
# CUSTOM_CHALLENGE_SOUND_LOCATION = 'customChallengeSoundLocation'
# UNSUPPORTED_GAMESAVES_DIR = 'unsupportedGamesavesDir'
# DISABLE_AUTO_ANNOUNCE_UNSUPPORTED = 'disableAutoAnnounceUnsupported'
# SERVER_ADDRESS = 'serverAddress'
#
# _settings = QSettings(os.path.join(os.path.expanduser("~"), 'ggpo.ini'), QSettings.IniFormat)
#
# @staticmethod
# def setBoolean(key, val):
# if val:
# val = '1'
# else:
# val = ''
# Settings._settings.setValue(key, val)
#
# @staticmethod
# def setPythonValue(key, val):
# try:
# Settings._settings.setValue(key, pickle.dumps(val))
# except pickle.PickleError:
# pass
#
# @staticmethod
# def pythonValue(key):
# # noinspection PyBroadException
# try:
# return pickle.loads(Settings._settings.value(key))
# except:
# return None
#
# @staticmethod
# def setValue(key, val):
# Settings._settings.setValue(key, val)
#
# @staticmethod
# def value(key):
# return Settings._settings.value(key)
, which may include functions, classes, or code. Output only the next line. | class NullBackend(Backend): |
Next line prediction: <|code_start|> '666699',
'FF9900',
'99CC00',
'339966',
'33CCCC',
'3366FF',
'800080',
'FF00FF',
'00CCFF',
'993366',
'660066',
'0066CC',
'008080',
'0000FF']
}
DARK = {
'player': ['FF6600',
'FF9900',
'99CC00',
'33CCCC',
'FF00FF',
'FFCC00',
'FFFF00',
'00FF00',
'00FFFF',
'00CCFF',
'C0C0C0',
'FF99CC',
'FFCC99',
<|code_end|>
. Use current file imports:
(import cgi
from PyQt4 import QtGui
from PyQt4.QtCore import QFile, QIODevice
from ggpo.common.settings import Settings)
and context including class names, function names, or small code snippets from other files:
# Path: ggpo/common/settings.py
# class Settings:
# # list of saved setting for autocomplete and avoid typos
# IGNORED = 'ignored'
# SELECTED_CHANNEL = 'channel'
# AUTOLOGIN = 'autoLogin'
# USERNAME = 'username'
# PASSWORD = 'password'
# SMOOTHING = 'smoothing'
# MUTE_CHALLENGE_SOUND = 'mute'
# NOTIFY_PLAYER_STATE_CHANGE = 'notifyPlayerStateChange'
# SHOW_COUNTRY_FLAG_IN_CHAT = 'showCountryFlagInChat'
# SHOW_TIMESTAMP_IN_CHAT = 'ShowTimestampInChat'
# WINDOW_GEOMETRY = 'mainWindowGeometry'
# WINDOW_STATE = 'mainWindowState'
# SPLITTER_STATE = 'splitterState'
# TABLE_HEADER_STATE = 'tableHeaderState'
# EMOTICON_DIALOG_GEOMETRY = 'emoticonDialogGeometry'
# SAVESTATES_DIALOG_GEOMETRY = 'savestatesDialogGeometry'
# SAVESTATES_DIALOG_TABLE_HEADER_STATE = 'savestatesDialogTableHeaderState'
# COLORTHEME = 'colortheme'
# CUSTOM_THEME_FILENAME = 'customThemeFilename'
# CUSTOM_EMOTICONS = 'customEmoticons'
# CHAT_HISTORY_FONT = 'chatFont'
# DEBUG_LOG = 'debuglog'
# USER_LOG_CHAT = 'userlogchat'
# USER_LOG_PLAYHISTORY = 'userlogplayhistory'
# SAVE_USERNAME_PASSWORD = 'saveUsernameAndPassword'
# GGPOFBA_LOCATION = 'ggpofbaLocation'
# WINE_LOCATION = 'wineLocation'
# GEOIP2DB_LOCATION = 'geoip2dbLocation'
# CUSTOM_CHALLENGE_SOUND_LOCATION = 'customChallengeSoundLocation'
# UNSUPPORTED_GAMESAVES_DIR = 'unsupportedGamesavesDir'
# DISABLE_AUTO_ANNOUNCE_UNSUPPORTED = 'disableAutoAnnounceUnsupported'
# SERVER_ADDRESS = 'serverAddress'
#
# _settings = QSettings(os.path.join(os.path.expanduser("~"), 'ggpo.ini'), QSettings.IniFormat)
#
# @staticmethod
# def setBoolean(key, val):
# if val:
# val = '1'
# else:
# val = ''
# Settings._settings.setValue(key, val)
#
# @staticmethod
# def setPythonValue(key, val):
# try:
# Settings._settings.setValue(key, pickle.dumps(val))
# except pickle.PickleError:
# pass
#
# @staticmethod
# def pythonValue(key):
# # noinspection PyBroadException
# try:
# return pickle.loads(Settings._settings.value(key))
# except:
# return None
#
# @staticmethod
# def setValue(key, val):
# Settings._settings.setValue(key, val)
#
# @staticmethod
# def value(key):
# return Settings._settings.value(key)
. Output only the next line. | 'FFFF99', |
Given the following code snippet before the placeholder: <|code_start|> self.data = iface.DataInterface({"slots": [999999, 4, 2, 1]})
singleCaster = MockClasses([5], ['full'])
mixedCaster = MockClasses([1, 0], ['full', ''])
multiCaster = MockClasses([1, 1], ['full', 'full'])
self.singleCaster = MockCharacter(singleCaster)
self.mixedCaster = MockCharacter(mixedCaster)
self.multiCaster = MockCharacter(multiCaster)
def test_initialize(self):
slots = cast.OwnedSpellSlots(self.data, self.singleCaster)
self.assertEqual(slots.max_spell_slots, [999999, 4, 3, 2])
slots = cast.OwnedSpellSlots(self.data, self.mixedCaster)
self.assertEqual(slots.max_spell_slots, [999999, 2])
slots = cast.OwnedSpellSlots(self.data, self.multiCaster)
self.assertEqual(slots.max_spell_slots, [999999, 3])
def test_cast(self):
slots = cast.OwnedSpellSlots(self.data, self.singleCaster)
slots.cast(3)
self.assertEqual(self.data.get('/slots/3'), 0)
with self.assertRaises(cast.OutOfSpells):
slots.cast(3)
slots.cast(0)
self.assertEqual(self.data.get('/slots/0'), 999999)
def test_regain(self):
slots = cast.OwnedSpellSlots(self.data, self.singleCaster)
slots.regain(2)
self.assertEqual(self.data.get('/slots/2'), 3)
with self.assertRaises(cast.OverflowSpells):
<|code_end|>
, predict the next line using imports from the current file:
import unittest
import DnD.modules.lib.interface as iface
import DnD.modules.lib.spellcastingLib as cast
from pathlib import Path
from DnD.modules.lib.settingsLib import RestLength
and context including class names, function names, and sometimes code from other files:
# Path: DnD/modules/lib/settingsLib.py
# class RestLength(enum.IntEnum):
# LONG = 100
# SHORT = 10
# TURN = 1
# NOTHING = 0
#
# @classmethod
# def from_string(cls, value):
# if value == 'long' or value == 'long rest':
# return RestLength.LONG
# elif value == 'short' or value == 'short rest':
# return RestLength.SHORT
# elif value == 'turn':
# return RestLength.TURN
# else:
# return RestLength.NOTHING
. Output only the next line. | slots.regain(2) |
Predict the next line for this snippet: <|code_start|>
class Settings:
def __init__(self, jf: JsonInterface):
self.record = jf
@property
def healing(self) -> 'HealingMode':
return self.record.get('/HEALING') or HealingMode.VANILLA
@healing.setter
def healing(self, value: 'HealingMode'):
self.record.set('/HEALING', value)
@property
def spellPoints(self) -> bool:
return self.record.get('/SPELL_POINTS') or False
@spellPoints.setter
def spellPoints(self, value: bool):
self.record.set('/SPELL_POINTS', value)
@property
def proficiencyDice(self) -> bool:
return self.record.get('/PROFICIENCY_DICE') or False
@proficiencyDice.setter
def proficiencyDice(self, value: bool):
self.record.set('/PROFICIENCY_DICE', value)
def serialize(self):
<|code_end|>
with the help of current file imports:
import enum
from .interface import JsonInterface
and context from other files:
# Path: DnD/modules/lib/interface.py
# class JsonInterface(DataInterface):
# OBJECTSPATH = Path('./objects/')
# EXTANT = {}
#
# def __new__(cls, filename, **kwargs):
# if kwargs.get('isabsolute', False):
# totalpath = filename
# else:
# totalpath = cls.OBJECTSPATH / filename
# if totalpath in cls.EXTANT:
# return cls.EXTANT[totalpath]
# else:
# obj = super().__new__(cls)
# return obj
#
# def __init__(self, filename, readonly=False, isabsolute=False):
# self.shortFilename = h.readable_filename(str(filename))
# if isabsolute:
# self.filename = Path(filename)
# else:
# self.filename = self.OBJECTSPATH / filename
# with self.filename.open('r') as f:
# data = json.load(f, object_pairs_hook=collections.OrderedDict)
# super().__init__(data, readonly)
# self.EXTANT[self.filename] = self
#
# def __add__(self, other):
# if isinstance(other, JsonInterface):
# return LinkedInterface(self, other)
# elif isinstance(other, LinkedInterface):
# return other.__add__(self)
# else:
# raise TypeError("You can only add a JsonInterface or a "
# "MultiInterface to a JsonInterface")
#
# def __repr__(self):
# return "<JsonInterface to {}>".format(self.filename)
#
# def __str__(self):
# return self.shortFilename
#
# def write(self):
# if self.readonly:
# raise ex.ReadonlyError("Trying to write a readonly file")
# with open(self.filename, 'w') as f:
# json.dump(self.data, f, indent=2)
, which may contain function names, class names, or code. Output only the next line. | rv = {} |
Using the snippet: <|code_start|> LIGHT_ARMOR: [EquipmentSlot.CLOTHES, EquipmentSlot.PANTS],
MEDIUM_ARMOR: [EquipmentSlot.CLOTHES, EquipmentSlot.PANTS],
HEAVY_ARMOR: [EquipmentSlot.CLOTHES, EquipmentSlot.PANTS],
CLOTHES: [EquipmentSlot.CLOTHES, EquipmentSlot.PANTS],
HEADWEAR: [EquipmentSlot.HEAD],
BOOTS: [EquipmentSlot.LEFT_FOOT, EquipmentSlot.RIGHT_FOOT],
NECKLACE: [EquipmentSlot.NECK],
CLOAK: [EquipmentSlot.CLOAK],
SHIELD: [EquipmentSlot.OFF_HAND],
WEAPON_1H: [EquipmentSlot.MAIN_HAND],
WEAPON_2H: [EquipmentSlot.OFF_HAND],
}
def slots(self):
return self.__slotMap[self]
class ItemEntry:
__slots__ = ('record', 'item', 'inventory', 'name', 'value', 'weight',
'consumes', 'effect', 'description')
def __init__(self, name: str, jf: DataInterface, parent: Inventory):
self.record = jf
self.item = Item(name, jf.get('/'))
self.inventory = parent
def __getattr__(self, key):
# Properties that aren't found should delegate to the Item
return getattr(self.item, key)
<|code_end|>
, determine the next line of code. You have imports:
import enum
from typing import Optional
from . import abilitiesLib as abil
from . import characterLib as char
from . import exceptionsLib as ex
from .exceptionsLib import OutOfItems
from .interface import DataInterface
from .itemLib import Item
and context (class names, function names, or code) available:
# Path: DnD/modules/lib/exceptionsLib.py
# class OutOfItems(DnDError):
# def __init__(self, name):
# self.name = name
#
# def __str__(self):
# formatstr = 'You have no {item}s remaining.'
# return formatstr.format(item=self.name)
#
# Path: DnD/modules/lib/interface.py
# class DataInterface:
# class JsonPointerCache:
# def __init__(self):
# self.cache = {}
#
# def __getitem__(self, key: str) -> jsonpointer.JsonPointer:
# if key not in self.cache:
# self.cache[key] = jsonpointer.JsonPointer(key)
# return self.cache[key]
#
# def __init__(self, data: Union[list, Dict[str, Any]], readonly=False, basepath=""):
# self.data = data
# self.basepath = basepath.rstrip('/')
# self.readonly = readonly
# self._cache = type(self).JsonPointerCache()
#
# def __iter__(self):
# obj = self.get('/')
# if isinstance(obj, dict):
# yield from obj.items()
# elif isinstance(obj, list):
# yield from obj
#
# def get(self, path: str):
# if self.basepath + path == '/':
# return self.data
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# return pointer.resolve(self.data, None)
#
# def delete(self, path):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = {}
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# subdoc, key = pointer.to_last(self.data)
# del subdoc[key]
#
# def set(self, path, value):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = value
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# pointer.set(self.data, value)
#
# def cd(self, path, readonly=False):
# return DataInterface(self.data, readonly=self.readonly or readonly,
# basepath=self.basepath + path)
#
# Path: DnD/modules/lib/itemLib.py
# class Item:
# def __init__(self, name: str, spec: dict):
# types = spec['type'].split()
# fmt = '{}/{}.{}'
# filename = fmt.format(types[-1], sanitize_filename(name), '.'.join(types))
# self.record = JsonInterface(filename, readonly=True)
# self.name = self.record.get('/name')
# self.value = self.record.get('/value')
# self.weight = self.record.get('/weight')
# self.consumes = self.record.get('/consumes')
# self.effect: str = self.record.get('/effect')
# self.description: str = self.record.get('/description')
#
# def use(self) -> str:
# # TODO: consume item
# return self.effect
#
# def describe(self) -> str:
# return self.description
. Output only the next line. | @property |
Given the code snippet: <|code_start|> for name in jf.get('/')}
def __getitem__(self, item: str) -> 'ItemEntry':
return self.entries[item]
def __iter__(self):
yield from self.entries.values()
def add(self, name: str, quantity=1, type='item', equipped=None):
path = '/' + name
self.record.set(path, {})
self.record.set(path + '/type', type)
self.record.set(path + '/quantity', quantity)
self.record.set(path + '/equipped', equipped)
self.entries[name] = ItemEntry(name, self.record.cd(path), self)
def consume_item(self, name):
if name not in self.entries:
raise OutOfItems(name)
item = self.entries[name]
if item.quantity < 1:
raise OutOfItems(name)
item.quantity -= 1
@property
def totalWeight(self):
return sum(item.weight for item in self.entries.values())
def cleanup(self):
for name, item in self.entries.items():
<|code_end|>
, generate the next line using the imports in this file:
import enum
from typing import Optional
from . import abilitiesLib as abil
from . import characterLib as char
from . import exceptionsLib as ex
from .exceptionsLib import OutOfItems
from .interface import DataInterface
from .itemLib import Item
and context (functions, classes, or occasionally code) from other files:
# Path: DnD/modules/lib/exceptionsLib.py
# class OutOfItems(DnDError):
# def __init__(self, name):
# self.name = name
#
# def __str__(self):
# formatstr = 'You have no {item}s remaining.'
# return formatstr.format(item=self.name)
#
# Path: DnD/modules/lib/interface.py
# class DataInterface:
# class JsonPointerCache:
# def __init__(self):
# self.cache = {}
#
# def __getitem__(self, key: str) -> jsonpointer.JsonPointer:
# if key not in self.cache:
# self.cache[key] = jsonpointer.JsonPointer(key)
# return self.cache[key]
#
# def __init__(self, data: Union[list, Dict[str, Any]], readonly=False, basepath=""):
# self.data = data
# self.basepath = basepath.rstrip('/')
# self.readonly = readonly
# self._cache = type(self).JsonPointerCache()
#
# def __iter__(self):
# obj = self.get('/')
# if isinstance(obj, dict):
# yield from obj.items()
# elif isinstance(obj, list):
# yield from obj
#
# def get(self, path: str):
# if self.basepath + path == '/':
# return self.data
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# return pointer.resolve(self.data, None)
#
# def delete(self, path):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = {}
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# subdoc, key = pointer.to_last(self.data)
# del subdoc[key]
#
# def set(self, path, value):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = value
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# pointer.set(self.data, value)
#
# def cd(self, path, readonly=False):
# return DataInterface(self.data, readonly=self.readonly or readonly,
# basepath=self.basepath + path)
#
# Path: DnD/modules/lib/itemLib.py
# class Item:
# def __init__(self, name: str, spec: dict):
# types = spec['type'].split()
# fmt = '{}/{}.{}'
# filename = fmt.format(types[-1], sanitize_filename(name), '.'.join(types))
# self.record = JsonInterface(filename, readonly=True)
# self.name = self.record.get('/name')
# self.value = self.record.get('/value')
# self.weight = self.record.get('/weight')
# self.consumes = self.record.get('/consumes')
# self.effect: str = self.record.get('/effect')
# self.description: str = self.record.get('/description')
#
# def use(self) -> str:
# # TODO: consume item
# return self.effect
#
# def describe(self) -> str:
# return self.description
. Output only the next line. | if item.quantity < 1: |
Given the code snippet: <|code_start|> if item.quantity < 1:
self.record.delete('/' + name)
class OwnedInventory(Inventory):
def __init__(self, jf: DataInterface, character: 'char.Character'):
super().__init__(jf)
self.owner = character
@property
def encumbrance(self):
strength = self.owner.abilities[abil.AbilityName.STRENGTH].score
stages = ["No penalty.",
"Your speed drops by 10 feet.",
"Your speed drops by 20 feet and you have disadvantage on "
"all physical rolls.",
"You cannot carry this much weight, only push or drag it.",
"You cannot move this much weight."]
thresholds = [strength * 5,
strength * 10,
strength * 15,
strength * 30,
99999]
weight = self.totalWeight
for s, t in zip(stages, thresholds):
if weight <= t:
return s
def equip(self, item: str):
entry = self[item]
<|code_end|>
, generate the next line using the imports in this file:
import enum
from typing import Optional
from . import abilitiesLib as abil
from . import characterLib as char
from . import exceptionsLib as ex
from .exceptionsLib import OutOfItems
from .interface import DataInterface
from .itemLib import Item
and context (functions, classes, or occasionally code) from other files:
# Path: DnD/modules/lib/exceptionsLib.py
# class OutOfItems(DnDError):
# def __init__(self, name):
# self.name = name
#
# def __str__(self):
# formatstr = 'You have no {item}s remaining.'
# return formatstr.format(item=self.name)
#
# Path: DnD/modules/lib/interface.py
# class DataInterface:
# class JsonPointerCache:
# def __init__(self):
# self.cache = {}
#
# def __getitem__(self, key: str) -> jsonpointer.JsonPointer:
# if key not in self.cache:
# self.cache[key] = jsonpointer.JsonPointer(key)
# return self.cache[key]
#
# def __init__(self, data: Union[list, Dict[str, Any]], readonly=False, basepath=""):
# self.data = data
# self.basepath = basepath.rstrip('/')
# self.readonly = readonly
# self._cache = type(self).JsonPointerCache()
#
# def __iter__(self):
# obj = self.get('/')
# if isinstance(obj, dict):
# yield from obj.items()
# elif isinstance(obj, list):
# yield from obj
#
# def get(self, path: str):
# if self.basepath + path == '/':
# return self.data
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# return pointer.resolve(self.data, None)
#
# def delete(self, path):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = {}
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# subdoc, key = pointer.to_last(self.data)
# del subdoc[key]
#
# def set(self, path, value):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = value
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# pointer.set(self.data, value)
#
# def cd(self, path, readonly=False):
# return DataInterface(self.data, readonly=self.readonly or readonly,
# basepath=self.basepath + path)
#
# Path: DnD/modules/lib/itemLib.py
# class Item:
# def __init__(self, name: str, spec: dict):
# types = spec['type'].split()
# fmt = '{}/{}.{}'
# filename = fmt.format(types[-1], sanitize_filename(name), '.'.join(types))
# self.record = JsonInterface(filename, readonly=True)
# self.name = self.record.get('/name')
# self.value = self.record.get('/value')
# self.weight = self.record.get('/weight')
# self.consumes = self.record.get('/consumes')
# self.effect: str = self.record.get('/effect')
# self.description: str = self.record.get('/description')
#
# def use(self) -> str:
# # TODO: consume item
# return self.effect
#
# def describe(self) -> str:
# return self.description
. Output only the next line. | try: |
Predict the next line for this snippet: <|code_start|>
class Race:
def __init__(self, jf: JsonInterface):
spec = jf.get('/')
file = 'race/{}.race'.format(spec['base'])
self.interface = JsonInterface(file, readonly=True)
self.name = spec['base']
if 'subrace' in spec:
file = 'race/{}.{}.sub.race'.format(spec['base'], spec['subrace'])
sub = JsonInterface(file, readonly=True)
<|code_end|>
with the help of current file imports:
from .interface import JsonInterface
and context from other files:
# Path: DnD/modules/lib/interface.py
# class JsonInterface(DataInterface):
# OBJECTSPATH = Path('./objects/')
# EXTANT = {}
#
# def __new__(cls, filename, **kwargs):
# if kwargs.get('isabsolute', False):
# totalpath = filename
# else:
# totalpath = cls.OBJECTSPATH / filename
# if totalpath in cls.EXTANT:
# return cls.EXTANT[totalpath]
# else:
# obj = super().__new__(cls)
# return obj
#
# def __init__(self, filename, readonly=False, isabsolute=False):
# self.shortFilename = h.readable_filename(str(filename))
# if isabsolute:
# self.filename = Path(filename)
# else:
# self.filename = self.OBJECTSPATH / filename
# with self.filename.open('r') as f:
# data = json.load(f, object_pairs_hook=collections.OrderedDict)
# super().__init__(data, readonly)
# self.EXTANT[self.filename] = self
#
# def __add__(self, other):
# if isinstance(other, JsonInterface):
# return LinkedInterface(self, other)
# elif isinstance(other, LinkedInterface):
# return other.__add__(self)
# else:
# raise TypeError("You can only add a JsonInterface or a "
# "MultiInterface to a JsonInterface")
#
# def __repr__(self):
# return "<JsonInterface to {}>".format(self.filename)
#
# def __str__(self):
# return self.shortFilename
#
# def write(self):
# if self.readonly:
# raise ex.ReadonlyError("Trying to write a readonly file")
# with open(self.filename, 'w') as f:
# json.dump(self.data, f, indent=2)
, which may contain function names, class names, or code. Output only the next line. | self.subrace = Subrace(sub) |
Given the code snippet: <|code_start|>
class Item:
def __init__(self, name: str, spec: dict):
types = spec['type'].split()
fmt = '{}/{}.{}'
filename = fmt.format(types[-1], sanitize_filename(name), '.'.join(types))
self.record = JsonInterface(filename, readonly=True)
self.name = self.record.get('/name')
self.value = self.record.get('/value')
<|code_end|>
, generate the next line using the imports in this file:
from .helpers import sanitize_filename
from .interface import JsonInterface
and context (functions, classes, or occasionally code) from other files:
# Path: DnD/modules/lib/helpers.py
# def sanitize_filename(name: str) -> str:
# """Translates problematic characters in a filename into happier ones."""
# return name.translate(str.maketrans(" '/:", "_@&$"))
#
# Path: DnD/modules/lib/interface.py
# class JsonInterface(DataInterface):
# OBJECTSPATH = Path('./objects/')
# EXTANT = {}
#
# def __new__(cls, filename, **kwargs):
# if kwargs.get('isabsolute', False):
# totalpath = filename
# else:
# totalpath = cls.OBJECTSPATH / filename
# if totalpath in cls.EXTANT:
# return cls.EXTANT[totalpath]
# else:
# obj = super().__new__(cls)
# return obj
#
# def __init__(self, filename, readonly=False, isabsolute=False):
# self.shortFilename = h.readable_filename(str(filename))
# if isabsolute:
# self.filename = Path(filename)
# else:
# self.filename = self.OBJECTSPATH / filename
# with self.filename.open('r') as f:
# data = json.load(f, object_pairs_hook=collections.OrderedDict)
# super().__init__(data, readonly)
# self.EXTANT[self.filename] = self
#
# def __add__(self, other):
# if isinstance(other, JsonInterface):
# return LinkedInterface(self, other)
# elif isinstance(other, LinkedInterface):
# return other.__add__(self)
# else:
# raise TypeError("You can only add a JsonInterface or a "
# "MultiInterface to a JsonInterface")
#
# def __repr__(self):
# return "<JsonInterface to {}>".format(self.filename)
#
# def __str__(self):
# return self.shortFilename
#
# def write(self):
# if self.readonly:
# raise ex.ReadonlyError("Trying to write a readonly file")
# with open(self.filename, 'w') as f:
# json.dump(self.data, f, indent=2)
. Output only the next line. | self.weight = self.record.get('/weight') |
Predict the next line after this snippet: <|code_start|> self.record.set('/current', value)
else:
raise TypeError('Trying to set HP to not a number')
@property
def max(self):
return self.baseMax + self.bonusMax
@property
def baseMax(self):
return self.record.get('/max') or 0
@baseMax.setter
def baseMax(self, value):
self.record.set('/max', value)
@property
def temp(self):
return self.record.get('/temp') or 0
@temp.setter
def temp(self, value):
self.record.set('/temp', value)
@property
def bonusMax(self):
return self.record.get('/bonusMax') or 0
@bonusMax.setter
def bonusMax(self, value):
<|code_end|>
using the current file's imports:
from math import ceil
from dndice import basic
from . import abilitiesLib as abil
from . import characterLib as char
from . import resourceLib as res
from .interface import DataInterface
from .settingsLib import RestLength, HealingMode
and any relevant context from other files:
# Path: DnD/modules/lib/interface.py
# class DataInterface:
# class JsonPointerCache:
# def __init__(self):
# self.cache = {}
#
# def __getitem__(self, key: str) -> jsonpointer.JsonPointer:
# if key not in self.cache:
# self.cache[key] = jsonpointer.JsonPointer(key)
# return self.cache[key]
#
# def __init__(self, data: Union[list, Dict[str, Any]], readonly=False, basepath=""):
# self.data = data
# self.basepath = basepath.rstrip('/')
# self.readonly = readonly
# self._cache = type(self).JsonPointerCache()
#
# def __iter__(self):
# obj = self.get('/')
# if isinstance(obj, dict):
# yield from obj.items()
# elif isinstance(obj, list):
# yield from obj
#
# def get(self, path: str):
# if self.basepath + path == '/':
# return self.data
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# return pointer.resolve(self.data, None)
#
# def delete(self, path):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = {}
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# subdoc, key = pointer.to_last(self.data)
# del subdoc[key]
#
# def set(self, path, value):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = value
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# pointer.set(self.data, value)
#
# def cd(self, path, readonly=False):
# return DataInterface(self.data, readonly=self.readonly or readonly,
# basepath=self.basepath + path)
#
# Path: DnD/modules/lib/settingsLib.py
# class RestLength(enum.IntEnum):
# LONG = 100
# SHORT = 10
# TURN = 1
# NOTHING = 0
#
# @classmethod
# def from_string(cls, value):
# if value == 'long' or value == 'long rest':
# return RestLength.LONG
# elif value == 'short' or value == 'short rest':
# return RestLength.SHORT
# elif value == 'turn':
# return RestLength.TURN
# else:
# return RestLength.NOTHING
#
# class HealingMode(enum.Enum):
# FAST = 'fast'
# VANILLA = 'vanilla'
# SLOW = 'slow'
. Output only the next line. | self.record.set('/bonusMax', value) |
Given the following code snippet before the placeholder: <|code_start|> self.record.set('/current', value)
else:
raise TypeError('Trying to set HP to not a number')
@property
def max(self):
return self.baseMax + self.bonusMax
@property
def baseMax(self):
return self.record.get('/max') or 0
@baseMax.setter
def baseMax(self, value):
self.record.set('/max', value)
@property
def temp(self):
return self.record.get('/temp') or 0
@temp.setter
def temp(self, value):
self.record.set('/temp', value)
@property
def bonusMax(self):
return self.record.get('/bonusMax') or 0
@bonusMax.setter
def bonusMax(self, value):
<|code_end|>
, predict the next line using imports from the current file:
from math import ceil
from dndice import basic
from . import abilitiesLib as abil
from . import characterLib as char
from . import resourceLib as res
from .interface import DataInterface
from .settingsLib import RestLength, HealingMode
and context including class names, function names, and sometimes code from other files:
# Path: DnD/modules/lib/interface.py
# class DataInterface:
# class JsonPointerCache:
# def __init__(self):
# self.cache = {}
#
# def __getitem__(self, key: str) -> jsonpointer.JsonPointer:
# if key not in self.cache:
# self.cache[key] = jsonpointer.JsonPointer(key)
# return self.cache[key]
#
# def __init__(self, data: Union[list, Dict[str, Any]], readonly=False, basepath=""):
# self.data = data
# self.basepath = basepath.rstrip('/')
# self.readonly = readonly
# self._cache = type(self).JsonPointerCache()
#
# def __iter__(self):
# obj = self.get('/')
# if isinstance(obj, dict):
# yield from obj.items()
# elif isinstance(obj, list):
# yield from obj
#
# def get(self, path: str):
# if self.basepath + path == '/':
# return self.data
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# return pointer.resolve(self.data, None)
#
# def delete(self, path):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = {}
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# subdoc, key = pointer.to_last(self.data)
# del subdoc[key]
#
# def set(self, path, value):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = value
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# pointer.set(self.data, value)
#
# def cd(self, path, readonly=False):
# return DataInterface(self.data, readonly=self.readonly or readonly,
# basepath=self.basepath + path)
#
# Path: DnD/modules/lib/settingsLib.py
# class RestLength(enum.IntEnum):
# LONG = 100
# SHORT = 10
# TURN = 1
# NOTHING = 0
#
# @classmethod
# def from_string(cls, value):
# if value == 'long' or value == 'long rest':
# return RestLength.LONG
# elif value == 'short' or value == 'short rest':
# return RestLength.SHORT
# elif value == 'turn':
# return RestLength.TURN
# else:
# return RestLength.NOTHING
#
# class HealingMode(enum.Enum):
# FAST = 'fast'
# VANILLA = 'vanilla'
# SLOW = 'slow'
. Output only the next line. | self.record.set('/bonusMax', value) |
Next line prediction: <|code_start|>
class HP:
def __init__(self, jf: DataInterface):
self.record = jf
@property
def current(self):
return self.record.get('/current') or 0
@current.setter
def current(self, value):
if isinstance(value, int):
if value < 0:
self.record.set('/current', 0)
elif value > self.max:
self.record.set('/current', self.max)
<|code_end|>
. Use current file imports:
(from math import ceil
from dndice import basic
from . import abilitiesLib as abil
from . import characterLib as char
from . import resourceLib as res
from .interface import DataInterface
from .settingsLib import RestLength, HealingMode)
and context including class names, function names, or small code snippets from other files:
# Path: DnD/modules/lib/interface.py
# class DataInterface:
# class JsonPointerCache:
# def __init__(self):
# self.cache = {}
#
# def __getitem__(self, key: str) -> jsonpointer.JsonPointer:
# if key not in self.cache:
# self.cache[key] = jsonpointer.JsonPointer(key)
# return self.cache[key]
#
# def __init__(self, data: Union[list, Dict[str, Any]], readonly=False, basepath=""):
# self.data = data
# self.basepath = basepath.rstrip('/')
# self.readonly = readonly
# self._cache = type(self).JsonPointerCache()
#
# def __iter__(self):
# obj = self.get('/')
# if isinstance(obj, dict):
# yield from obj.items()
# elif isinstance(obj, list):
# yield from obj
#
# def get(self, path: str):
# if self.basepath + path == '/':
# return self.data
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# return pointer.resolve(self.data, None)
#
# def delete(self, path):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = {}
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# subdoc, key = pointer.to_last(self.data)
# del subdoc[key]
#
# def set(self, path, value):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = value
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# pointer.set(self.data, value)
#
# def cd(self, path, readonly=False):
# return DataInterface(self.data, readonly=self.readonly or readonly,
# basepath=self.basepath + path)
#
# Path: DnD/modules/lib/settingsLib.py
# class RestLength(enum.IntEnum):
# LONG = 100
# SHORT = 10
# TURN = 1
# NOTHING = 0
#
# @classmethod
# def from_string(cls, value):
# if value == 'long' or value == 'long rest':
# return RestLength.LONG
# elif value == 'short' or value == 'short rest':
# return RestLength.SHORT
# elif value == 'turn':
# return RestLength.TURN
# else:
# return RestLength.NOTHING
#
# class HealingMode(enum.Enum):
# FAST = 'fast'
# VANILLA = 'vanilla'
# SLOW = 'slow'
. Output only the next line. | else: |
Predict the next line for this snippet: <|code_start|>
def parse_one(elem: Tag) -> dict:
data = {
'name': elem.find('name').text.rstrip('()ESCAG '),
'level': int(elem.level.text),
<|code_end|>
with the help of current file imports:
import json
import re
from pathlib import Path
from typing import List, Tuple, Optional
from bs4 import BeautifulSoup, Tag
from DnD.modules.lib.helpers import sanitize_filename
and context from other files:
# Path: DnD/modules/lib/helpers.py
# def sanitize_filename(name: str) -> str:
# """Translates problematic characters in a filename into happier ones."""
# return name.translate(str.maketrans(" '/:", "_@&$"))
, which may contain function names, class names, or code. Output only the next line. | 'school': parse_school(elem.school.text), |
Given snippet: <|code_start|> def test_set(self):
inter = interface.DataInterface(self.data)
inter.set('/dict/a', 'New A')
self.assertEqual(self.data['dict']['a'], 'New A')
inter.set('/dict', 'a dict no longer')
self.assertEqual(self.data['dict'], 'a dict no longer')
inter.set('/new', "new value")
self.assertEqual(self.data['new'], 'new value')
inter.set('/', "nothing remains")
self.assertEqual(inter.get('/'), "nothing remains")
def test_delete(self):
inter = interface.DataInterface(self.data)
inter.delete('/dict/a')
self.assertEqual(self.data['dict'], {'b': 'B'})
inter.delete('/list/1')
self.assertEqual(self.data['list'], ['string', None, True])
inter.delete('/')
self.assertEqual(inter.get('/'), {})
def test_cd(self):
inter = interface.DataInterface(self.data)
sub = inter.cd('/dict')
self.assertEqual(sub.get('/a'), 'A')
self.assertEqual(sub.get('/'), {'a': 'A', 'b': 'B'})
sub.set('/c', 'C')
self.assertEqual(sub.get('/c'), 'C')
sub.delete('/a')
self.assertEqual(sub.get('/'), {'b': 'B', 'c': 'C'})
first = inter.cd('/nesting')
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import json
import tempfile
import unittest
from DnD.modules.lib import interface
and context:
# Path: DnD/modules/lib/interface.py
# class DataInterface:
# class JsonPointerCache:
# class JsonInterface(DataInterface):
# class LinkedInterface:
# def __init__(self):
# def __getitem__(self, key: str) -> jsonpointer.JsonPointer:
# def __init__(self, data: Union[list, Dict[str, Any]], readonly=False, basepath=""):
# def __iter__(self):
# def get(self, path: str):
# def delete(self, path):
# def set(self, path, value):
# def cd(self, path, readonly=False):
# def __new__(cls, filename, **kwargs):
# def __init__(self, filename, readonly=False, isabsolute=False):
# def __add__(self, other):
# def __repr__(self):
# def __str__(self):
# def write(self):
# def __init__(self, *interfaces: JsonInterface):
# def __add__(self, other):
# def _most_to_least(self):
# def _least_to_most(self):
# def get(self, path: str):
# OBJECTSPATH = Path('./objects/')
# EXTANT = {}
which might include code, classes, or functions. Output only the next line. | second = first.cd('/multiple') |
Given snippet: <|code_start|>
class Spell:
def __init__(self, jf: JsonInterface):
self.record = jf
self.name: str = jf.get('/name')
self.level: int = jf.get('/level')
self.effect: str = jf.get('/effect')
self.classes: Set[str] = set(jf.get('/class'))
self.castingTime: str = jf.get('/casting_time')
self.duration: str = jf.get('/duration')
self.range: str = jf.get('/range')
self.components: str = jf.get('/components')
self.school: str = jf.get('/school')
self.isRitual: bool = jf.get('/ritual')
self.isConcentration: bool = jf.get('/concentration')
def __eq__(self, other):
if isinstance(other, Spell):
return self.record is other.record
elif isinstance(other, str):
return self.name == other
else:
return False
def is_available(self, character: 'char.Character'):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from typing import Set
from . import characterLib as char
from . import exceptionsLib as ex
from .interface import JsonInterface
and context:
# Path: DnD/modules/lib/interface.py
# class JsonInterface(DataInterface):
# OBJECTSPATH = Path('./objects/')
# EXTANT = {}
#
# def __new__(cls, filename, **kwargs):
# if kwargs.get('isabsolute', False):
# totalpath = filename
# else:
# totalpath = cls.OBJECTSPATH / filename
# if totalpath in cls.EXTANT:
# return cls.EXTANT[totalpath]
# else:
# obj = super().__new__(cls)
# return obj
#
# def __init__(self, filename, readonly=False, isabsolute=False):
# self.shortFilename = h.readable_filename(str(filename))
# if isabsolute:
# self.filename = Path(filename)
# else:
# self.filename = self.OBJECTSPATH / filename
# with self.filename.open('r') as f:
# data = json.load(f, object_pairs_hook=collections.OrderedDict)
# super().__init__(data, readonly)
# self.EXTANT[self.filename] = self
#
# def __add__(self, other):
# if isinstance(other, JsonInterface):
# return LinkedInterface(self, other)
# elif isinstance(other, LinkedInterface):
# return other.__add__(self)
# else:
# raise TypeError("You can only add a JsonInterface or a "
# "MultiInterface to a JsonInterface")
#
# def __repr__(self):
# return "<JsonInterface to {}>".format(self.filename)
#
# def __str__(self):
# return self.shortFilename
#
# def write(self):
# if self.readonly:
# raise ex.ReadonlyError("Trying to write a readonly file")
# with open(self.filename, 'w') as f:
# json.dump(self.data, f, indent=2)
which might include code, classes, or functions. Output only the next line. | available = character.classes.spells_available |
Using the snippet: <|code_start|>
class Skill:
def __init__(self, name: str, ability: abil.Ability):
self.name = name
self.ability = ability
def roll(self, advantage=False, disadvantage=False, lucky=False):
d20 = d20_roll(advantage, disadvantage, lucky)
return basic(d20, modifiers=self.ability.modifier)
class Skills:
<|code_end|>
, determine the next line of code. You have imports:
from dndice import basic
from . import abilitiesLib as abil
from .helpers import d20_roll
and context (class names, function names, or code) available:
# Path: DnD/modules/lib/helpers.py
# def d20_roll(adv=False, dis=False, luck=False):
# """Return the d20 roll to make under the given conditions."""
# if adv and not dis:
# if luck:
# return ADV_LUCK.copy()
# else:
# return ADV.copy()
# elif dis and not adv:
# if luck:
# return DIS_LUCK.copy()
# else:
# return DIS.copy()
# else:
# if luck:
# return D20_LUCK.copy()
# else:
# return D20.copy()
. Output only the next line. | pass |
Predict the next line for this snippet: <|code_start|>
class Resource:
def __init__(self, jf: Optional[DataInterface], definition: DataInterface = None):
self.record = jf
self.definition = definition or jf
self.recharge = RestLength.from_string(self.definition.get('/recharge'))
self.value = self.definition.get('/value')
self.name = self.definition.get('/name')
@property
def number(self):
return self.record.get('/number')
@number.setter
def number(self, value):
self.record.set('/number', value)
@property
def maxnumber(self):
return self.record.get('/maxnumber') or self.definition.get('/maxnumber')
@maxnumber.setter
def maxnumber(self, value):
<|code_end|>
with the help of current file imports:
import re
from typing import Optional
from dndice import basic
from . import characterLib as char
from .exceptionsLib import LowOnResource
from .interface import DataInterface
from .settingsLib import RestLength
and context from other files:
# Path: DnD/modules/lib/exceptionsLib.py
# class LowOnResource(DnDError):
# def __init__(self, resource):
# self.resource = resource
#
# def __str__(self):
# formatstr = 'You have no {rs} remaining.'
# return formatstr.format(rs=self.resource.name)
#
# Path: DnD/modules/lib/interface.py
# class DataInterface:
# class JsonPointerCache:
# def __init__(self):
# self.cache = {}
#
# def __getitem__(self, key: str) -> jsonpointer.JsonPointer:
# if key not in self.cache:
# self.cache[key] = jsonpointer.JsonPointer(key)
# return self.cache[key]
#
# def __init__(self, data: Union[list, Dict[str, Any]], readonly=False, basepath=""):
# self.data = data
# self.basepath = basepath.rstrip('/')
# self.readonly = readonly
# self._cache = type(self).JsonPointerCache()
#
# def __iter__(self):
# obj = self.get('/')
# if isinstance(obj, dict):
# yield from obj.items()
# elif isinstance(obj, list):
# yield from obj
#
# def get(self, path: str):
# if self.basepath + path == '/':
# return self.data
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# return pointer.resolve(self.data, None)
#
# def delete(self, path):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = {}
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# subdoc, key = pointer.to_last(self.data)
# del subdoc[key]
#
# def set(self, path, value):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = value
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# pointer.set(self.data, value)
#
# def cd(self, path, readonly=False):
# return DataInterface(self.data, readonly=self.readonly or readonly,
# basepath=self.basepath + path)
#
# Path: DnD/modules/lib/settingsLib.py
# class RestLength(enum.IntEnum):
# LONG = 100
# SHORT = 10
# TURN = 1
# NOTHING = 0
#
# @classmethod
# def from_string(cls, value):
# if value == 'long' or value == 'long rest':
# return RestLength.LONG
# elif value == 'short' or value == 'short rest':
# return RestLength.SHORT
# elif value == 'turn':
# return RestLength.TURN
# else:
# return RestLength.NOTHING
, which may contain function names, class names, or code. Output only the next line. | self.record.set('/maxnumber', value) |
Using the snippet: <|code_start|>
@number.setter
def number(self, value):
self.record.set('/number', value)
@property
def maxnumber(self):
return self.record.get('/maxnumber') or self.definition.get('/maxnumber')
@maxnumber.setter
def maxnumber(self, value):
self.record.set('/maxnumber', value)
def use(self, number):
if self.number < number:
raise LowOnResource(self)
self.number -= number
if isinstance(self.value, str):
return basic('+'.join([self.value] * number))
elif isinstance(self.value, int):
return number * self.value
else:
return 0
def regain(self, number):
if self.number + number > self.maxnumber:
self.reset()
else:
self.number += number
<|code_end|>
, determine the next line of code. You have imports:
import re
from typing import Optional
from dndice import basic
from . import characterLib as char
from .exceptionsLib import LowOnResource
from .interface import DataInterface
from .settingsLib import RestLength
and context (class names, function names, or code) available:
# Path: DnD/modules/lib/exceptionsLib.py
# class LowOnResource(DnDError):
# def __init__(self, resource):
# self.resource = resource
#
# def __str__(self):
# formatstr = 'You have no {rs} remaining.'
# return formatstr.format(rs=self.resource.name)
#
# Path: DnD/modules/lib/interface.py
# class DataInterface:
# class JsonPointerCache:
# def __init__(self):
# self.cache = {}
#
# def __getitem__(self, key: str) -> jsonpointer.JsonPointer:
# if key not in self.cache:
# self.cache[key] = jsonpointer.JsonPointer(key)
# return self.cache[key]
#
# def __init__(self, data: Union[list, Dict[str, Any]], readonly=False, basepath=""):
# self.data = data
# self.basepath = basepath.rstrip('/')
# self.readonly = readonly
# self._cache = type(self).JsonPointerCache()
#
# def __iter__(self):
# obj = self.get('/')
# if isinstance(obj, dict):
# yield from obj.items()
# elif isinstance(obj, list):
# yield from obj
#
# def get(self, path: str):
# if self.basepath + path == '/':
# return self.data
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# return pointer.resolve(self.data, None)
#
# def delete(self, path):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = {}
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# subdoc, key = pointer.to_last(self.data)
# del subdoc[key]
#
# def set(self, path, value):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = value
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# pointer.set(self.data, value)
#
# def cd(self, path, readonly=False):
# return DataInterface(self.data, readonly=self.readonly or readonly,
# basepath=self.basepath + path)
#
# Path: DnD/modules/lib/settingsLib.py
# class RestLength(enum.IntEnum):
# LONG = 100
# SHORT = 10
# TURN = 1
# NOTHING = 0
#
# @classmethod
# def from_string(cls, value):
# if value == 'long' or value == 'long rest':
# return RestLength.LONG
# elif value == 'short' or value == 'short rest':
# return RestLength.SHORT
# elif value == 'turn':
# return RestLength.TURN
# else:
# return RestLength.NOTHING
. Output only the next line. | def reset(self): |
Continue the code snippet: <|code_start|> self.value = self.definition.get('/value')
self.name = self.definition.get('/name')
@property
def number(self):
return self.record.get('/number')
@number.setter
def number(self, value):
self.record.set('/number', value)
@property
def maxnumber(self):
return self.record.get('/maxnumber') or self.definition.get('/maxnumber')
@maxnumber.setter
def maxnumber(self, value):
self.record.set('/maxnumber', value)
def use(self, number):
if self.number < number:
raise LowOnResource(self)
self.number -= number
if isinstance(self.value, str):
return basic('+'.join([self.value] * number))
elif isinstance(self.value, int):
return number * self.value
else:
return 0
<|code_end|>
. Use current file imports:
import re
from typing import Optional
from dndice import basic
from . import characterLib as char
from .exceptionsLib import LowOnResource
from .interface import DataInterface
from .settingsLib import RestLength
and context (classes, functions, or code) from other files:
# Path: DnD/modules/lib/exceptionsLib.py
# class LowOnResource(DnDError):
# def __init__(self, resource):
# self.resource = resource
#
# def __str__(self):
# formatstr = 'You have no {rs} remaining.'
# return formatstr.format(rs=self.resource.name)
#
# Path: DnD/modules/lib/interface.py
# class DataInterface:
# class JsonPointerCache:
# def __init__(self):
# self.cache = {}
#
# def __getitem__(self, key: str) -> jsonpointer.JsonPointer:
# if key not in self.cache:
# self.cache[key] = jsonpointer.JsonPointer(key)
# return self.cache[key]
#
# def __init__(self, data: Union[list, Dict[str, Any]], readonly=False, basepath=""):
# self.data = data
# self.basepath = basepath.rstrip('/')
# self.readonly = readonly
# self._cache = type(self).JsonPointerCache()
#
# def __iter__(self):
# obj = self.get('/')
# if isinstance(obj, dict):
# yield from obj.items()
# elif isinstance(obj, list):
# yield from obj
#
# def get(self, path: str):
# if self.basepath + path == '/':
# return self.data
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# return pointer.resolve(self.data, None)
#
# def delete(self, path):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = {}
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# subdoc, key = pointer.to_last(self.data)
# del subdoc[key]
#
# def set(self, path, value):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = value
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# pointer.set(self.data, value)
#
# def cd(self, path, readonly=False):
# return DataInterface(self.data, readonly=self.readonly or readonly,
# basepath=self.basepath + path)
#
# Path: DnD/modules/lib/settingsLib.py
# class RestLength(enum.IntEnum):
# LONG = 100
# SHORT = 10
# TURN = 1
# NOTHING = 0
#
# @classmethod
# def from_string(cls, value):
# if value == 'long' or value == 'long rest':
# return RestLength.LONG
# elif value == 'short' or value == 'short rest':
# return RestLength.SHORT
# elif value == 'turn':
# return RestLength.TURN
# else:
# return RestLength.NOTHING
. Output only the next line. | def regain(self, number): |
Continue the code snippet: <|code_start|>
class SpellResource:
def __init__(self, jf: DataInterface):
self.record = jf
def cast(self, level: int):
raise NotImplementedError
def regain(self, level: int):
raise NotImplementedError
def reset(self):
<|code_end|>
. Use current file imports:
from pathlib import Path
from . import characterLib as char
from . import spellLib as sp
from .exceptionsLib import OverflowSpells, OutOfSpells, AlreadyPrepared
from .helpers import sanitize_filename
from .interface import DataInterface, JsonInterface
from .settingsLib import RestLength
and context (classes, functions, or code) from other files:
# Path: DnD/modules/lib/exceptionsLib.py
# class OverflowSpells(SpellError):
# def __init__(self, spell):
# self.spell = spell
#
# def __str__(self):
# formatstr = 'You have full spell slots of level {lv} already.'
# return formatstr.format(lv=self.spell.level)
#
# class OutOfSpells(SpellError):
# def __init__(self, spell):
# self.spell = spell
#
# def __str__(self):
# formatstr = 'You have no spell slots of level {lv} remaining.'
# return formatstr.format(lv=(self.spell if isinstance(self.spell, int)
# else self.spell.level))
#
# class AlreadyPrepared(SpellError):
# pass
#
# Path: DnD/modules/lib/helpers.py
# def sanitize_filename(name: str) -> str:
# """Translates problematic characters in a filename into happier ones."""
# return name.translate(str.maketrans(" '/:", "_@&$"))
#
# Path: DnD/modules/lib/interface.py
# class DataInterface:
# class JsonPointerCache:
# def __init__(self):
# self.cache = {}
#
# def __getitem__(self, key: str) -> jsonpointer.JsonPointer:
# if key not in self.cache:
# self.cache[key] = jsonpointer.JsonPointer(key)
# return self.cache[key]
#
# def __init__(self, data: Union[list, Dict[str, Any]], readonly=False, basepath=""):
# self.data = data
# self.basepath = basepath.rstrip('/')
# self.readonly = readonly
# self._cache = type(self).JsonPointerCache()
#
# def __iter__(self):
# obj = self.get('/')
# if isinstance(obj, dict):
# yield from obj.items()
# elif isinstance(obj, list):
# yield from obj
#
# def get(self, path: str):
# if self.basepath + path == '/':
# return self.data
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# return pointer.resolve(self.data, None)
#
# def delete(self, path):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = {}
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# subdoc, key = pointer.to_last(self.data)
# del subdoc[key]
#
# def set(self, path, value):
# if self.readonly:
# raise ex.ReadonlyError('{} is readonly'.format(self.data))
# if self.basepath + path == '/':
# self.data = value
# return
# if path == '/':
# path = ''
# pointer = self._cache[self.basepath + path]
# pointer.set(self.data, value)
#
# def cd(self, path, readonly=False):
# return DataInterface(self.data, readonly=self.readonly or readonly,
# basepath=self.basepath + path)
#
# class JsonInterface(DataInterface):
# OBJECTSPATH = Path('./objects/')
# EXTANT = {}
#
# def __new__(cls, filename, **kwargs):
# if kwargs.get('isabsolute', False):
# totalpath = filename
# else:
# totalpath = cls.OBJECTSPATH / filename
# if totalpath in cls.EXTANT:
# return cls.EXTANT[totalpath]
# else:
# obj = super().__new__(cls)
# return obj
#
# def __init__(self, filename, readonly=False, isabsolute=False):
# self.shortFilename = h.readable_filename(str(filename))
# if isabsolute:
# self.filename = Path(filename)
# else:
# self.filename = self.OBJECTSPATH / filename
# with self.filename.open('r') as f:
# data = json.load(f, object_pairs_hook=collections.OrderedDict)
# super().__init__(data, readonly)
# self.EXTANT[self.filename] = self
#
# def __add__(self, other):
# if isinstance(other, JsonInterface):
# return LinkedInterface(self, other)
# elif isinstance(other, LinkedInterface):
# return other.__add__(self)
# else:
# raise TypeError("You can only add a JsonInterface or a "
# "MultiInterface to a JsonInterface")
#
# def __repr__(self):
# return "<JsonInterface to {}>".format(self.filename)
#
# def __str__(self):
# return self.shortFilename
#
# def write(self):
# if self.readonly:
# raise ex.ReadonlyError("Trying to write a readonly file")
# with open(self.filename, 'w') as f:
# json.dump(self.data, f, indent=2)
#
# Path: DnD/modules/lib/settingsLib.py
# class RestLength(enum.IntEnum):
# LONG = 100
# SHORT = 10
# TURN = 1
# NOTHING = 0
#
# @classmethod
# def from_string(cls, value):
# if value == 'long' or value == 'long rest':
# return RestLength.LONG
# elif value == 'short' or value == 'short rest':
# return RestLength.SHORT
# elif value == 'turn':
# return RestLength.TURN
# else:
# return RestLength.NOTHING
. Output only the next line. | raise NotImplementedError |
Given the following code snippet before the placeholder: <|code_start|>
__doc__ = """
The zsys class provides miscellaneous functions. Only a limited set of
functions are exposed from the czmq zsys module as many duplicate
<|code_end|>
, predict the next line using imports from the current file:
from pyczmq._cffi import C, ffi, cdef
and context including class names, function names, and sometimes code from other files:
# Path: pyczmq/_cffi.py
# C = ffi.dlopen('czmq')
# Z = ffi.dlopen('zmq')
# def ptop(typ, val):
# def cdef(decl, returns_string=False, nullable=False):
# def wrap(f):
# def inner_f(*args):
. Output only the next line. | functionality of built-in python types or libraries. |
Here is a snippet: <|code_start|>
__doc__ = """
The zloop class provides an event-driven reactor pattern. The reactor
handles zmq_pollitem_t items (pollers or writers, sockets or fds), and
<|code_end|>
. Write the next line using the current file imports:
from pyczmq._cffi import ffi, C, ptop, cdef
and context from other files:
# Path: pyczmq/_cffi.py
# C = ffi.dlopen('czmq')
# Z = ffi.dlopen('zmq')
# def ptop(typ, val):
# def cdef(decl, returns_string=False, nullable=False):
# def wrap(f):
# def inner_f(*args):
, which may include functions, classes, or code. Output only the next line. | once-off or repeated timers. Its resolution is 1 msec. It uses a |
Here is a snippet: <|code_start|>from __future__ import print_function
__doc__ = """
The zframe class provides methods to send and receive single message
frames across 0MQ sockets. A frame corresponds to one zmq_msg_t. When
you read a frame from a socket, the zframe_more() method indicates if
the frame is part of an unfinished multipart message. The zframe_send
<|code_end|>
. Write the next line using the current file imports:
from pyczmq._cffi import C, cdef, ffi, ptop
and context from other files:
# Path: pyczmq/_cffi.py
# C = ffi.dlopen('czmq')
# Z = ffi.dlopen('zmq')
# def ptop(typ, val):
# def cdef(decl, returns_string=False, nullable=False):
# def wrap(f):
# def inner_f(*args):
, which may include functions, classes, or code. Output only the next line. | method normally destroys the frame, but with the ZFRAME_REUSE flag, |
Based on the snippet: <|code_start|>from __future__ import print_function
__doc__ = """
The zframe class provides methods to send and receive single message
frames across 0MQ sockets. A frame corresponds to one zmq_msg_t. When
you read a frame from a socket, the zframe_more() method indicates if
<|code_end|>
, predict the immediate next line with the help of imports:
from pyczmq._cffi import C, cdef, ffi, ptop
and context (classes, functions, sometimes code) from other files:
# Path: pyczmq/_cffi.py
# C = ffi.dlopen('czmq')
# Z = ffi.dlopen('zmq')
# def ptop(typ, val):
# def cdef(decl, returns_string=False, nullable=False):
# def wrap(f):
# def inner_f(*args):
. Output only the next line. | the frame is part of an unfinished multipart message. The zframe_send |
Given the following code snippet before the placeholder: <|code_start|>from __future__ import print_function
__doc__ = """
The zframe class provides methods to send and receive single message
frames across 0MQ sockets. A frame corresponds to one zmq_msg_t. When
you read a frame from a socket, the zframe_more() method indicates if
the frame is part of an unfinished multipart message. The zframe_send
method normally destroys the frame, but with the ZFRAME_REUSE flag,
you can send the same frame many times. Frames are binary, and this
<|code_end|>
, predict the next line using imports from the current file:
from pyczmq._cffi import C, cdef, ffi, ptop
and context including class names, function names, and sometimes code from other files:
# Path: pyczmq/_cffi.py
# C = ffi.dlopen('czmq')
# Z = ffi.dlopen('zmq')
# def ptop(typ, val):
# def cdef(decl, returns_string=False, nullable=False):
# def wrap(f):
# def inner_f(*args):
. Output only the next line. | class has no special support for text data. |
Continue the code snippet: <|code_start|>
def test_zmq():
version = zmq.version()
assert version
<|code_end|>
. Use current file imports:
from pyczmq import zmq
and context (classes, functions, or code) from other files:
# Path: pyczmq/zmq.py
# IO_THREADS = 1
# MAX_SOCKETS = 2
# IO_THREADS_DFLT = 1
# MAX_SOCKETS_DFLT = 1024
# POLLIN = 1
# POLLOUT = 2
# POLLERR = 4
# EVENT_CONNECTED = 1
# EVENT_CONNECT_DELAYED = 2
# EVENT_CONNECT_RETRIED = 4
# EVENT_LISTENING = 8
# EVENT_BIND_FAILED = 16
# EVENT_ACCEPTED = 32
# EVENT_ACCEPT_FAILED = 64
# EVENT_CLOSED = 128
# EVENT_CLOSE_FAILED = 256
# EVENT_DISCONNECTED = 512
# EVENT_MONITOR_STOPPED = 1024
# EVENT_ALL = (EVENT_CONNECTED | EVENT_CONNECT_DELAYED |
# EVENT_CONNECT_RETRIED | EVENT_LISTENING |
# EVENT_BIND_FAILED | EVENT_ACCEPTED |
# EVENT_ACCEPT_FAILED | EVENT_CLOSED |
# EVENT_CLOSE_FAILED | EVENT_DISCONNECTED |
# EVENT_MONITOR_STOPPED)
# PAIR = 0
# PUB = 1
# SUB = 2
# REQ = 3
# REP = 4
# DEALER = 5
# ROUTER = 6
# PULL = 7
# PUSH = 8
# XPUB = 9
# XSUB = 10
# STREAM = 11
# AFFINITY = 4
# IDENTITY = 5
# SUBSCRIBE = 6
# UNSUBSCRIBE = 7
# RATE = 8
# RECOVERY_IVL = 9
# SNDBUF = 11
# RCVBUF = 12
# RCVMORE = 13
# FD = 14
# EVENTS = 15
# TYPE = 16
# LINGER = 17
# RECONNECT_IVL = 18
# BACKLOG = 19
# RECONNECT_IVL_MAX = 21
# MAXMSGSIZE = 22
# SNDHWM = 23
# RCVHWM = 24
# MULTICAST_HOPS = 25
# RCVTIMEO = 27
# SNDTIMEO = 28
# LAST_ENDPOINT = 32
# ROUTER_MANDATORY = 33
# TCP_KEEPALIVE = 34
# TCP_KEEPALIVE_CNT = 35
# TCP_KEEPALIVE_IDLE = 36
# TCP_KEEPALIVE_INTVL = 37
# TCP_ACCEPT_FILTER = 38
# IMMEDIATE = 39
# XPUB_VERBOSE = 40
# ROUTER_RAW = 41
# IPV6 = 42
# MECHANISM = 43
# PLAIN_SERVER = 44
# PLAIN_USERNAME = 45
# PLAIN_PASSWORD = 46
# CURVE_SERVER = 47
# CURVE_PUBLICKEY = 48
# CURVE_SECRETKEY = 49
# CURVE_SERVERKEY = 50
# PROBE_ROUTER = 51
# REQ_CORRELATE = 52
# REQ_RELAXED = 53
# CONFLATE = 54
# ZAP_DOMAIN = 55
# MORE = 1
# DONTWAIT = 1
# SNDMORE = 2
# NULL = 0
# PLAIN = 1
# CURVE = 2
# def errno():
# def version():
# def strerror(num):
# def ctx_new():
# def ctx_term(ctx):
# def ctx_shutdown(ctx):
# def ctx_set(ctx, opt, val):
# def ctx_get(ctx, opt):
# def msg_init(msg):
# def msg_init_size(msg, size):
# def msg_init_data(msg, data, size, ffn, hint):
# def msg_send(msg, s, flags):
# def msg_recv(msg, s, flags):
# def msg_close(msg):
# def msg_move(dest, src):
# def msg_copy(dest, src):
# def msg_data(msg):
# def msg_size(msg):
# def msg_more(msg):
# def msg_get(msg, opt):
# def msg_set(msg, opt, val):
# def socket(ctx, typ):
# def close(sock):
# def setsockopt(sock, opt, val, len):
# def getsockopt(sock, opt, val, len):
# def bind(sock, addr):
# def connect(sock, addr):
# def unbind(sock, addr):
# def disconnect(sock, addr):
# def send(sock, buf, len, flags):
# def recv(sock, buf, len, flags):
# def socket_monitor(sock, addr, events):
# def sendmsg(sock, msg, flags):
# def recvmsg(sock, msg, flags):
# def pollitem(socket=None, fd=0, events=0, revents=0):
# def poll(items, nitem, timeout):
# def proxy(frontend, backend, capture):
# def z85_encode(dest, data, size):
# def z85_decode(dest, string):
. Output only the next line. | assert len(version) == 3 |
Given the code snippet: <|code_start|> void zsocket_set_plain_password (void *zocket, const char * plain_password);
void zsocket_set_curve_server (void *zocket, int curve_server);
void zsocket_set_curve_publickey (void *zocket, const char * curve_publickey);
void zsocket_set_curve_publickey_bin (void *zocket, const char *curve_publickey);
void zsocket_set_curve_secretkey (void *zocket, const char * curve_secretkey);
void zsocket_set_curve_secretkey_bin (void *zocket, const char *curve_secretkey);
void zsocket_set_curve_serverkey (void *zocket, const char * curve_serverkey);
void zsocket_set_curve_serverkey_bin (void *zocket, const char *curve_serverkey);
void zsocket_set_zap_domain (void *zocket, const char * zap_domain);
void zsocket_set_sndhwm (void *zocket, int sndhwm);
void zsocket_set_rcvhwm (void *zocket, int rcvhwm);
void zsocket_set_affinity (void *zocket, int affinity);
void zsocket_set_subscribe (void *zocket, const char * subscribe);
void zsocket_set_unsubscribe (void *zocket, const char * unsubscribe);
void zsocket_set_identity (void *zocket, const char * identity);
void zsocket_set_rate (void *zocket, int rate);
void zsocket_set_recovery_ivl (void *zocket, int recovery_ivl);
void zsocket_set_sndbuf (void *zocket, int sndbuf);
void zsocket_set_rcvbuf (void *zocket, int rcvbuf);
void zsocket_set_linger (void *zocket, int linger);
void zsocket_set_reconnect_ivl (void *zocket, int reconnect_ivl);
void zsocket_set_reconnect_ivl_max (void *zocket, int reconnect_ivl_max);
void zsocket_set_backlog (void *zocket, int backlog);
void zsocket_set_maxmsgsize (void *zocket, int maxmsgsize);
void zsocket_set_multicast_hops (void *zocket, int multicast_hops);
void zsocket_set_rcvtimeo (void *zocket, int rcvtimeo);
void zsocket_set_sndtimeo (void *zocket, int sndtimeo);
void zsocket_set_xpub_verbose (void *zocket, int xpub_verbose);
void zsocket_set_tcp_keepalive (void *zocket, int tcp_keepalive);
void zsocket_set_tcp_keepalive_idle (void *zocket, int tcp_keepalive_idle);
<|code_end|>
, generate the next line using the imports in this file:
from pyczmq._cffi import C, ffi, cdef
and context (functions, classes, or occasionally code) from other files:
# Path: pyczmq/_cffi.py
# C = ffi.dlopen('czmq')
# Z = ffi.dlopen('zmq')
# def ptop(typ, val):
# def cdef(decl, returns_string=False, nullable=False):
# def wrap(f):
# def inner_f(*args):
. Output only the next line. | void zsocket_set_tcp_keepalive_cnt (void *zocket, int tcp_keepalive_cnt); |
Next line prediction: <|code_start|> int zsocket_sndbuf (void *zocket);
int zsocket_rcvbuf (void *zocket);
int zsocket_linger (void *zocket);
int zsocket_reconnect_ivl (void *zocket);
int zsocket_reconnect_ivl_max (void *zocket);
int zsocket_backlog (void *zocket);
int zsocket_maxmsgsize (void *zocket);
int zsocket_multicast_hops (void *zocket);
int zsocket_rcvtimeo (void *zocket);
int zsocket_sndtimeo (void *zocket);
int zsocket_tcp_keepalive (void *zocket);
int zsocket_tcp_keepalive_idle (void *zocket);
int zsocket_tcp_keepalive_cnt (void *zocket);
int zsocket_tcp_keepalive_intvl (void *zocket);
char * zsocket_tcp_accept_filter (void *zocket);
int zsocket_rcvmore (void *zocket);
int zsocket_fd (void *zocket);
int zsocket_events (void *zocket);
char * zsocket_last_endpoint (void *zocket);
// Set socket options
void zsocket_set_ipv6 (void *zocket, int ipv6);
void zsocket_set_immediate (void *zocket, int immediate);
void zsocket_set_router_raw (void *zocket, int router_raw);
void zsocket_set_ipv4only (void *zocket, int ipv4only);
void zsocket_set_delay_attach_on_connect (void *zocket, int delay_attach_on_connect);
void zsocket_set_router_mandatory (void *zocket, int router_mandatory);
void zsocket_set_probe_router (void *zocket, int probe_router);
void zsocket_set_req_relaxed (void *zocket, int req_relaxed);
void zsocket_set_req_correlate (void *zocket, int req_correlate);
<|code_end|>
. Use current file imports:
(from pyczmq._cffi import C, ffi, cdef)
and context including class names, function names, or small code snippets from other files:
# Path: pyczmq/_cffi.py
# C = ffi.dlopen('czmq')
# Z = ffi.dlopen('zmq')
# def ptop(typ, val):
# def cdef(decl, returns_string=False, nullable=False):
# def wrap(f):
# def inner_f(*args):
. Output only the next line. | void zsocket_set_conflate (void *zocket, int conflate); |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.