Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Given snippet: <|code_start|># 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 the Virtual Vision Simulator.
# If not, see <http://www.gnu.org/licenses/>.
#
class PandaCameraBuilder:
"""Used to build different types of cameras"""
def __init__(self, parent):
self.parent = parent
def buildPandaPTZCamera(self, config):
buffer = self.makeFBO("camera buffer")
panda_camera = base.makeCamera(buffer)
panda_camera.reparentTo(render)
path = Filename.fromOsSpecific(os.path.dirname(__file__))
camera_model = loader.loadModel("%s/../camera/camera.egg" % path)
camera_model.setScale(0.3)
camera_model.reparentTo(render)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
from pandac.PandaModules import Spotlight
from pandac.PandaModules import Filename
from panda3d.core import (WindowProperties, FrameBufferProperties, GraphicsPipe,
GraphicsOutput, Texture)
from direct.actor.Actor import Actor
from ..camera.panda_ptz_camera import PandaPTZCamera
and context:
# Path: src/simulator/panda3d/camera/panda_ptz_camera.py
# class PandaPTZCamera(PandaCamera):
#
# def __init__(self, buffer, camera, camera_model):
# PandaCamera.__init__(self, buffer, camera, camera_model)
# self.zoom_motor = Motor(self, "setFov")
# self.pan_motor = Motor(self, "setPan")
# self.tilt_motor = Motor(self, "setTilt")
# self.reset()
#
# def zoomIn(self, angle=10, time=1.0):
# current = self.getFov()
# new = current - angle
# self.zoom_motor.newValue(current, new, time)
#
#
# def zoomOut(self, angle=10, time=1.0):
# current = self.getFov()
# new = current + angle
# self.zoom_motor.newValue(current, new, time)
#
#
# def panLeft(self, angle=10, time=1.0):
# current = self.getPan()
# new = current - angle
# self.pan_motor.newValue(current, new, time)
#
#
# def panRight(self, angle=10, time=1.0):
# current = self.getPan()
# new = current + angle
# self.pan_motor.newValue(current, new, time)
#
#
# def tiltUp(self, angle=10, time=1.0):
# current = self.getTilt()
# new = current + angle
# self.tilt_motor.newValue(current, new, time)
#
#
# def tiltDown(self, angle=10, time=1.0):
# current = self.getTilt()
# new = current - angle
# self.tilt_motor.newValue(current, new, time)
#
#
# def revertToDefault(self, time=1.0):
# fov = self.getDefaultFov()
# cur_fov = self.getFov()
# self.zoom_motor.newValue(cur_fov, fov, time)
#
# pan = 0
# cur_pan = self.getPan()
# self.pan_motor.newValue(cur_pan, pan, time)
#
# tilt = 0
# cur_tilt = self.getTilt()
# self.tilt_motor.newValue(cur_tilt, tilt, time)
#
#
# def reset(self):
# self.zoom_motor.stop()
# self.pan_motor.stop()
# self.tilt_motor.stop()
#
# self.setFov(self.getDefaultFov())
# self.setPan(0)
# self.setTilt(0)
# self.cur_time = 0
#
#
# def update(self, time):
# increment = time - self.cur_time
# self.cur_time = time
# self.zoom_motor.update(increment)
# self.pan_motor.update(increment)
# self.tilt_motor.update(increment)
which might include code, classes, or functions. Output only the next line. | panda_ptz_camera = PandaPTZCamera(buffer, panda_camera, camera_model) |
Given snippet: <|code_start|> self.pedestrian_count = 0
self.characters = {}
def buildPedestrian(self, character_name, texture, scale, hpr, pos):
"""Builds a Panda3D actor by using the specified model and texture"""
if not character_name in self.characters:
return
character = self.characters[character_name]
model_path = os.path.normpath("%s/%s"
% (self.config_path, character['model']))
if not os.path.exists(model_path):
logging.error("The path '%s' does not exist" % model_path)
sys.exit()
actor = Actor(model_path)
tex_dir = character['texture_dir']
tex_path = os.path.normpath("%s/%s/%s"
%(self.config_path, tex_dir, texture))
if not os.path.exists(tex_path):
logging.error("The path '%s' does not exist" % tex_path)
sys.exit()
tex = loader.loadTexture(tex_path)
actor.setTexture(tex,1)
actor.reparentTo(self.parent.render)
actor.setScale(scale)
actor.setHpr(VBase3(*hpr))
actor.setPos(*ToPandaCoordinates(VBase3(*pos)))
joint = character['joint']
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import logging
import sys
from pandac.PandaModules import Spotlight
from direct.actor.Actor import Actor
from pandac.PandaModules import VBase3
from ..panda3d_helper import *
from ..panda_pedestrian import PandaPedestrian
and context:
# Path: src/simulator/panda3d/panda_pedestrian.py
# class PandaPedestrian:
#
#
# def __init__(self, actor, texture, taskMgr, joint):
# self.taskMgr = taskMgr
# self.actor = actor
# self.texture = texture
# self.joint = self.actor.exposeJoint(None, 'modelRoot', joint)
#
# self.animations = {}
# self.actions = {}
# self.command_queue = []
# self.cur_action = 'stand'
#
# self.type = "male"
# self.id = -1
# self.pos = np.array([0,0,0])
# self.loop = False
# self.sequence = Parallel()
#
# self.live_controller = False
# self.print_action = False
# self.start_time = 0.0
#
#
# def getActor(self):
# return self.actor
#
#
# def getTexture(self):
# return self.texture
#
#
# def setColor(self, color):
# pass
#
#
# def setId(self, id):
# self.id = id
#
#
# def getId(self):
# return self.id
#
#
# def setType(self, type):
# self.type = type
#
#
# def getType(self):
# return self.type
#
#
# def getBounds(self):
# return self.actor.getTightBounds()
#
#
# def addAnimation(self, name, path):
# self.animations[name] = path
# self.actor.loadAnims({name:path})
#
#
# def addAction(self, name, angle, diff):
# self.actions[name] = Action(name, angle, VBase3(*diff))
#
#
# def addCommand(self, command):
# if command in self.actions:
# self.command_queue.append(command)
# else:
# print "Error: invalid command"
#
#
# def addCommands(self, commands):
# for command in commands:
# self.addCommand(command)
#
#
# def setStartTime(self, time):
# self.start_time = time
#
#
# def update(self, time):
# if self.cur_action:
# name = self.cur_action
# anim_controller = self.actor.getAnimControl(name)
# next_frame = anim_controller.getNextFrame()
# cur_frame = anim_controller.getFullFframe()
# num_frames = anim_controller.getNumFrames()
#
# if not self.sequence.isPlaying():
# # if not anim_controller.isPlaying():
# if self.command_queue:
# next_action = self.command_queue.pop(0)
# self.startAction(next_action)
# else:
# if self.live_controller:
# if self.cur_action == 'run':
# next_action = 'run'
# elif self.cur_action == 'stand':
# next_action = 'stand'
# else:
# next_action = 'walk'
#
# self.startAction(next_action)
#
#
# def isActive(self, time):
# if time >= self.start_time and self.command_queue or \
# time >= self.start_time and self.live_controller:
# if self.actor.isHidden():
# self.actor.show()
# return True
# else:
# if not self.actor.isHidden():
# self.actor.hide()
# return False
#
#
# def reposition(self, diff, rotation):
# x,y,z = diff
# self.actor.setX(x)
# self.actor.setY(y)
# self.actor.setH(self.actor.getH() + rotation)
# # name = self.cur_action
# # anim_controller = self.actor.getAnimControl(name)
# # cur_frame = anim_controller.getFullFframe()
# # print cur_frame
#
#
# def liveController(self):
# self.print_action = True
# self.live_controller = True
#
#
# def startAction(self, action):
# cur_action = self.cur_action
# rotation = self.actions[cur_action].rotation
# self.cur_action = action
# paction = self.actions[action]
# if cur_action != "stand":
# diff = self.joint.getPos(render) - paction.diff
# else:
# diff = self.actor.getPos()
#
# if self.print_action:
# print paction.name,
#
# interval = self.actor.actorInterval(paction.name)
# func = Func(self.reposition, diff, rotation)
# self.sequence = Parallel(Sequence(Wait(0.001),func), interval)
# self.sequence.start()
which might include code, classes, or functions. Output only the next line. | panda_pedestrian = PandaPedestrian(actor, texture, self.parent.taskMgr, joint) |
Using the snippet: <|code_start|>
__all__ = [
'Employee'
]
def current_date():
return timezone.now().date()
<|code_end|>
, determine the next line of code. You have imports:
from django.conf import settings
from django.db import models
from django.utils import timezone
from django.utils.translation import ugettext_lazy as _
from apps.contacts.mixins import ContactMixin
and context (class names, function names, or code) available:
# Path: apps/contacts/mixins.py
# class ContactMixin(object):
# """
# Would be used for adding contacts functionality to Employee model.
# """
#
# def get_contacts(self, is_primary=False):
# """
# Returns dict with all contacts.
# Example:
# >> obj.get_contacts()
# << {'email': [], 'skype': []}
#
# :param is_primary: bool Return only primary contacts.
# :return: dict
# """
# subclasses = BaseContact.__subclasses__()
# results = {}
# for cls in subclasses:
# queryset = cls.objects.filter(employee_id=self.id, is_active=True)
# key, verbose = cls.CONTACT_EXTRA_DATA
# if is_primary:
# queryset = queryset.filter(is_primary=True)
# results.setdefault(key, queryset)
# return results
. Output only the next line. | class Employee(ContactMixin, models.Model): |
Predict the next line after this snippet: <|code_start|>
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^api-token-auth/$', obtain_jwt_token),
url(r'^api-token-refresh/$', refresh_jwt_token),
url(r'^api-token-verify/$', verify_jwt_token),
<|code_end|>
using the current file's imports:
from django.contrib import admin
from django.conf import settings
from django.conf.urls import include, url
from rest_framework_jwt.views import (obtain_jwt_token, refresh_jwt_token,
verify_jwt_token)
from office.views import DRFAuthenticatedGraphQLView
import debug_toolbar
and any relevant context from other files:
# Path: office/views.py
# class DRFAuthenticatedGraphQLView(GraphQLView):
# """
# Extended default GraphQLView.
# """
#
# @method_decorator(check_jwt_decorator)
# def dispatch(self, request, *args, **kwargs):
# return super(DRFAuthenticatedGraphQLView, self).dispatch(
# request, *args, **kwargs)
. Output only the next line. | url(r'^graphql/$', DRFAuthenticatedGraphQLView.as_view(graphiql=True)), |
Given the code snippet: <|code_start|>
class BookModelTest(TestCase):
def setUp(self):
self.book = mommy.make(Book)
def test_string_representation(self):
self.assertEqual(str(self.book), self.book.name)
def test_verbose_name_plural(self):
self.assertEqual(str(Book._meta.verbose_name_plural), 'books')
def test_kind_book_create_instance(self):
self.assertIsInstance(self.book, Book)
class HolderModelTest(TestCase):
def setUp(self):
<|code_end|>
, generate the next line using the imports in this file:
from django.test import TestCase
from apps.library.models import Book, Holder, Offer, Tag, Author, Publisher
from apps.employees.models import Employee
from model_mommy import mommy
and context (functions, classes, or occasionally code) from other files:
# Path: apps/library/models/book.py
# class Book(models.Model):
# name = models.CharField(_('name'), max_length=1024)
# authors = models.ManyToManyField('library.Author', verbose_name=_('authors'),
# blank=False, related_name='books')
# publishers = models.ManyToManyField('library.Publisher', verbose_name=_('publishers'),
# blank=True, related_name='books')
# description = models.TextField(_('description'), default='', blank=True)
# tags = models.ManyToManyField('library.Tag', verbose_name=_('tags'),
# blank=True, related_name='books')
# specializations = models.ManyToManyField('employees.specialization',
# blank=True, related_name='books',
# verbose_name=_('specializations'))
# created_at = models.DateTimeField(_('created at'), auto_now_add=True)
#
# def __str__(self):
# return self.name
#
# class Meta:
# verbose_name = _('book')
# verbose_name_plural = _('books')
#
# Path: apps/library/models/offer.py
# class Offer(models.Model):
# book = models.OneToOneField('library.Book', blank=True, default=None,
# verbose_name=_('book'), related_name='offer',
# null=True)
# employee = models.ForeignKey('employees.Employee',
# verbose_name=_('employee'),
# related_name='book_offers')
# name = models.CharField(_('name'), max_length=512, default='', blank=True)
# url = models.CharField(_('url'), max_length=512, default='', blank=True)
# price = models.IntegerField(_('price'), default=0)
# count = models.PositiveIntegerField(_('count'), default=1)
# description = models.TextField(_('description'), default='', blank=True)
# created_at = models.DateTimeField(_('created at'), auto_now_add=True)
#
# def __str__(self):
# return self.name or self.url
#
# class Meta:
# verbose_name = _('offer')
# verbose_name_plural = _('offers')
#
# Path: apps/library/models/holder.py
# class Holder(models.Model):
# employee = models.ForeignKey('employees.Employee',
# verbose_name=_('employee'),
# related_name='holder_history')
# book = models.ForeignKey('library.Book', related_name='holder_history',
# verbose_name=_('book'))
# notes = models.TextField(_('notes'), default='', blank=True)
# created_at = models.DateTimeField(_('created at'), auto_now_add=True)
# refunded_at = models.DateTimeField(_('refunded at'), null=True, blank=True)
#
# class Meta:
# verbose_name = _('holder')
# verbose_name_plural = _('holders')
#
# Path: apps/library/models/tag.py
# class Tag(models.Model):
#
# name = models.CharField(_('name'), max_length=256, unique=True)
#
# class Meta:
# verbose_name = _('tag')
# verbose_name_plural = _('tags')
#
# Path: apps/library/models/author.py
# class Author(models.Model):
# name = models.CharField(_('name'), max_length=1024)
# about = models.TextField(_('about'), default='', blank=True)
# created_at = models.DateTimeField(_('created at'), auto_now_add=True)
#
# def __str__(self):
# return self.name
#
# class Meta:
# verbose_name = _('author')
# verbose_name_plural = _('authors')
#
# Path: apps/library/models/publisher.py
# class Publisher(models.Model):
# title = models.CharField(_('name'), max_length=1024)
# description = models.TextField(_('description'), default='', blank=True)
# created_at = models.DateTimeField(_('created at'), auto_now_add=True)
#
# def __str__(self):
# return self.title
#
# class Meta:
# verbose_name = _('publisher')
# verbose_name_plural = _('publishers')
#
# Path: apps/employees/models/employee.py
# class Employee(ContactMixin, models.Model):
#
# user = models.OneToOneField(settings.AUTH_USER_MODEL, related_name='employee')
# first_name = models.CharField(_('first name'), max_length=128)
# last_name = models.CharField(_('last name'), max_length=128)
# middle_name = models.CharField(
# _('middle name'), default='', max_length=128, blank=True
# )
# notes = models.TextField(_('notes'), default='', blank=True)
# birthday = models.DateField(
# _('birthday'), default=None, null=True, blank=True
# )
# specializations = models.ManyToManyField(
# 'employees.Specialization', verbose_name=_('specializations'),
# related_name='employees', blank=True
# )
# position = models.ForeignKey(
# 'employees.Position', related_name='employees',
# verbose_name=_('position'),
# )
# work_started = models.DateField(_('work started'), default=current_date)
#
# def __str__(self):
# return '{first_name} {last_name}'.format(
# first_name=self.first_name, last_name=self.last_name
# )
#
# class Meta:
# verbose_name = _('employee')
# verbose_name_plural = _('employees')
. Output only the next line. | self.holder = mommy.make(Holder) |
Based on the snippet: <|code_start|>
class ContactMixin(object):
"""
Would be used for adding contacts functionality to Employee model.
"""
def get_contacts(self, is_primary=False):
"""
Returns dict with all contacts.
Example:
>> obj.get_contacts()
<< {'email': [], 'skype': []}
:param is_primary: bool Return only primary contacts.
:return: dict
"""
<|code_end|>
, predict the immediate next line with the help of imports:
from apps.contacts.models import BaseContact
and context (classes, functions, sometimes code) from other files:
# Path: apps/contacts/models.py
# class BaseContact(models.Model):
# employee = models.ForeignKey('employees.Employee',
# verbose_name=_('employee'),
# related_name='%(class)s_contact_list')
# is_primary = models.BooleanField(_('is primary'), default=False)
# is_active = models.BooleanField(_('is active'), default=True)
# created_at = models.DateTimeField(_('created at'), auto_now_add=True)
#
# class Meta:
# abstract = True
. Output only the next line. | subclasses = BaseContact.__subclasses__() |
Continue the code snippet: <|code_start|>x = Dense(1)(x)
x = Activation('linear')(x)
critic = Model(inputs=[action_input, observation_input], outputs=x)
print(critic.summary())
# Set up the agent for training
memory = SequentialMemory(limit=100000, window_length=1)
random_process = OrnsteinUhlenbeckProcess(theta=.15, mu=0., sigma=.2, size=env.noutput)
agent = DDPGAgent(nb_actions=nb_actions, actor=actor, critic=critic, critic_action_input=action_input,
memory=memory, nb_steps_warmup_critic=100, nb_steps_warmup_actor=100,
random_process=random_process, gamma=.99, target_model_update=1e-3,
delta_clip=1.)
# agent = ContinuousDQNAgent(nb_actions=env.noutput, V_model=V_model, L_model=L_model, mu_model=mu_model,
# memory=memory, nb_steps_warmup=1000, random_process=random_process,
# gamma=.99, target_model_update=0.1)
agent.compile(Adam(lr=.001, clipnorm=1.), metrics=['mae'])
# Okay, now it's time to learn something! We visualize the training here for show, but this
# slows down training quite a lot. You can always safely abort the training prematurely using
# Ctrl + C.
if args.train:
agent.fit(env, nb_steps=nallsteps, visualize=False, verbose=1, nb_max_episode_steps=env.timestep_limit, log_interval=10000)
# After training is done, we save the final weights.
agent.save_weights(args.model, overwrite=True)
# If TEST and TOKEN, submit to crowdAI
if not args.train and args.token:
agent.load_weights(args.model)
# Settings
remote_base = 'http://grader.crowdai.org:1729'
<|code_end|>
. Use current file imports:
import opensim as osim
import numpy as np
import sys
import numpy as np
import argparse
import math
from keras.models import Sequential, Model
from keras.layers import Dense, Activation, Flatten, Input, concatenate
from keras.optimizers import Adam
from rl.agents import DDPGAgent
from rl.memory import SequentialMemory
from rl.random import OrnsteinUhlenbeckProcess
from osim.env import *
from osim.http.client import Client
from keras.optimizers import RMSprop
and context (classes, functions, or code) from other files:
# Path: osim/http/client.py
# class Client(object):
# """
# Gym client to interface with gym_http_server
# """
# def __init__(self, remote_base):
# self.remote_base = remote_base
# self.session = requests.Session()
# self.session.headers.update({'Content-type': 'application/json'})
# self.instance_id = None
#
# def _parse_server_error_or_raise_for_status(self, resp):
# j = {}
# try:
# j = resp.json()
# except:
# # Most likely json parse failed because of network error, not server error (server
# # sends its errors in json). Don't let parse exception go up, but rather raise default
# # error.
# resp.raise_for_status()
# if resp.status_code != 200 and "message" in j: # descriptive message from server side
# raise ServerError(message=j["message"], status_code=resp.status_code)
# resp.raise_for_status()
# return j
#
# def _post_request(self, route, data):
# url = urlparse.urljoin(self.remote_base, route)
# logger.info("POST {}\n{}".format(url, json.dumps(data)))
# resp = self.session.post(urlparse.urljoin(self.remote_base, route),
# data=json.dumps(data))
# return self._parse_server_error_or_raise_for_status(resp)
#
# def _get_request(self, route):
# url = urlparse.urljoin(self.remote_base, route)
# logger.info("GET {}".format(url))
# resp = self.session.get(url)
# return self._parse_server_error_or_raise_for_status(resp)
#
# def env_create(self, token, env_id = "Run"):
# route = '/v1/envs/'
# data = {'env_id': env_id,
# 'token': token,
# 'version': pkg_resources.get_distribution("osim-rl").version }
# try:
# resp = self._post_request(route, data)
# except ServerError as e:
# sys.exit(e.message)
# self.instance_id = resp['instance_id']
# self.env_monitor_start("tmp", force=True)
# return self.env_reset()
#
# def env_reset(self):
# route = '/v1/envs/{}/reset/'.format(self.instance_id)
# resp = self._post_request(route, None)
# observation = resp['observation']
# return observation
#
# def env_step(self, action, render=False):
# route = '/v1/envs/{}/step/'.format(self.instance_id)
# data = {'action': action, 'render': render}
# resp = self._post_request(route, data)
# observation = resp['observation']
# reward = resp['reward']
# done = resp['done']
# info = resp['info']
# return [observation, reward, done, info]
#
# def env_monitor_start(self, directory,
# force=False, resume=False, video_callable=False):
# route = '/v1/envs/{}/monitor/start/'.format(self.instance_id)
# data = {'directory': directory,
# 'force': force,
# 'resume': resume,
# 'video_callable': video_callable}
# self._post_request(route, data)
#
# def submit(self):
# route = '/v1/envs/{}/monitor/close/'.format(self.instance_id)
# result = self._post_request(route, None)
# if result['reward']:
# print("Your total reward from this submission: %f" % result['reward'])
# else:
# print("There was an error in your submission. Please contact administrators.")
# route = '/v1/envs/{}/close/'.format(self.instance_id)
# self.env_close()
#
# def env_close(self):
# route = '/v1/envs/{}/close/'.format(self.instance_id)
# self._post_request(route, None)
. Output only the next line. | client = Client(remote_base) |
Continue the code snippet: <|code_start|># Derived from keras-rl
# Command line parameters
parser = argparse.ArgumentParser(description='Train or test neural net motor controller')
parser.add_argument('--train', dest='train', action='store_true', default=True)
parser.add_argument('--test', dest='train', action='store_false', default=True)
parser.add_argument('--steps', dest='steps', action='store', default=10000, type=int)
parser.add_argument('--visualize', dest='visualize', action='store_true', default=False)
parser.add_argument('--model', dest='model', action='store', default="example.h5f")
args = parser.parse_args()
# set to get observation in array
#def _new_step(self, action, project=True, obs_as_dict=False):
# return super(Arm2DEnv, self).step(action, project=project, obs_as_dict=obs_as_dict)
#Arm2DEnv.step = _new_step
# Load walking environment
<|code_end|>
. Use current file imports:
import opensim as osim
import numpy as np
import sys
import numpy as np
import argparse
import math
from keras.models import Sequential, Model
from keras.layers import Dense, Activation, Flatten, Input, concatenate
from keras.optimizers import Adam
from rl.agents import DDPGAgent
from rl.memory import SequentialMemory
from rl.random import OrnsteinUhlenbeckProcess
from osim.env.arm import Arm2DVecEnv
from keras.optimizers import RMSprop
and context (classes, functions, or code) from other files:
# Path: osim/env/arm.py
# class Arm2DVecEnv(Arm2DEnv):
# def reset(self, obs_as_dict=False):
# obs = super(Arm2DVecEnv, self).reset(obs_as_dict=obs_as_dict)
# if np.isnan(obs).any():
# obs = np.nan_to_num(obs)
# return obs
# def step(self, action, obs_as_dict=False):
# if np.isnan(action).any():
# action = np.nan_to_num(action)
# obs, reward, done, info = super(Arm2DVecEnv, self).step(action, obs_as_dict=obs_as_dict)
# if np.isnan(obs).any():
# obs = np.nan_to_num(obs)
# done = True
# reward -10
# return obs, reward, done, info
. Output only the next line. | env = Arm2DVecEnv(args.visualize) |
Given snippet: <|code_start|> metadata = {
'render.modes': ['human'],
'video.frames_per_second' : None
}
def get_reward(self):
raise NotImplementedError
def is_done(self):
return False
def __init__(self, visualize = True, integrator_accuracy = 5e-5):
self.visualize = visualize
self.integrator_accuracy = integrator_accuracy
self.load_model()
def load_model(self, model_path = None):
if model_path:
self.model_path = model_path
self.osim_model = OsimModel(self.model_path, self.visualize, integrator_accuracy = self.integrator_accuracy)
# Create specs, action and observation spaces mocks for compatibility with OpenAI gym
self.spec = Spec()
self.spec.timestep_limit = self.time_limit
self.action_space = ( [0.0] * self.osim_model.get_action_space_size(), [1.0] * self.osim_model.get_action_space_size() )
# self.observation_space = ( [-math.pi*100] * self.get_observation_space_size(), [math.pi*100] * self.get_observation_space_s
self.observation_space = ( [0] * self.get_observation_space_size(), [0] * self.get_observation_space_size() )
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import math
import numpy as np
import os
import gym
import opensim
import random
from .utils.mygym import convert_to_gym
from envs.target import VTgtField
and context:
# Path: osim/env/utils/mygym.py
# def convert_to_gym(space):
# return spaces.Box(np.array(space[0]), np.array(space[1]) )
which might include code, classes, or functions. Output only the next line. | self.action_space = convert_to_gym(self.action_space) |
Using the snippet: <|code_start|>
def flatten(listOfLists):
"Flatten one level of nesting"
return chain.from_iterable(listOfLists)
<|code_end|>
, determine the next line of code. You have imports:
import opensim
import math
import numpy as np
import os
import random
import string
from itertools import chain
from .osim import OsimEnv
and context (class names, function names, or code) available:
# Path: osim/env/legacy/osim.py
# class OsimEnv(gym.Env):
# stepsize = 0.01
# integration_accuracy = 1e-3
# timestep_limit = 1000
# test = False
#
# action_space = None
# observation_space = None
# osim_model = None
# istep = 0
#
# model_path = ""
# visualize = False
# ninput = 0
# noutput = 0
# last_action = None
# spec = None
#
# metadata = {
# 'render.modes': ['human'],
# 'video.frames_per_second' : 50
# }
#
# def __getstate__(self):
# state = self.__dict__.copy()
# del state['osim_model']
# print ("HERE1")
# return state
#
# def __setstate__(self, newstate):
# self.__dict__.update(newstate)
# self.osim_model = Osim(self.model_path, True)
# self.configure()
#
# def angular_dist(self, t,s):
# x = (t-s) % (2*math.pi)
# return min(x, 2*math.pi-x)
#
# def compute_reward(self):
# return 0.0
#
# def is_done(self):
# return False
#
# def terminate(self):
# pass
#
# def __init__(self, visualize = True, noutput = None):
# self.visualize = visualize
# self.osim_model = Osim(self.model_path, self.visualize)
#
# self.noutput = noutput
# if not noutput:
# self.noutput = self.osim_model.muscleSet.getSize()
# if not self.action_space:
# self.action_space = ( [0.0] * self.noutput, [1.0] * self.noutput )
# if not self.observation_space:
# self.observation_space = ( [-math.pi] * self.ninput, [math.pi] * self.ninput )
#
# self.action_space = convert_to_gym(self.action_space)
# self.observation_space = convert_to_gym(self.observation_space)
# self.spec = Spec()
# self.horizon = self.spec.timestep_limit
#
# self.configure()
# # self.reset()
#
# def configure(self):
# pass
#
#
# super(OsimEnv, self).reset()
# self.istep = 0
# self.osim_model.initializeState()
# return self.get_observation()
#
# def sanitify(self, x):
# if math.isnan(x):
# return 0.0
# BOUND = 1000.0
# if x > BOUND:
# x = BOUND
# if x < -BOUND:
# x = -BOUND
# return x
#
# def activate_muscles(self, action):
# if np.any(np.isnan(action)):
# raise ValueError("NaN passed in the activation vector. Values in [0,1] interval are required.")
# action = np.clip(action, 0.0, 1.0)
# self.last_action = action
#
# brain = opensim.PrescribedController.safeDownCast(self.osim_model.model.getControllerSet().get(0))
# functionSet = brain.get_ControlFunctions()
#
# for j in range(functionSet.getSize()):
# func = opensim.Constant.safeDownCast(functionSet.get(j))
# func.setValue( float(action[j]) )
#
# def step(self, action):
# self.activate_muscles(action)
#
# # Integrate one step
# if self.istep == 0:
# print ("Initializing the model!")
# self.manager = opensim.Manager(self.osim_model.model)
# self.osim_model.state.setTime(self.stepsize * self.istep)
# self.manager.initialize(self.osim_model.state)
# try:
# self.osim_model.state = self.manager.integrate(self.stepsize * (self.istep + 1))
# except Exception as e:
# print (e)
# return self.get_observation(), -500, True, {}
#
# self.istep = self.istep + 1
#
# res = [ self.get_observation(), self.compute_reward(), self.is_done(), {} ]
# return res
#
# def render(self, mode='human', close=False):
# pass
. Output only the next line. | class RunEnv(OsimEnv): |
Based on the snippet: <|code_start|>x = Dense(1)(x)
x = Activation('linear')(x)
critic = Model(inputs=[action_input, observation_input], outputs=x)
print(critic.summary())
# Set up the agent for training
memory = SequentialMemory(limit=100000, window_length=1)
random_process = OrnsteinUhlenbeckProcess(theta=.15, mu=0., sigma=.2, size=env.get_action_space_size())
agent = DDPGAgent(nb_actions=nb_actions, actor=actor, critic=critic, critic_action_input=action_input,
memory=memory, nb_steps_warmup_critic=100, nb_steps_warmup_actor=100,
random_process=random_process, gamma=.99, target_model_update=1e-3,
delta_clip=1.)
# agent = ContinuousDQNAgent(nb_actions=env.noutput, V_model=V_model, L_model=L_model, mu_model=mu_model,
# memory=memory, nb_steps_warmup=1000, random_process=random_process,
# gamma=.99, target_model_update=0.1)
agent.compile(Adam(lr=.001, clipnorm=1.), metrics=['mae'])
# Okay, now it's time to learn something! We visualize the training here for show, but this
# slows down training quite a lot. You can always safely abort the training prematurely using
# Ctrl + C.
if args.train:
agent.fit(env, nb_steps=nallsteps, visualize=False, verbose=1, nb_max_episode_steps=env.time_limit, log_interval=10000)
# After training is done, we save the final weights.
agent.save_weights(args.model, overwrite=True)
# If TEST and TOKEN, submit to crowdAI
if not args.train and args.token:
agent.load_weights(args.model)
# Settings
remote_base = 'http://grader.crowdai.org:1729'
<|code_end|>
, predict the immediate next line with the help of imports:
import numpy as np
import sys
import numpy as np
import argparse
import math
from keras.models import Sequential, Model
from keras.layers import Dense, Activation, Flatten, Input, concatenate
from keras.optimizers import Adam
from rl.agents import DDPGAgent
from rl.memory import SequentialMemory
from rl.random import OrnsteinUhlenbeckProcess
from osim.env import *
from osim.http.client import Client
from keras.optimizers import RMSprop
and context (classes, functions, sometimes code) from other files:
# Path: osim/http/client.py
# class Client(object):
# """
# Gym client to interface with gym_http_server
# """
# def __init__(self, remote_base):
# self.remote_base = remote_base
# self.session = requests.Session()
# self.session.headers.update({'Content-type': 'application/json'})
# self.instance_id = None
#
# def _parse_server_error_or_raise_for_status(self, resp):
# j = {}
# try:
# j = resp.json()
# except:
# # Most likely json parse failed because of network error, not server error (server
# # sends its errors in json). Don't let parse exception go up, but rather raise default
# # error.
# resp.raise_for_status()
# if resp.status_code != 200 and "message" in j: # descriptive message from server side
# raise ServerError(message=j["message"], status_code=resp.status_code)
# resp.raise_for_status()
# return j
#
# def _post_request(self, route, data):
# url = urlparse.urljoin(self.remote_base, route)
# logger.info("POST {}\n{}".format(url, json.dumps(data)))
# resp = self.session.post(urlparse.urljoin(self.remote_base, route),
# data=json.dumps(data))
# return self._parse_server_error_or_raise_for_status(resp)
#
# def _get_request(self, route):
# url = urlparse.urljoin(self.remote_base, route)
# logger.info("GET {}".format(url))
# resp = self.session.get(url)
# return self._parse_server_error_or_raise_for_status(resp)
#
# def env_create(self, token, env_id = "Run"):
# route = '/v1/envs/'
# data = {'env_id': env_id,
# 'token': token,
# 'version': pkg_resources.get_distribution("osim-rl").version }
# try:
# resp = self._post_request(route, data)
# except ServerError as e:
# sys.exit(e.message)
# self.instance_id = resp['instance_id']
# self.env_monitor_start("tmp", force=True)
# return self.env_reset()
#
# def env_reset(self):
# route = '/v1/envs/{}/reset/'.format(self.instance_id)
# resp = self._post_request(route, None)
# observation = resp['observation']
# return observation
#
# def env_step(self, action, render=False):
# route = '/v1/envs/{}/step/'.format(self.instance_id)
# data = {'action': action, 'render': render}
# resp = self._post_request(route, data)
# observation = resp['observation']
# reward = resp['reward']
# done = resp['done']
# info = resp['info']
# return [observation, reward, done, info]
#
# def env_monitor_start(self, directory,
# force=False, resume=False, video_callable=False):
# route = '/v1/envs/{}/monitor/start/'.format(self.instance_id)
# data = {'directory': directory,
# 'force': force,
# 'resume': resume,
# 'video_callable': video_callable}
# self._post_request(route, data)
#
# def submit(self):
# route = '/v1/envs/{}/monitor/close/'.format(self.instance_id)
# result = self._post_request(route, None)
# if result['reward']:
# print("Your total reward from this submission: %f" % result['reward'])
# else:
# print("There was an error in your submission. Please contact administrators.")
# route = '/v1/envs/{}/close/'.format(self.instance_id)
# self.env_close()
#
# def env_close(self):
# route = '/v1/envs/{}/close/'.format(self.instance_id)
# self._post_request(route, None)
. Output only the next line. | client = Client(remote_base) |
Predict the next line after this snippet: <|code_start|>
def _blocking_request(self, _request):
"""
request:
-command_type
-payload
-response_channel
response: (on response_channel)
- RESULT
* Send the payload on command_channel (self.namespace+"::command")
** redis-left-push (LPUSH)
* Keep listening on response_channel (BLPOP)
"""
assert type(_request) ==type({})
_request['response_channel'] = self._generate_response_channel()
_redis = self.get_redis_connection()
"""
The client always pushes in the left
and the service always pushes in the right
"""
if self.verbose: print("Request : ", _response)
# Push request in command_channels
payload = msgpack.packb(_request, default=m.encode, use_bin_type=True)
_redis.lpush(self.command_channel, payload)
## TODO: Check if we can use `repr` for json.dumps string serialization
# Wait with a blocking pop for the response
_response = _redis.blpop(_request['response_channel'])[1]
if self.verbose: print("Response : ", _response)
_response = msgpack.unpackb(_response, object_hook=m.decode, encoding="utf8")
<|code_end|>
using the current file's imports:
import redis
import json
import os
import pkg_resources
import sys
import numpy as np
import msgpack
import msgpack_numpy as m
import hashlib
import random
import time
import logging
from osim.redis import messages
and any relevant context from other files:
# Path: osim/redis/messages.py
# class OSIM_RL:
# PING = "OSIM_RL.PING"
# PONG = "OSIM_RL.PONG"
# ENV_CREATE = "OSIM_RL.ENV_CREATE"
# ENV_CREATE_RESPONSE = "OSIM_RL.ENV_CREATE_RESPONSE"
# ENV_RESET = "OSIM_RL.ENV_RESET"
# ENV_RESET_RESPONSE = "OSIM_RL.ENV_RESET_RESPONSE"
# ENV_STEP = "OSIM_RL.ENV_STEP"
# ENV_STEP_RESPONSE = "OSIM_RL.ENV_STEP_RESPONSE"
# ENV_SUBMIT = "OSIM_RL.ENV_SUBMIT"
# ENV_SUBMIT_RESPONSE = "OSIM_RL.ENV_SUBMIT_RESPONSE"
# ERROR = "OSIM_RL.ERROR"
. Output only the next line. | if _response['type'] == messages.OSIM_RL.ERROR: |
Continue the code snippet: <|code_start|> self.report = report
self.max_steps = max_steps
self.initalize_seed_map(seed_map)
def initalize_seed_map(self, seed_map_string):
if seed_map_string:
assert type(seed_map_string) == type("")
seed_map = seed_map_string.split(",")
seed_map = [int(x) for x in seed_map]
self.seed_map = seed_map
else:
self.seed_map = [np.random.randint(0,10**10)]
def get_redis_connection(self):
redis_conn = redis.Redis(connection_pool=self.redis_pool)
try:
redis_conn.ping()
except:
raise Exception(
"Unable to connect to redis server at {}:{} ."
"Are you sure there is a redis-server running at the "
"specified location ?".format(
self.remote_host,
self.remote_port
)
)
return redis_conn
def _error_template(self, payload):
_response = {}
<|code_end|>
. Use current file imports:
import redis
import json
import numpy as np
import msgpack
import msgpack_numpy as m
import osim
import os
import timeout_decorator
import time
import argparse
from osim.redis import messages
from osim.env import *
and context (classes, functions, or code) from other files:
# Path: osim/redis/messages.py
# class OSIM_RL:
# PING = "OSIM_RL.PING"
# PONG = "OSIM_RL.PONG"
# ENV_CREATE = "OSIM_RL.ENV_CREATE"
# ENV_CREATE_RESPONSE = "OSIM_RL.ENV_CREATE_RESPONSE"
# ENV_RESET = "OSIM_RL.ENV_RESET"
# ENV_RESET_RESPONSE = "OSIM_RL.ENV_RESET_RESPONSE"
# ENV_STEP = "OSIM_RL.ENV_STEP"
# ENV_STEP_RESPONSE = "OSIM_RL.ENV_STEP_RESPONSE"
# ENV_SUBMIT = "OSIM_RL.ENV_SUBMIT"
# ENV_SUBMIT_RESPONSE = "OSIM_RL.ENV_SUBMIT_RESPONSE"
# ERROR = "OSIM_RL.ERROR"
. Output only the next line. | _response['type'] = messages.OSIM_RL.ERROR |
Predict the next line for this snippet: <|code_start|>#!/usr/bin/env python
"""
NOTE: For testing your submission scripts, you first need to ensure that redis-server is running in the background
and you can locally run the grading service by running this script : https://github.com/crowdAI/osim-rl/blob/master/osim/redis/service.py
The client and the grading service communicate with each other by pointing to the same redis server.
"""
"""
Please ensure that `visualize=False`, else there might be unexpected errors in your submission
"""
env = ProstheticsEnv(visualize=False)
<|code_end|>
with the help of current file imports:
import opensim as osim
import numpy as np
import argparse
import os
from osim.redis.client import Client
from osim.env import *
and context from other files:
# Path: osim/redis/client.py
# class Client(object):
# """
# Redis client to interface with osim-rl redis-service
#
# The Docker container hosts a redis-server inside the container.
# This client connects to the same redis-server, and communicates with the service.
#
# The service eventually will reside outside the docker container, and will communicate
# with the client only via the redis-server of the docker container.
#
# On the instantiation of the docker container, one service will be instantiated parallely.
#
# The service will accepts commands at "`service_id`::commands"
# where `service_id` is either provided as an `env` variable or is
# instantiated to "osim_rl_redis_service_id"
# """
# def __init__(self, remote_host='127.0.0.1', remote_port=6379, remote_db=0, remote_password=None, verbose=False):
# self.redis_pool = redis.ConnectionPool(host=remote_host, port=remote_port, db=remote_db, password=remote_password)
# self.namespace = "osim-rl"
# try:
# self.service_id = os.environ['osim_rl_redis_service_id']
# except KeyError:
# self.service_id = "osim_rl_redis_service_id"
# self.command_channel = "{}::{}::commands".format(self.namespace, self.service_id)
# self.verbose = verbose
# self.ping_pong()
#
# def get_redis_connection(self):
# return redis.Redis(connection_pool=self.redis_pool)
#
# def _generate_response_channel(self):
# random_hash = hashlib.md5("{}".format(random.randint(0, 10**10)).encode('utf-8')).hexdigest()
# response_channel = "{}::{}::response::{}".format( self.namespace,
# self.service_id,
# random_hash)
# return response_channel
#
# def _blocking_request(self, _request):
# """
# request:
# -command_type
# -payload
# -response_channel
# response: (on response_channel)
# - RESULT
# * Send the payload on command_channel (self.namespace+"::command")
# ** redis-left-push (LPUSH)
# * Keep listening on response_channel (BLPOP)
# """
# assert type(_request) ==type({})
# _request['response_channel'] = self._generate_response_channel()
#
# _redis = self.get_redis_connection()
# """
# The client always pushes in the left
# and the service always pushes in the right
# """
# if self.verbose: print("Request : ", _response)
# # Push request in command_channels
# payload = msgpack.packb(_request, default=m.encode, use_bin_type=True)
# _redis.lpush(self.command_channel, payload)
# ## TODO: Check if we can use `repr` for json.dumps string serialization
# # Wait with a blocking pop for the response
# _response = _redis.blpop(_request['response_channel'])[1]
# if self.verbose: print("Response : ", _response)
# _response = msgpack.unpackb(_response, object_hook=m.decode, encoding="utf8")
# if _response['type'] == messages.OSIM_RL.ERROR:
# raise Exception(str(_response))
# else:
# return _response
#
# def ping_pong(self):
# """
# Official Handshake with the grading service
# Send a PING
# and wait for PONG
# If not PONG, raise error
# """
# _request = {}
# _request['type'] = messages.OSIM_RL.PING
# _request['payload'] = {}
# _response = self._blocking_request(_request)
# if _response['type'] != messages.OSIM_RL.PONG:
# raise Exception("Unable to perform handshake with the redis service. Expected PONG; received {}".format(json.dumps(_response)))
# else:
# return True
#
# def env_create(self):
# _request = {}
# _request['type'] = messages.OSIM_RL.ENV_CREATE
# _request['payload'] = {}
# _response = self._blocking_request(_request)
# observation = _response['payload']['observation']
# return observation
#
# def env_reset(self):
# _request = {}
# _request['type'] = messages.OSIM_RL.ENV_RESET
# _request['payload'] = {}
# _response = self._blocking_request(_request)
# observation = _response['payload']['observation']
# return observation
#
# def env_step(self, action, render=False):
# """
# Respond with [observation, reward, done, info]
# """
# action = np.array(action).tolist()
# _request = {}
# _request['type'] = messages.OSIM_RL.ENV_STEP
# _request['payload'] = {}
# _request['payload']['action'] = action
# _response = self._blocking_request(_request)
# _payload = _response['payload']
# observation = _payload['observation']
# reward = _payload['reward']
# done = _payload['done']
# info = _payload['info']
# return [observation, reward, done, info]
#
# def submit(self):
# _request = {}
# _request['type'] = messages.OSIM_RL.ENV_SUBMIT
# _request['payload'] = {}
# _response = self._blocking_request(_request)
# if os.getenv("CROWDAI_BLOCKING_SUBMIT"):
# """
# If the submission is supposed to happen as a blocking submit,
# then wait indefinitely for the evaluator to decide what to
# do with the container.
# """
# while True:
# time.sleep(10)
# return _response['payload']
, which may contain function names, class names, or code. Output only the next line. | client = Client() |
Using the snippet: <|code_start|>#!/usr/bin/env python3
# coding=utf-8
pytestmark = pytest.mark.asyncio
github_ci = os.getenv('GITHUB_ACTIONS') # Github set this to be the following: true instead of True
class TestBufferover(object):
@staticmethod
def domain() -> str:
return 'uber.com'
async def test_api(self):
base_url = f'https://dns.bufferover.run/dns?q={TestBufferover.domain()}'
headers = {'User-Agent': Core.get_user_agent()}
request = requests.get(base_url, headers=headers)
assert request.status_code == 200
async def test_do_search(self):
<|code_end|>
, determine the next line of code. You have imports:
from theHarvester.lib.core import *
from theHarvester.discovery import bufferoverun
import os
import requests
import pytest
and context (class names, function names, or code) available:
# Path: theHarvester/discovery/bufferoverun.py
# class SearchBufferover:
# def __init__(self, word):
# async def do_search(self):
# async def get_hostnames(self) -> set:
# async def get_ips(self) -> set:
# async def process(self, proxy=False):
. Output only the next line. | search = bufferoverun.SearchBufferover(TestBufferover.domain()) |
Continue the code snippet: <|code_start|>#!/usr/bin/env python3
# coding=utf-8
pytestmark = pytest.mark.asyncio
github_ci = os.getenv('GITHUB_ACTIONS') # Github set this to be the following: true instead of True
class TestGetLinks(object):
async def test_splitter(self):
results = [
'https://www.linkedin.com/in/don-draper-b1045618',
'https://www.linkedin.com/in/don-draper-b59210a',
'https://www.linkedin.com/in/don-draper-b5bb50b3',
'https://www.linkedin.com/in/don-draper-b83ba26',
'https://www.linkedin.com/in/don-draper-b854a51'
]
filtered_results = await splitter(results)
assert len(filtered_results) == 1
async def test_get_links(self):
<|code_end|>
. Use current file imports:
from theHarvester.discovery import linkedinsearch
from theHarvester.discovery.constants import splitter
import os
import re
import pytest
and context (classes, functions, or code) from other files:
# Path: theHarvester/discovery/linkedinsearch.py
# class SearchLinkedin:
# def __init__(self, word, limit):
# async def do_search(self):
# async def get_people(self):
# async def get_links(self):
# async def process(self, proxy=False):
#
# Path: theHarvester/discovery/constants.py
# async def splitter(links):
# """
# Method that tries to remove duplicates
# LinkedinLists pulls a lot of profiles with the same name.
# This method tries to remove duplicates from the list.
# :param links: list of links to remove duplicates from
# :return: unique-ish list
# """
# unique_list = []
# name_check = []
# for url in links:
# tail = url.split("/")[-1]
# if len(tail) == 2 or tail == "zh-cn":
# tail = url.split("/")[-2]
# name = tail.split("-")
# if len(name) > 1:
# joined_name = name[0] + name[1]
# else:
# joined_name = name[0]
# if joined_name not in name_check:
# unique_list.append(url)
# name_check.append(joined_name)
# return unique_list
. Output only the next line. | search = linkedinsearch.SearchLinkedin("facebook.com", '100') |
Using the snippet: <|code_start|>#!/usr/bin/env python3
# coding=utf-8
pytestmark = pytest.mark.asyncio
github_ci = os.getenv('GITHUB_ACTIONS') # Github set this to be the following: true instead of True
class TestGetLinks(object):
async def test_splitter(self):
results = [
'https://www.linkedin.com/in/don-draper-b1045618',
'https://www.linkedin.com/in/don-draper-b59210a',
'https://www.linkedin.com/in/don-draper-b5bb50b3',
'https://www.linkedin.com/in/don-draper-b83ba26',
'https://www.linkedin.com/in/don-draper-b854a51'
]
<|code_end|>
, determine the next line of code. You have imports:
from theHarvester.discovery import linkedinsearch
from theHarvester.discovery.constants import splitter
import os
import re
import pytest
and context (class names, function names, or code) available:
# Path: theHarvester/discovery/linkedinsearch.py
# class SearchLinkedin:
# def __init__(self, word, limit):
# async def do_search(self):
# async def get_people(self):
# async def get_links(self):
# async def process(self, proxy=False):
#
# Path: theHarvester/discovery/constants.py
# async def splitter(links):
# """
# Method that tries to remove duplicates
# LinkedinLists pulls a lot of profiles with the same name.
# This method tries to remove duplicates from the list.
# :param links: list of links to remove duplicates from
# :return: unique-ish list
# """
# unique_list = []
# name_check = []
# for url in links:
# tail = url.split("/")[-1]
# if len(tail) == 2 or tail == "zh-cn":
# tail = url.split("/")[-2]
# name = tail.split("-")
# if len(name) > 1:
# joined_name = name[0] + name[1]
# else:
# joined_name = name[0]
# if joined_name not in name_check:
# unique_list.append(url)
# name_check.append(joined_name)
# return unique_list
. Output only the next line. | filtered_results = await splitter(results) |
Given the code snippet: <|code_start|>#!/usr/bin/env python3
# coding=utf-8
pytestmark = pytest.mark.asyncio
github_ci = os.getenv('GITHUB_ACTIONS') # Github set this to be the following: true instead of True
class TestAnubis:
@staticmethod
def domain() -> str:
return 'apple.com'
async def test_api(self):
base_url = f'https://jldc.me/anubis/subdomains/{TestAnubis.domain()}'
headers = {'User-Agent': Core.get_user_agent()}
request = requests.get(base_url, headers=headers)
assert request.status_code == 200
async def test_do_search(self):
<|code_end|>
, generate the next line using the imports in this file:
import requests
import os
import pytest
from theHarvester.lib.core import *
from theHarvester.discovery import anubis
and context (functions, classes, or occasionally code) from other files:
# Path: theHarvester/discovery/anubis.py
# class SearchAnubis:
# def __init__(self, word):
# async def do_search(self):
# async def get_hostnames(self) -> Type[list]:
# async def process(self, proxy=False):
. Output only the next line. | search = anubis.SearchAnubis(word=TestAnubis.domain()) |
Given the code snippet: <|code_start|> if isinstance(val, list):
if len(val) == 0: # Make sure not indexing an empty list.
continue
val = val[0] # First value should be dict.
if isinstance(val, dict): # Sanity check.
for key in val.keys():
value = val.get(key)
if isinstance(value, str) and value != '' and 'https://' in value or 'http://' in value:
urls.add(value)
if isinstance(val, str) and val != '' and 'https://' in val or 'http://' in val:
urls.add(val)
tmp = set()
for url in urls:
if '<' in url and 'href=' in url: # Format is <href="https://www.website.com"/>
equal_index = url.index('=')
true_url = ''
for ch in url[equal_index + 1:]:
if ch == '"':
tmp.add(true_url)
break
true_url += ch
else:
if url != '':
tmp.add(url)
return tmp
except Exception as e:
print(f'Exception occurred: {e}')
return []
async def get_emails(self):
<|code_end|>
, generate the next line using the imports in this file:
from theHarvester.discovery.constants import *
from theHarvester.lib.core import *
from theHarvester.parsers import myparser
import json
and context (functions, classes, or occasionally code) from other files:
# Path: theHarvester/parsers/myparser.py
# class Parser:
# def __init__(self, results, word):
# async def genericClean(self):
# async def urlClean(self):
# async def emails(self):
# async def fileurls(self, file):
# async def hostnames(self):
# async def people_googleplus(self):
# async def hostnames_all(self):
# async def links_linkedin(self):
# async def people_linkedin(self):
# async def people_twitter(self):
# async def profiles(self):
# async def set(self):
# async def urls(self):
# async def unique(self) -> list:
. Output only the next line. | rawres = myparser.Parser(self.totalresults, self.word) |
Here is a snippet: <|code_start|>#!/usr/bin/env python3
# coding=utf-8
class TestMyParser(object):
@pytest.mark.asyncio
async def test_emails(self):
word = 'domain.com'
results = '@domain.com***a@domain***banotherdomain.com***c@domain.com***d@sub.domain.com***'
<|code_end|>
. Write the next line using the current file imports:
from theHarvester.parsers import myparser
import pytest
and context from other files:
# Path: theHarvester/parsers/myparser.py
# class Parser:
# def __init__(self, results, word):
# async def genericClean(self):
# async def urlClean(self):
# async def emails(self):
# async def fileurls(self, file):
# async def hostnames(self):
# async def people_googleplus(self):
# async def hostnames_all(self):
# async def links_linkedin(self):
# async def people_linkedin(self):
# async def people_twitter(self):
# async def profiles(self):
# async def set(self):
# async def urls(self):
# async def unique(self) -> list:
, which may include functions, classes, or code. Output only the next line. | parse = myparser.Parser(results, word) |
Predict the next line after this snippet: <|code_start|> if len(parts) == 2:
hostnames.add(parts[1])
rdns_new = rdns_new[:-1] if rdns_new[-1] == '.' else rdns_new
hostnames.add(rdns_new)
else:
rdns_new = rdns_new[:-1] if rdns_new[-1] == '.' else rdns_new
hostnames.add(rdns_new)
if 'rdns' in match.keys():
rdns = match['rdns']
rdns = rdns[:-1] if rdns[-1] == '.' else rdns
hostnames.add(rdns)
if 'portinfo' in match.keys():
# re.
temp_emails = set(await self.parse_emails(match['portinfo']['banner']))
emails.update(temp_emails)
hostnames.update(set(await self.parse_hostnames(match['portinfo']['banner'])))
iurls = {str(iurl.group(1)).replace('"', '') for iurl
in re.finditer(self.iurl_regex, match['portinfo']['banner'])
if self.word in str(iurl.group(1))}
except Exception as e:
print(f'An exception has occurred: {e}')
return hostnames, emails, ips, asns, iurls
async def process(self, proxy=False):
self.proxy = proxy
await self.do_search() # Only need to do it once.
async def parse_emails(self, content):
<|code_end|>
using the current file's imports:
from theHarvester.discovery.constants import *
from theHarvester.lib.core import *
from theHarvester.parsers import myparser
import asyncio
import re
and any relevant context from other files:
# Path: theHarvester/parsers/myparser.py
# class Parser:
# def __init__(self, results, word):
# async def genericClean(self):
# async def urlClean(self):
# async def emails(self):
# async def fileurls(self, file):
# async def hostnames(self):
# async def people_googleplus(self):
# async def hostnames_all(self):
# async def links_linkedin(self):
# async def people_linkedin(self):
# async def people_twitter(self):
# async def profiles(self):
# async def set(self):
# async def urls(self):
# async def unique(self) -> list:
. Output only the next line. | rawres = myparser.Parser(content, self.word) |
Given snippet: <|code_start|> for response in responses:
self.total_results += response
async def do_search_api(self):
url = 'https://api.cognitive.microsoft.com/bing/v7.0/search?'
params = {
'q': self.word,
'count': str(self.limit),
'offset': '0',
'mkt': 'en-us',
'safesearch': 'Off'
}
headers = {'User-Agent': Core.get_user_agent(), 'Ocp-Apim-Subscription-Key': self.bingApi}
self.results = await AsyncFetcher.fetch_all([url], headers=headers, params=params, proxy=self.proxy)
self.total_results += self.results
async def do_search_vhost(self):
headers = {
'Host': self.hostname,
'Cookie': 'mkt=en-US;ui=en-US;SRCHHPGUSR=NEWWND=0&ADLT=DEMOTE&NRSLT=50',
'Accept-Language': 'en-us,en',
'User-agent': Core.get_user_agent()
}
base_url = f'http://{self.server}/search?q=ip:{self.word}&go=&count=50&FORM=QBHL&qs=n&first=xx'
urls = [base_url.replace("xx", str(num)) for num in range(0, self.limit, 50) if num <= self.limit]
responses = await AsyncFetcher.fetch_all(urls, headers=headers, proxy=self.proxy)
for response in responses:
self.total_results += response
async def get_emails(self):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from theHarvester.discovery.constants import *
from theHarvester.lib.core import *
from theHarvester.parsers import myparser
and context:
# Path: theHarvester/parsers/myparser.py
# class Parser:
# def __init__(self, results, word):
# async def genericClean(self):
# async def urlClean(self):
# async def emails(self):
# async def fileurls(self, file):
# async def hostnames(self):
# async def people_googleplus(self):
# async def hostnames_all(self):
# async def links_linkedin(self):
# async def people_linkedin(self):
# async def people_twitter(self):
# async def profiles(self):
# async def set(self):
# async def urls(self):
# async def unique(self) -> list:
which might include code, classes, or functions. Output only the next line. | rawres = myparser.Parser(self.total_results, self.word) |
Continue the code snippet: <|code_start|>
class SearchBaidu:
def __init__(self, word, limit):
self.word = word
self.total_results = ""
self.server = 'www.baidu.com'
self.hostname = 'www.baidu.com'
self.limit = limit
self.proxy = False
async def do_search(self):
headers = {
'Host': self.hostname,
'User-agent': Core.get_user_agent()
}
base_url = f'https://{self.server}/s?wd=%40{self.word}&pn=xx&oq={self.word}'
urls = [base_url.replace("xx", str(num)) for num in range(0, self.limit, 10) if num <= self.limit]
responses = await AsyncFetcher.fetch_all(urls, headers=headers, proxy=self.proxy)
for response in responses:
self.total_results += response
async def process(self, proxy=False):
self.proxy = proxy
await self.do_search()
async def get_emails(self):
<|code_end|>
. Use current file imports:
from theHarvester.lib.core import *
from theHarvester.parsers import myparser
and context (classes, functions, or code) from other files:
# Path: theHarvester/parsers/myparser.py
# class Parser:
# def __init__(self, results, word):
# async def genericClean(self):
# async def urlClean(self):
# async def emails(self):
# async def fileurls(self, file):
# async def hostnames(self):
# async def people_googleplus(self):
# async def hostnames_all(self):
# async def links_linkedin(self):
# async def people_linkedin(self):
# async def people_twitter(self):
# async def profiles(self):
# async def set(self):
# async def urls(self):
# async def unique(self) -> list:
. Output only the next line. | rawres = myparser.Parser(self.total_results, self.word) |
Based on the snippet: <|code_start|>
for response in responses:
try:
json_response = json.loads(response)
except JSONDecodeError:
# sometimes error 502 from server
continue
try:
response_items = json_response['data']['result']['items']
except KeyError:
if json_response.get("status", None) \
and json_response.get("error", None) == 24:
# https://www.qwant.com/anti_robot
print("Rate limit reached - IP Blocked until captcha is solved")
break
continue
for response_item in response_items:
desc = response_item.get('desc', '')
"""
response_item[0]['desc'] = "end of previous description."
response_item[1]['desc'] = "john.doo@company.com start the next description"
total_results = "end of first description.john.doo@company.com"
get_emails() = "description.john.doo@company.com"
"""
self.total_results += " "
self.total_results += desc
async def get_emails(self) -> set:
<|code_end|>
, predict the immediate next line with the help of imports:
import json
import math
from json.decoder import JSONDecodeError
from theHarvester.lib.core import *
from theHarvester.parsers import myparser
and context (classes, functions, sometimes code) from other files:
# Path: theHarvester/parsers/myparser.py
# class Parser:
# def __init__(self, results, word):
# async def genericClean(self):
# async def urlClean(self):
# async def emails(self):
# async def fileurls(self, file):
# async def hostnames(self):
# async def people_googleplus(self):
# async def hostnames_all(self):
# async def links_linkedin(self):
# async def people_linkedin(self):
# async def people_twitter(self):
# async def profiles(self):
# async def set(self):
# async def urls(self):
# async def unique(self) -> list:
. Output only the next line. | parser = myparser.Parser(self.total_results, self.word) |
Next line prediction: <|code_start|> csrftoken = ''
if self.proxy is False:
async with session.get(url, headers=headers) as resp:
cookies = str(resp.cookies)
cookies = cookies.split('csrftoken=')
csrftoken += cookies[1][:cookies[1].find(';')]
else:
async with session.get(url, headers=headers, proxy=self.proxy) as resp:
cookies = str(resp.cookies)
cookies = cookies.split('csrftoken=')
csrftoken += cookies[1][:cookies[1].find(';')]
await asyncio.sleep(2)
# extract csrftoken from cookies
data = {
'Cookie': f'csfrtoken={csrftoken}', 'csrfmiddlewaretoken': csrftoken,
'targetip': self.word, 'user': 'free'}
headers['Referer'] = url
if self.proxy is False:
async with session.post(url, headers=headers, data=data) as resp:
self.results = await resp.text()
else:
async with session.post(url, headers=headers, data=data, proxy=self.proxy) as resp:
self.results = await resp.text()
await session.close()
except Exception as e:
print(f'An exception occurred: {e}')
self.totalresults += self.results
async def get_hostnames(self):
<|code_end|>
. Use current file imports:
(from theHarvester.lib.core import *
from theHarvester.parsers import myparser
import aiohttp
import asyncio)
and context including class names, function names, or small code snippets from other files:
# Path: theHarvester/parsers/myparser.py
# class Parser:
# def __init__(self, results, word):
# async def genericClean(self):
# async def urlClean(self):
# async def emails(self):
# async def fileurls(self, file):
# async def hostnames(self):
# async def people_googleplus(self):
# async def hostnames_all(self):
# async def links_linkedin(self):
# async def people_linkedin(self):
# async def people_twitter(self):
# async def profiles(self):
# async def set(self):
# async def urls(self):
# async def unique(self) -> list:
. Output only the next line. | rawres = myparser.Parser(self.totalresults, self.word) |
Given the code snippet: <|code_start|> data = {
"term": self.word,
"buckets": [],
"lookuplevel": 0,
"maxresults": self.limit,
"timeout": 5,
"datefrom": "",
"dateto": "",
"sort": 2,
"media": 0,
"terminate": [],
"target": 0
}
total_resp = requests.post(f'{self.database}/phonebook/search', headers=headers, json=data)
phonebook_id = json.loads(total_resp.text)['id']
await asyncio.sleep(2)
# Fetch results from phonebook based on ID
resp = await AsyncFetcher.fetch_all(
[f'{self.database}/phonebook/search/result?id={phonebook_id}&limit={self.limit}&offset={self.offset}'],
headers=headers, json=True, proxy=self.proxy)
resp = resp[0]
self.results = resp
except Exception as e:
print(f'An exception has occurred in Intelx: {e}')
async def process(self, proxy=False):
self.proxy = proxy
await self.do_search()
<|code_end|>
, generate the next line using the imports in this file:
from theHarvester.discovery.constants import *
from theHarvester.lib.core import *
from theHarvester.parsers import intelxparser
import asyncio
import json
import requests
and context (functions, classes, or occasionally code) from other files:
# Path: theHarvester/parsers/intelxparser.py
# class Parser:
# def __init__(self):
# async def parse_dictionaries(self, results: dict) -> tuple:
. Output only the next line. | intelx_parser = intelxparser.Parser() |
Given the code snippet: <|code_start|>
class SearchVirustotal:
def __init__(self, word):
self.word = word
self.results = ""
self.totalresults = ""
self.quantity = '100'
self.counter = 0
self.proxy = False
async def do_search(self):
base_url = f'https://www.virustotal.com/ui/domains/{self.word}/subdomains?relationships=resolutions&cursor=STMwCi4%3D&limit=40'
headers = {'User-Agent': Core.get_user_agent()}
responses = await AsyncFetcher.fetch_all([base_url], headers=headers, proxy=self.proxy)
self.results = responses[0]
self.totalresults += self.results
async def get_hostnames(self):
<|code_end|>
, generate the next line using the imports in this file:
from theHarvester.lib.core import *
from theHarvester.parsers import myparser
import re
and context (functions, classes, or occasionally code) from other files:
# Path: theHarvester/parsers/myparser.py
# class Parser:
# def __init__(self, results, word):
# async def genericClean(self):
# async def urlClean(self):
# async def emails(self):
# async def fileurls(self, file):
# async def hostnames(self):
# async def people_googleplus(self):
# async def hostnames_all(self):
# async def links_linkedin(self):
# async def people_linkedin(self):
# async def people_twitter(self):
# async def profiles(self):
# async def set(self):
# async def urls(self):
# async def unique(self) -> list:
. Output only the next line. | rawres = myparser.Parser(self.results, self.word) |
Predict the next line for this snippet: <|code_start|> self.quantity = '100'
self.limit = 300
self.trello_urls = []
self.hostnames = []
self.counter = 0
self.proxy = False
async def do_search(self):
base_url = f'https://{self.server}/search?num=300&start=xx&hl=en&q=site%3Atrello.com%20{self.word}'
urls = [base_url.replace("xx", str(num)) for num in range(0, self.limit, 20) if num <= self.limit]
# limit is 20 as that is the most results google will show per num
headers = {'User-Agent': googleUA}
for url in urls:
try:
resp = await AsyncFetcher.fetch_all([url], headers=headers, proxy=self.proxy)
self.results = resp[0]
if await search(self.results):
try:
self.results = await google_workaround(base_url)
if isinstance(self.results, bool):
print('Google is blocking your ip and the workaround, returning')
return
except Exception as e:
print(e)
self.totalresults += self.results
await asyncio.sleep(get_delay() - .5)
except Exception as e:
print(f'An exception has occurred in trello: {e}')
async def get_emails(self):
<|code_end|>
with the help of current file imports:
from theHarvester.discovery.constants import *
from theHarvester.parsers import myparser
import random
import asyncio
and context from other files:
# Path: theHarvester/parsers/myparser.py
# class Parser:
# def __init__(self, results, word):
# async def genericClean(self):
# async def urlClean(self):
# async def emails(self):
# async def fileurls(self, file):
# async def hostnames(self):
# async def people_googleplus(self):
# async def hostnames_all(self):
# async def links_linkedin(self):
# async def people_linkedin(self):
# async def people_twitter(self):
# async def profiles(self):
# async def set(self):
# async def urls(self):
# async def unique(self) -> list:
, which may contain function names, class names, or code. Output only the next line. | rawres = myparser.Parser(self.totalresults, self.word) |
Given the code snippet: <|code_start|>#!/usr/bin/env python3
# coding=utf-8
pytestmark = pytest.mark.asyncio
github_ci = os.getenv('GITHUB_ACTIONS') # Github set this to be the following: true instead of True
class TestCertspotter(object):
@staticmethod
def domain() -> str:
return 'metasploit.com'
async def test_api(self):
base_url = f'https://api.certspotter.com/v1/issuances?domain={TestCertspotter.domain()}&expand=dns_names'
headers = {'User-Agent': Core.get_user_agent()}
request = requests.get(base_url, headers=headers)
assert request.status_code == 200
async def test_search(self):
<|code_end|>
, generate the next line using the imports in this file:
from theHarvester.lib.core import *
from theHarvester.discovery import certspottersearch
import os
import requests
import pytest
and context (functions, classes, or occasionally code) from other files:
# Path: theHarvester/discovery/certspottersearch.py
# class SearchCertspoter:
# def __init__(self, word):
# async def do_search(self) -> None:
# async def get_hostnames(self) -> set:
# async def process(self, proxy=False):
. Output only the next line. | search = certspottersearch.SearchCertspoter(TestCertspotter.domain()) |
Next line prediction: <|code_start|>#!/usr/bin/env python3
# coding=utf-8
pytestmark = pytest.mark.asyncio
github_ci = os.getenv('GITHUB_ACTIONS') # Github set this to be the following: true instead of True
class TestOtx(object):
@staticmethod
def domain() -> str:
return 'metasploit.com'
async def test_api(self):
base_url = f'https://otx.alienvault.com/api/v1/indicators/domain/{TestOtx.domain()}/passive_dns'
headers = {'User-Agent': Core.get_user_agent()}
request = requests.get(base_url, headers=headers)
assert request.status_code == 200
async def test_search(self):
<|code_end|>
. Use current file imports:
(from theHarvester.lib.core import *
from theHarvester.discovery import otxsearch
import os
import requests
import pytest)
and context including class names, function names, or small code snippets from other files:
# Path: theHarvester/discovery/otxsearch.py
# class SearchOtx:
# def __init__(self, word):
# async def do_search(self):
# async def get_hostnames(self) -> set:
# async def get_ips(self) -> set:
# async def process(self, proxy=False):
. Output only the next line. | search = otxsearch.SearchOtx(TestOtx.domain()) |
Based on the snippet: <|code_start|>#!/usr/bin/env python3
# coding=utf-8
pytestmark = pytest.mark.asyncio
github_ci = os.getenv('GITHUB_ACTIONS') # Github set this to be the following: true instead of True
class TestOmnisint(object):
@staticmethod
def domain() -> str:
return 'uber.com'
@pytest.mark.skipif(github_ci == 'true', reason='Skipping on Github CI due to unstable status code from site')
async def test_api(self):
base_url = f'https://sonar.omnisint.io/all/{TestOmnisint.domain()}'
headers = {'User-Agent': Core.get_user_agent()}
request = requests.get(base_url, headers=headers)
assert request.status_code == 200
async def test_search(self):
<|code_end|>
, predict the immediate next line with the help of imports:
from theHarvester.lib.core import *
from theHarvester.discovery import omnisint
import os
import requests
import pytest
and context (classes, functions, sometimes code) from other files:
# Path: theHarvester/discovery/omnisint.py
# class SearchOmnisint:
# def __init__(self, word):
# async def do_search(self):
# async def get_hostnames(self) -> set:
# async def get_ips(self) -> set:
# async def process(self, proxy=False):
. Output only the next line. | search = omnisint.SearchOmnisint(TestOmnisint.domain()) |
Predict the next line for this snippet: <|code_start|>#!/usr/bin/env python3
# coding=utf-8
pytestmark = pytest.mark.asyncio
github_ci = os.getenv('GITHUB_ACTIONS') # Github set this to be the following: true instead of True
class TestThreatminer(object):
@staticmethod
def domain() -> str:
return 'target.com'
async def test_api(self):
base_url = f'https://api.threatminer.org/v2/domain.php?q={TestThreatminer.domain()}&rt=5'
headers = {'User-Agent': Core.get_user_agent()}
request = requests.get(base_url, headers=headers)
assert request.status_code == 200
async def test_search(self):
<|code_end|>
with the help of current file imports:
import requests
import os
import pytest
from theHarvester.lib.core import *
from theHarvester.discovery import threatminer
and context from other files:
# Path: theHarvester/discovery/threatminer.py
# class SearchThreatminer:
# def __init__(self, word):
# async def do_search(self):
# async def get_hostnames(self) -> Type[list]:
# async def get_ips(self) -> Type[list]:
# async def process(self, proxy=False):
, which may contain function names, class names, or code. Output only the next line. | search = threatminer.SearchThreatminer(TestThreatminer.domain()) |
Given snippet: <|code_start|> self.word = word.replace(' ', '%20')
self.results = ""
self.totalresults = ""
self.server = 'www.google.com'
self.quantity = '100'
self.limit = int(limit)
self.counter = 0
self.proxy = False
async def do_search(self):
urly = 'http://' + self.server + '/search?num=100&start=' + str(self.counter) + '&hl=en&meta=&q=site%3Alinkedin.com/in%20' + self.word
try:
headers = {'User-Agent': Core.get_user_agent()}
resp = await AsyncFetcher.fetch_all([urly], headers=headers, proxy=self.proxy)
self.results = resp[0]
if await search(self.results):
try:
self.results = await google_workaround(urly)
if isinstance(self.results, bool):
print('Google is blocking your ip and the workaround, returning')
return
except Exception:
# google blocked, no useful result
return
except Exception as e:
print(e)
await asyncio.sleep(get_delay())
self.totalresults += self.results
async def get_people(self):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from theHarvester.discovery.constants import *
from theHarvester.lib.core import *
from theHarvester.parsers import myparser
import asyncio
and context:
# Path: theHarvester/parsers/myparser.py
# class Parser:
# def __init__(self, results, word):
# async def genericClean(self):
# async def urlClean(self):
# async def emails(self):
# async def fileurls(self, file):
# async def hostnames(self):
# async def people_googleplus(self):
# async def hostnames_all(self):
# async def links_linkedin(self):
# async def people_linkedin(self):
# async def people_twitter(self):
# async def profiles(self):
# async def set(self):
# async def urls(self):
# async def unique(self) -> list:
which might include code, classes, or functions. Output only the next line. | rawres = myparser.Parser(self.totalresults, self.word) |
Here is a snippet: <|code_start|>#!/usr/bin/env python3
# coding=utf-8
pytestmark = pytest.mark.asyncio
github_ci = os.getenv('GITHUB_ACTIONS') # Github set this to be the following: true instead of True
class TestN45ht(object):
@staticmethod
def domain() -> str:
return 'uber.com'
async def test_api(self):
base_url = f'https://api.n45ht.or.id/v1/subdomain-enumeration?domain={TestN45ht.domain()}'
headers = {'User-Agent': Core.get_user_agent()}
request = requests.get(base_url, headers=headers)
assert request.status_code == 200
async def test_do_search(self):
<|code_end|>
. Write the next line using the current file imports:
from theHarvester.lib.core import *
from theHarvester.discovery import n45htsearch
import os
import requests
import pytest
and context from other files:
# Path: theHarvester/discovery/n45htsearch.py
# class SearchN45ht:
# def __init__(self, word):
# async def do_search(self):
# async def get_hostnames(self) -> set:
# async def process(self, proxy=False):
, which may include functions, classes, or code. Output only the next line. | search = n45htsearch.SearchN45ht(TestN45ht.domain()) |
Predict the next line for this snippet: <|code_start|> self.totalresults = ""
self.server = 'www.google.com'
self.quantity = '100'
self.limit = int(limit)
self.counter = 0
self.proxy = False
async def do_search(self):
base_url = f'https://{self.server}/search?num=100&start=xx&hl=en&meta=&q=site%3Atwitter.com%20intitle%3A%22on+Twitter%22%20{self.word}'
headers = {'User-Agent': Core.get_user_agent()}
try:
urls = [base_url.replace("xx", str(num)) for num in range(0, self.limit, 10) if num <= self.limit]
for url in urls:
response = await AsyncFetcher.fetch_all([url], headers=headers, proxy=self.proxy)
self.results = response[0]
if await search(self.results):
try:
self.results = await google_workaround(url)
if isinstance(self.results, bool):
print('Google is blocking your ip and the workaround, returning')
return
except Exception:
# google blocked, no useful result
return
self.totalresults += self.results
except Exception as error:
print(error)
async def get_people(self, proxy=False):
self.proxy = proxy
<|code_end|>
with the help of current file imports:
from theHarvester.discovery.constants import *
from theHarvester.lib.core import *
from theHarvester.parsers import myparser
import re
and context from other files:
# Path: theHarvester/parsers/myparser.py
# class Parser:
# def __init__(self, results, word):
# async def genericClean(self):
# async def urlClean(self):
# async def emails(self):
# async def fileurls(self, file):
# async def hostnames(self):
# async def people_googleplus(self):
# async def hostnames_all(self):
# async def links_linkedin(self):
# async def people_linkedin(self):
# async def people_twitter(self):
# async def profiles(self):
# async def set(self):
# async def urls(self):
# async def unique(self) -> list:
, which may contain function names, class names, or code. Output only the next line. | rawres = myparser.Parser(self.totalresults, self.word) |
Continue the code snippet: <|code_start|>
#####################################################################
# DNS FORCE
#####################################################################
class DnsForce:
def __init__(self, domain, dnsserver, verbose=False):
self.domain = domain
self.subdo = False
self.verbose = verbose
# self.dnsserver = [dnsserver] if isinstance(dnsserver, str) else dnsserver
self.dnsserver = list(map(str, dnsserver.split(','))) if isinstance(dnsserver, str) else dnsserver
try:
with open('/etc/theHarvester/wordlists/dns-names.txt', 'r') as file:
self.list = file.readlines()
except FileNotFoundError:
try:
with open('/usr/local/etc/theHarvester/wordlists/dns-names.txt', 'r') as file:
self.list = file.readlines()
except FileNotFoundError:
with open('wordlists/dns-names.txt', 'r') as file:
self.list = file.readlines()
self.domain = domain.replace('www.', '')
self.list = [f'{word.strip()}.{self.domain}' for word in self.list]
async def run(self):
print(f'Starting DNS brute forcing with {len(self.list)} words')
<|code_end|>
. Use current file imports:
import re
import sys
from aiodns import DNSResolver
from ipaddress import IPv4Network
from typing import Callable, List, Optional
from theHarvester.lib import hostchecker
and context (classes, functions, or code) from other files:
# Path: theHarvester/lib/hostchecker.py
# class Checker:
# def __init__(self, hosts: list, nameserver=False):
# async def query(host, resolver) -> Tuple[str, Any]:
# async def query_all(self, resolver) -> list:
# async def check(self):
. Output only the next line. | checker = hostchecker.Checker( |
Given snippet: <|code_start|>#!/usr/bin/env python3
# coding=utf-8
pytestmark = pytest.mark.asyncio
github_ci = os.getenv('GITHUB_ACTIONS') # Github set this to be the following: true instead of True
class TestSearchQwant(object):
@staticmethod
def domain() -> str:
return 'example.com'
def test_get_start_offset_return_0(self):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from theHarvester.discovery import qwantsearch
import os
import pytest
and context:
# Path: theHarvester/discovery/qwantsearch.py
# class SearchQwant:
# def __init__(self, word, start, limit):
# def get_start_offset(self) -> int:
# async def do_search(self) -> None:
# async def get_emails(self) -> set:
# async def get_hostnames(self) -> list:
# async def process(self, proxy=False) -> None:
which might include code, classes, or functions. Output only the next line. | search = qwantsearch.SearchQwant(TestSearchQwant.domain(), 0, 200) |
Predict the next line after this snippet: <|code_start|>#!/usr/bin/env python3
# coding=utf-8
pytestmark = pytest.mark.asyncio
github_ci = os.getenv('GITHUB_ACTIONS') # Github set this to be the following: true instead of True
class TestSublist3r(object):
@staticmethod
def domain() -> str:
return 'target.com'
async def test_api(self):
base_url = f'https://api.sublist3r.com/search.php?domain={TestSublist3r.domain()}'
headers = {'User-Agent': Core.get_user_agent()}
request = requests.get(base_url, headers=headers)
assert request.status_code == 200
async def test_do_search(self):
<|code_end|>
using the current file's imports:
import requests
import os
import pytest
from theHarvester.lib.core import *
from theHarvester.discovery import sublist3r
and any relevant context from other files:
# Path: theHarvester/discovery/sublist3r.py
# class SearchSublist3r:
# def __init__(self, word):
# async def do_search(self):
# async def get_hostnames(self) -> Type[list]:
# async def process(self, proxy=False):
. Output only the next line. | search = sublist3r.SearchSublist3r(TestSublist3r.domain()) |
Next line prediction: <|code_start|> if result.next_page is not None:
return result.next_page
else:
return result.last_page
async def process(self, proxy=False):
self.proxy = proxy
try:
while self.counter <= self.limit and self.page is not None:
api_response = await self.do_search(self.page)
result = await self.handle_response(api_response)
if isinstance(result, SuccessResult):
print(f'\tSearching {self.counter} results.')
for fragment in result.fragments:
self.total_results += fragment
self.counter = self.counter + 1
self.page = await self.next_page_or_end(result)
await asyncio.sleep(get_delay())
elif isinstance(result, RetryResult):
sleepy_time = get_delay() + result.time
print(f'\tRetrying page in {sleepy_time} seconds...')
await asyncio.sleep(sleepy_time)
elif isinstance(result, ErrorResult):
raise Exception(f"\tException occurred: status_code: {result.status_code} reason: {result.body}")
else:
raise Exception("\tUnknown exception occurred")
except Exception as e:
print(f'An exception has occurred: {e}')
async def get_emails(self):
<|code_end|>
. Use current file imports:
(from theHarvester.discovery.constants import *
from theHarvester.lib.core import *
from theHarvester.parsers import myparser
from typing import List, Dict, Any, Optional, NamedTuple, Tuple
import asyncio
import aiohttp
import urllib.parse as urlparse
import random)
and context including class names, function names, or small code snippets from other files:
# Path: theHarvester/parsers/myparser.py
# class Parser:
# def __init__(self, results, word):
# async def genericClean(self):
# async def urlClean(self):
# async def emails(self):
# async def fileurls(self, file):
# async def hostnames(self):
# async def people_googleplus(self):
# async def hostnames_all(self):
# async def links_linkedin(self):
# async def people_linkedin(self):
# async def people_twitter(self):
# async def profiles(self):
# async def set(self):
# async def urls(self):
# async def unique(self) -> list:
. Output only the next line. | rawres = myparser.Parser(self.total_results, self.word) |
Given the code snippet: <|code_start|> self.proxy = False
async def authenticate(self) -> None:
# Method to authenticate API key before sending requests.
headers = {'APIKEY': self.key}
url = f'{self.api}ping'
auth_responses = await AsyncFetcher.fetch_all([url], headers=headers, proxy=self.proxy)
auth_responses = auth_responses[0]
if 'False' in auth_responses or 'Invalid authentication' in auth_responses:
print('\tKey could not be authenticated exiting program.')
await asyncio.sleep(2)
async def do_search(self) -> None:
# https://api.securitytrails.com/v1/domain/domain.com
url = f'{self.api}domain/{self.word}'
headers = {'APIKEY': self.key}
response = await AsyncFetcher.fetch_all([url], headers=headers, proxy=self.proxy)
await asyncio.sleep(2) # Not random delay because 2 seconds is required due to rate limit.
self.results = response[0]
self.totalresults += self.results
url += '/subdomains' # Get subdomains now.
subdomain_response = await AsyncFetcher.fetch_all([url], headers=headers, proxy=self.proxy)
await asyncio.sleep(2)
self.results = subdomain_response[0]
self.totalresults += self.results
async def process(self, proxy=False) -> None:
self.proxy = proxy
await self.authenticate()
await self.do_search()
<|code_end|>
, generate the next line using the imports in this file:
from theHarvester.discovery.constants import *
from theHarvester.lib.core import *
from theHarvester.parsers import securitytrailsparser
import asyncio
and context (functions, classes, or occasionally code) from other files:
# Path: theHarvester/parsers/securitytrailsparser.py
# class Parser:
# def __init__(self, word, text):
# async def parse_text(self) -> Union[List, Tuple]:
. Output only the next line. | parser = securitytrailsparser.Parser(word=self.word, text=self.totalresults) |
Given the following code snippet before the placeholder: <|code_start|> return
except Exception as e:
print(e)
# google blocked, no useful result
return
await asyncio.sleep(get_delay())
self.totalresults += self.results
async def do_search_profiles(self):
urly = 'http://' + self.server + '/search?num=' + self.quantity + '&start=' + str(
self.counter) + '&hl=en&meta=&q=site:www.google.com%20intitle:\"Google%20Profile\"%20\"Companies%20I%27ve%20worked%20for\"%20\"at%20' + self.word + '\"'
try:
headers = {'User-Agent': googleUA}
resp = await AsyncFetcher.fetch_all([urly], headers=headers, proxy=self.proxy)
except Exception as e:
print(e)
self.results = resp[0]
if await search(self.results):
try:
self.results = await google_workaround(urly)
if isinstance(self.results, bool):
print('Google is blocking your ip and the workaround, returning')
return
except Exception:
# google blocked, no useful result
return
await asyncio.sleep(get_delay())
self.totalresults += self.results
async def get_emails(self):
<|code_end|>
, predict the next line using imports from the current file:
from theHarvester.discovery.constants import *
from theHarvester.parsers import myparser
import asyncio
and context including class names, function names, and sometimes code from other files:
# Path: theHarvester/parsers/myparser.py
# class Parser:
# def __init__(self, results, word):
# async def genericClean(self):
# async def urlClean(self):
# async def emails(self):
# async def fileurls(self, file):
# async def hostnames(self):
# async def people_googleplus(self):
# async def hostnames_all(self):
# async def links_linkedin(self):
# async def people_linkedin(self):
# async def people_twitter(self):
# async def profiles(self):
# async def set(self):
# async def urls(self):
# async def unique(self) -> list:
. Output only the next line. | rawres = myparser.Parser(self.totalresults, self.word) |
Continue the code snippet: <|code_start|> text-align: center;
display: block;
}
</style>
</head>
<body>
<br/>
<a href="https://github.com/laramies/theHarvester" target="_blank">
<span class="img-container">
<img src="https://raw.githubusercontent.com/laramies/theHarvester/master/theHarvester-logo.png" alt="theHarvester logo"/>
</span>
</a>
</body>
</html>
"""
return html
@app.get('/nicebot')
async def bot():
# nice bot
string = {'bot': 'These are not the droids you are looking for'}
return string
@app.get('/sources', response_class=UJSONResponse)
@limiter.limit('5/minute')
async def getsources(request: Request):
# Endpoint for user to query for available sources theHarvester supports
# Rate limit of 5 requests per minute
<|code_end|>
. Use current file imports:
import argparse
import os
from typing import List
from fastapi import FastAPI, Header, Query, Request
from fastapi.responses import HTMLResponse, UJSONResponse
from slowapi import Limiter, _rate_limit_exceeded_handler
from slowapi.errors import RateLimitExceeded
from slowapi.util import get_remote_address
from starlette.responses import RedirectResponse
from starlette.staticfiles import StaticFiles
from theHarvester import __main__
and context (classes, functions, or code) from other files:
# Path: theHarvester/__main__.py
# async def start(rest_args=None):
# async def store(search_engine: Any, source: str, process_param: Any = None, store_host: bool = False,
# store_emails: bool = False, store_ip: bool = False, store_people: bool = False,
# store_links: bool = False, store_results: bool = False,
# store_interestingurls: bool = False, store_asns: bool = False) -> None:
# async def worker(queue):
# async def handler(lst):
# async def entry_point():
. Output only the next line. | sources = __main__.Core.get_supportedengines() |
Given the following code snippet before the placeholder: <|code_start|>#!/usr/bin/env python3
# Note: This script runs theHarvester
if sys.version_info.major < 3 or sys.version_info.minor < 7:
print('\033[93m[!] Make sure you have Python 3.7+ installed, quitting.\n\n \033[0m')
sys.exit(1)
if __name__ == '__main__':
platform = sys.platform
if platform == 'win32':
# Required or things will break if trying to take screenshots
multiprocessing.freeze_support()
asyncio.DefaultEventLoopPolicy = asyncio.WindowsSelectorEventLoopPolicy
else:
uvloop.install()
if "linux" in platform:
# As we are not using Windows we can change the spawn method to fork for greater performance
aiomultiprocess.set_context("fork")
<|code_end|>
, predict the next line using imports from the current file:
import sys
import asyncio
import multiprocessing
import uvloop
import aiomultiprocess
from theHarvester import __main__
and context including class names, function names, and sometimes code from other files:
# Path: theHarvester/__main__.py
# async def start(rest_args=None):
# async def store(search_engine: Any, source: str, process_param: Any = None, store_host: bool = False,
# store_emails: bool = False, store_ip: bool = False, store_people: bool = False,
# store_links: bool = False, store_results: bool = False,
# store_interestingurls: bool = False, store_asns: bool = False) -> None:
# async def worker(queue):
# async def handler(lst):
# async def entry_point():
. Output only the next line. | asyncio.run(__main__.entry_point()) |
Based on the snippet: <|code_start|>
class SearchYahoo:
def __init__(self, word, limit):
self.word = word
self.total_results = ""
self.server = 'search.yahoo.com'
self.limit = limit
self.proxy = False
async def do_search(self):
base_url = f'https://{self.server}/search?p=%40{self.word}&b=xx&pz=10'
headers = {
'Host': self.server,
'User-agent': Core.get_user_agent()
}
urls = [base_url.replace("xx", str(num)) for num in range(0, self.limit, 10) if num <= self.limit]
responses = await AsyncFetcher.fetch_all(urls, headers=headers, proxy=self.proxy)
for response in responses:
self.total_results += response
async def process(self):
await self.do_search()
async def get_emails(self):
<|code_end|>
, predict the immediate next line with the help of imports:
from theHarvester.lib.core import *
from theHarvester.parsers import myparser
and context (classes, functions, sometimes code) from other files:
# Path: theHarvester/parsers/myparser.py
# class Parser:
# def __init__(self, results, word):
# async def genericClean(self):
# async def urlClean(self):
# async def emails(self):
# async def fileurls(self, file):
# async def hostnames(self):
# async def people_googleplus(self):
# async def hostnames_all(self):
# async def links_linkedin(self):
# async def people_linkedin(self):
# async def people_twitter(self):
# async def profiles(self):
# async def set(self):
# async def urls(self):
# async def unique(self) -> list:
. Output only the next line. | rawres = myparser.Parser(self.total_results, self.word) |
Here is a snippet: <|code_start|>
class UtilsIPTestsV4(unittest.TestCase):
def setUp(self):
print
def test_aton_with_valid_ip(self):
<|code_end|>
. Write the next line using the current file imports:
from mock import patch
from luna.utils import ip
import unittest
and context from other files:
# Path: luna/utils/ip.py
# def ntoa(num_ip, ver=4):
# def aton(ip, ver=4):
# def reltoa(num_net, rel_ip, ver):
# def atorel(ip, num_net, prefix, ver=4):
# def get_num_subnet(ip, prefix, ver=4):
# def ip_in_net(ip, num_net, prefix, ver=4):
# def guess_ns_hostname():
# def get_ip_version(ip):
# def ipv6_unwrap(ip):
, which may include functions, classes, or code. Output only the next line. | self.assertEqual(ip.aton('10.0.0.1'), 167772161) |
Given snippet: <|code_start|>
class UtilsFreelistTests(unittest.TestCase):
def setUp(self):
print
self.flist0 = []
self.flist1 = [{'start': 1, 'end': 254}]
self.flist2 = [{'start': 10, 'end': 18}, {'start': 20, 'end': 254}]
self.flist3 = [{'start': 254, 'end': 254}]
self.flist4 = [{'start': 10, 'end': 10}, {'start': 12, 'end': 254}]
def test_next_free(self):
# Simple freelist
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import mock
import unittest
import os
from luna.utils import freelist
and context:
# Path: luna/utils/freelist.py
# def next_free(flist):
# def unfree_range(flist, start, end=None):
# def free_range(flist, start, end=None):
# def set_upper_limit(flist, end, prev_end):
# def get_nonfree(flist, limit=None):
which might include code, classes, or functions. Output only the next line. | flist, next_free = freelist.next_free(self.flist1) |
Predict the next line after this snippet: <|code_start|>#!/usr/bin/env python
'''
Written by Dmitry Chirikov <dmitry@chirikov.ru>
This file is part of Luna, cluster provisioning tool
https://github.com/dchirikov/luna
This file is part of Luna.
Luna 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.
Luna 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 Luna. If not, see <http://www.gnu.org/licenses/>.
'''
log = logging.getLogger(__file__)
log.info('Luna migration script to db v1.2')
try:
<|code_end|>
using the current file's imports:
import logging
import pymongo
import uuid
from luna.utils.helpers import get_con_options
from luna.config import db_name
from luna import Group
from luna import Cluster
and any relevant context from other files:
# Path: luna/utils/helpers.py
# def get_con_options():
# con_options = {'host': 'mongodb://'}
# conf_defaults = {'server': 'localhost', 'replicaset': None,
# 'authdb': None, 'user': None, 'password': None,
# 'SSL': None, 'CAcert': None}
# conf = ConfigParser.ConfigParser(conf_defaults)
#
# if not conf.read("/etc/luna.conf"):
# return {'host': conf_defaults['server']}
#
# replicaset = conf.get("MongoDB", "replicaset")
# server = conf.get("MongoDB", "server")
# authdb = conf.get("MongoDB", "authdb")
# user = conf.get("MongoDB", "user")
# password = urllib.quote_plus(conf.get("MongoDB", "password"))
# need_ssl = conf.get("MongoDB", "SSL")
# ca_cert = conf.get("MongoDB", "CAcert")
#
# if user and password:
# con_options['host'] += user + ':' + password + '@'
#
# con_options['host'] += server
#
# if authdb:
# con_options['host'] += '/' + authdb
#
# if replicaset:
# con_options['replicaSet'] = replicaset
#
# if need_ssl in ['Enabled', 'enabled']:
# con_options['ssl'] = True
# if ca_cert:
# con_options['ssl_ca_certs'] = ca_cert
# con_options['ssl_cert_reqs'] = ssl.CERT_REQUIRED
# else:
# con_options['ssl_cert_reqs'] = ssl.CERT_NONE
#
# return con_options
#
# Path: luna/config.py
. Output only the next line. | mclient = pymongo.MongoClient(**get_con_options()) |
Given snippet: <|code_start|>#!/usr/bin/env python
'''
Written by Dmitry Chirikov <dmitry@chirikov.ru>
This file is part of Luna, cluster provisioning tool
https://github.com/dchirikov/luna
This file is part of Luna.
Luna 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.
Luna 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 Luna. If not, see <http://www.gnu.org/licenses/>.
'''
log = logging.getLogger(__file__)
log.info('Luna migration script to db v1.2')
try:
mclient = pymongo.MongoClient(**get_con_options())
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import logging
import pymongo
import uuid
from luna.utils.helpers import get_con_options
from luna.config import db_name
from luna import Group
from luna import Cluster
and context:
# Path: luna/utils/helpers.py
# def get_con_options():
# con_options = {'host': 'mongodb://'}
# conf_defaults = {'server': 'localhost', 'replicaset': None,
# 'authdb': None, 'user': None, 'password': None,
# 'SSL': None, 'CAcert': None}
# conf = ConfigParser.ConfigParser(conf_defaults)
#
# if not conf.read("/etc/luna.conf"):
# return {'host': conf_defaults['server']}
#
# replicaset = conf.get("MongoDB", "replicaset")
# server = conf.get("MongoDB", "server")
# authdb = conf.get("MongoDB", "authdb")
# user = conf.get("MongoDB", "user")
# password = urllib.quote_plus(conf.get("MongoDB", "password"))
# need_ssl = conf.get("MongoDB", "SSL")
# ca_cert = conf.get("MongoDB", "CAcert")
#
# if user and password:
# con_options['host'] += user + ':' + password + '@'
#
# con_options['host'] += server
#
# if authdb:
# con_options['host'] += '/' + authdb
#
# if replicaset:
# con_options['replicaSet'] = replicaset
#
# if need_ssl in ['Enabled', 'enabled']:
# con_options['ssl'] = True
# if ca_cert:
# con_options['ssl_ca_certs'] = ca_cert
# con_options['ssl_cert_reqs'] = ssl.CERT_REQUIRED
# else:
# con_options['ssl_cert_reqs'] = ssl.CERT_NONE
#
# return con_options
#
# Path: luna/config.py
which might include code, classes, or functions. Output only the next line. | mdb = mclient[db_name] |
Predict the next line after this snippet: <|code_start|>
Luna 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.
Luna 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 Luna. If not, see <http://www.gnu.org/licenses/>.
'''
def set_mac_node(mac, node, mongo_db=None):
logging.basicConfig(level=logging.INFO)
# logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
if not mongo_db:
try:
mongo_client = pymongo.MongoClient(**get_con_options())
except:
err_msg = "Unable to connect to MongoDB."
logger.error(err_msg)
raise RuntimeError, err_msg
logger.debug("Connection to MongoDB was successful.")
<|code_end|>
using the current file's imports:
from luna.config import db_name
import logging
import pymongo
import ConfigParser
import urllib
import sys
import os
import errno
import subprocess
import ssl
and any relevant context from other files:
# Path: luna/config.py
. Output only the next line. | mongo_db = mongo_client[db_name] |
Based on the snippet: <|code_start|>
class Test(unittest.TestCase):
redis_host = '127.0.0.1'
# redis_port = 8379
redis_port = 6379
redis_db = 0
redis_password = ''
def setUp(self):
# Redis instance
r = redis.StrictRedis(host=self.redis_host, port=self.redis_port,
db=self.redis_db, password=self.redis_password)
# RpqQueue instance
<|code_end|>
, predict the immediate next line with the help of imports:
import unittest
import redis
from ..lib.RpqQueue import RpqQueue
and context (classes, functions, sometimes code) from other files:
# Path: clients/python/lib/RpqQueue.py
# class RpqQueue:
#
# def __init__(self, redis, queueName):
# """
# Registers RpqLua queue from a Redis connection
# """
#
# # RpqLua instance
# self.queue = RpqLua(redis)
#
# # Set queue name
# self.setqueueName(queueName)
#
# def eval(self, args):
# return self.queue.eval(*args)
#
# def bytesDecode(self, item):
# """
# Decode Bytes to utf-8 for Python 3 compatibility
# """
#
# return item.decode("utf-8")
#
# def setqueueName(self, queueName):
# """
# Define loaded queue name at class level
# """
#
# self.queueName = queueName
#
# def push(self, item, priority=None):
# """
# Push an item
# """
#
# # Build arg list
# args = ['push', self.queueName, item]
# if priority is not None:
# args.append(priority)
#
# return self.eval(args)
#
# def pop(self, orderBy='desc'):
# """
# alias for popOne()
# """
#
# return self.popOne(orderBy)
#
# def popOne(self, orderBy='desc'):
# """
# Pop an item
# """
#
# item = self.popMany(orderBy, 1)
#
# if item: # There is an item
# return item[0]
# else:
# return None
#
# def popMany(self, orderBy='desc', numberOfItems=1):
# """
# Pop many items
# """
#
# items = self.eval(['pop', self.queueName, orderBy, numberOfItems])
# if items:
# # Decode all items from bytes to utf-8
# items = tuple(map(self.bytesDecode, items))
#
# return items
# else:
# return None
#
# def peek(self, orderBy='desc'):
# """
# alias for peekOne()
# """
#
# return self.peekOne(orderBy)
#
# def peekOne(self, orderBy='desc'):
# """
# Peek an item
# """
#
# item = self.peekMany(orderBy, 1)
#
# if item: # There is an item
# return item[0]
# else:
# return None
#
# def peekMany(self, orderBy='desc', numberOfItems=1):
# """
# Peek many items
# """
#
# items = self.eval(['peek', self.queueName, orderBy, numberOfItems])
# if items:
# # Decode all items from bytes to utf-8
# items = tuple(map(self.bytesDecode, items))
#
# return items
# else:
# return None
#
# def count(self, priorityMin=None, priorityMax=None):
# """
# Get queue size
# """
#
# # Build arg list
# args = ['size', self.queueName]
# if priorityMin is not None:
# args.append(priorityMin)
# if priorityMax is not None:
# args.append(priorityMax)
#
# return self.eval(args)
. Output only the next line. | self.rq = RpqQueue(r, 'test_queue') |
Given the code snippet: <|code_start|>
class Test(unittest.TestCase):
redis_host = '127.0.0.1'
# redis_port = 8379
redis_port = 6379
redis_db = 0
redis_password = ''
lua_path = 'src/redis-priority-queue.lua'
def setUp(self):
# Redis instance
self.r = redis.StrictRedis(
host=self.redis_host, port=self.redis_port, db=self.redis_db, password=self.redis_password)
# RpqQueue instance
<|code_end|>
, generate the next line using the imports in this file:
import unittest
import redis
from ..lib.RpqLua import RpqLua
and context (functions, classes, or occasionally code) from other files:
# Path: clients/python/lib/RpqLua.py
# class RpqLua:
# def __init__(self, redisConnection):
# '''Sets Redis connection, load LUA from path'''
#
# # Set Redis connection
# self.setRedisConnection(redisConnection)
#
# # Load LUA source
# self.loadSource(self.getLuaPath())
#
# # Register LUA script
# self.register()
#
# def getLuaPath(self):
# """
# Returns the LUA path in the filesystem
# """
#
# import rpq_src
# import pkg_resources
#
# return pkg_resources.resource_filename('rpq_src', 'redis-priority-queue.lua')
#
# def file_get_contents(self, filename):
# """
# Get a file content
# """
#
# with open(filename) as f:
# return f.read()
#
# def setRedisConnection(self, connection):
# """
# Set a Redis connection
# """
#
# self.connection = connection
#
# return True
#
# def loadSource(self, path):
# """
# Load LUA script source code from a file
# """
#
# self.source = self.file_get_contents(path)
#
# return True
#
# def getSha1(self):
# """
# Calculate sha1 of the LUA source
# """
#
# d = hashlib.sha1(self.source.encode('utf-8'))
# d.digest()
# return d.hexdigest()
#
# def exists(self):
# """
# Returns `True` if the LUA script is already loaded into Redis
# """
#
# # Check if the script exists
# t = self.connection.script_exists(self.sha1)
#
# if t and t[0]:
# return True
#
# return False
#
# def load(self):
# """
# Load the script into Redis
# """
#
# self.connection.script_load(self.source)
#
# return True
#
# def register(self):
# """
# Registers the script
# """
#
# # Set LUA sha1
# self.sha1 = self.getSha1()
#
# # Load if needed
# if not self.exists():
# self.load()
#
# return True
#
# def eval(self, *args):
# """
# Call the LUA script with the desired arguments and returns the output
# """
#
# return self.connection.evalsha(self.sha1, 0, *args)
. Output only the next line. | self.rl = RpqLua(self.r) |
Continue the code snippet: <|code_start|>#!/usr/bin/env python3
class RpqQueue:
def __init__(self, redis, queueName):
"""
Registers RpqLua queue from a Redis connection
"""
# RpqLua instance
<|code_end|>
. Use current file imports:
from .RpqLua import RpqLua
and context (classes, functions, or code) from other files:
# Path: clients/python/lib/RpqLua.py
# class RpqLua:
# def __init__(self, redisConnection):
# '''Sets Redis connection, load LUA from path'''
#
# # Set Redis connection
# self.setRedisConnection(redisConnection)
#
# # Load LUA source
# self.loadSource(self.getLuaPath())
#
# # Register LUA script
# self.register()
#
# def getLuaPath(self):
# """
# Returns the LUA path in the filesystem
# """
#
# import rpq_src
# import pkg_resources
#
# return pkg_resources.resource_filename('rpq_src', 'redis-priority-queue.lua')
#
# def file_get_contents(self, filename):
# """
# Get a file content
# """
#
# with open(filename) as f:
# return f.read()
#
# def setRedisConnection(self, connection):
# """
# Set a Redis connection
# """
#
# self.connection = connection
#
# return True
#
# def loadSource(self, path):
# """
# Load LUA script source code from a file
# """
#
# self.source = self.file_get_contents(path)
#
# return True
#
# def getSha1(self):
# """
# Calculate sha1 of the LUA source
# """
#
# d = hashlib.sha1(self.source.encode('utf-8'))
# d.digest()
# return d.hexdigest()
#
# def exists(self):
# """
# Returns `True` if the LUA script is already loaded into Redis
# """
#
# # Check if the script exists
# t = self.connection.script_exists(self.sha1)
#
# if t and t[0]:
# return True
#
# return False
#
# def load(self):
# """
# Load the script into Redis
# """
#
# self.connection.script_load(self.source)
#
# return True
#
# def register(self):
# """
# Registers the script
# """
#
# # Set LUA sha1
# self.sha1 = self.getSha1()
#
# # Load if needed
# if not self.exists():
# self.load()
#
# return True
#
# def eval(self, *args):
# """
# Call the LUA script with the desired arguments and returns the output
# """
#
# return self.connection.evalsha(self.sha1, 0, *args)
. Output only the next line. | self.queue = RpqLua(redis) |
Given the following code snippet before the placeholder: <|code_start|>#!/usr/bin/python
#
# Copyright 2016 Pinterest, Inc
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
num = 0
def f():
global num
num += 1
class PeriodicalTestCase(unittest.TestCase):
def test_run_periodically(self):
<|code_end|>
, predict the next line using imports from the current file:
import unittest
import gevent
from kingpin.thrift_utils.periodical import Periodical
and context including class names, function names, and sometimes code from other files:
# Path: kingpin/thrift_utils/periodical.py
# class Periodical(object):
# def __init__(self, name, interval_secs, start_after_secs,
# f, *args, **kwargs):
# """Constructor.
#
# Args:
# name: name of the periodical for bookkeeping.
# interval_secs: frequency to run.
# start_after_secs: first run starts after start_after_secs.
# f: function to run.
# args: args passed to f
# kwargs: kwargs passed to f
#
# """
# self.name = name
# self.interval_secs = interval_secs
#
# self.f = f
# self.args = args
# self.kwargs = kwargs
#
# self.last_timestamp = time.time() + start_after_secs - interval_secs
# self.greenlet = gevent.spawn(self._run)
#
# def _run(self):
# """Run the wrapped function periodically"""
# try:
# while True:
# ts = time.time()
# if self.last_timestamp + self.interval_secs <= ts:
# self.last_timestamp = ts
# try:
# self.f(*self.args, **self.kwargs)
# except gevent.GreenletExit:
# # We are notified to exit.
# raise
# except BaseException as e:
# # We ignore other exceptions.
# log.error("Exception %s caught in Periodical %s " % (
# repr(e), self.name))
#
# # sleep until the time for the next run.
# sleep_secs = self.last_timestamp + self.interval_secs \
# - time.time()
#
# if sleep_secs < 0:
# sleep_secs = 0
#
# gevent.sleep(sleep_secs)
#
# except gevent.GreenletExit:
# log.info("Periodical %s stopped." % self.name)
#
# def stop(self):
# """Stop the periodical.
#
# It must be called in order to garbage collect this object.
#
# """
# self.greenlet.kill(block=True)
. Output only the next line. | p = Periodical('f', 0, 0, f) |
Continue the code snippet: <|code_start|># you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
TEST_ZK_HOSTS = ['observerzookeeper010:2181']
TEST_AWS_KEYFILE = "test_keyfile"
TEST_S3_BUCKET = "test_bucket"
class DeciderTestCase(TestCase):
experiment_name = "some_exp"
camel_experiment_name = "Some_Exp"
experiment_name2 = "some_exp2"
def setUp(self):
self.mock_zk_config_manager = mock.patch(
"kingpin.manageddata.managed_datastructures.ZKConfigManager",
mock_zk_config_manager.MockZkConfigManager)
self.mock_zk_config_manager.start()
<|code_end|>
. Use current file imports:
import mock
import mock_zk_config_manager
from kingpin.manageddata.decider import Decider
from unittest import TestCase
and context (classes, functions, or code) from other files:
# Path: kingpin/manageddata/decider.py
# class Decider(object):
# __metaclass__ = SingletonMetaclass
#
# def __init__(self):
# self.initialized = False
#
# def initialize(self, zk_hosts, aws_keyfile, s3_bucket, s3_endpoint="s3.amazonaws.com"):
# self.decider_map = ManagedHashMap("admin", "decider", "Decider Values",
# "Map of decider name and its value",
# zk_hosts, aws_keyfile, s3_bucket, s3_endpoint=s3_endpoint)
#
# def check_initialized(self):
# if not self.initialized:
# raise Exception("Decider not initialized! Please call initialize()")
#
# def get_decider_value(self, experiment_name, default=0):
# """Retrieve the decider value associated with the ``experiment_name``."""
# experiment_name = experiment_name.lower()
#
# decider_value = self.decider_map.get(experiment_name)
#
# if decider_value is None:
# decider_value = default
#
# return decider_value
#
# def decide_experiment(self, experiment_name, default=False):
# """Decides if a experiment needs to be run. Calculate a random number
# between 1 and 100 and see if its less than a given value.
# Ex: decider.decide_experiment(config.decider.NEW_BOARD_PIN_TUPLES_READ)
#
# Args:
# default: A boolean, the default value to return if the experiment does not exist.
#
# """
# default_value = 100 if default else 0
# exp_value = self.get_decider_value(experiment_name, default=default_value)
# if exp_value == 100:
# return True
# if exp_value == 0:
# return False
# return random.randrange(0, 100, 1) < exp_value
#
# def is_id_in_experiment(self, decider_id, experiment_name):
# """Decides if an id needs to be run under an experiment_name.
# It modes the id by 100 and see whether it is within
# the decider range.
# Ex: decider.is_id_in_experiment(
# 12345, config.decider.NEW_BOARD_PIN_TUPLES_READ)
#
# NOTE: If you are doing a user-sticky decider, you should probably use is_hashed_id_in_experiment(userid, decider)
# below. This function simply mods the userid by 100, which means that e.g. all user-ID based deciders set to 20%
# will affect the same 20% segment of users.
# """
# decider_value = self.get_decider_value(experiment_name)
# decider_id %= 100
# return decider_id < decider_value
#
# def is_hashed_id_in_experiment(self, unique_id, experiment_name):
# """Checks if a decider should be active given an ID (e.g. of a user, random request, etc.).
#
# This function computes a hash of the user ID and the decider, so different deciders will get different
# random samples of users.
# Ex: decider.is_hashed_id_in_decider(context.viewing_user.id, config.decider.NEW_BOARD_PIN_TUPLES_READ)
# """
# decider_value = self.get_decider_value(experiment_name)
#
# # We add the string decider_ so that if user IDs are used for unique_id, we don't have the same
# # hash as the experiment framework. That would lead to non-independence of this decider
# # and the experiment groups.
# hash_val = hashlib.md5("decider_%s%s" % (experiment_name, unique_id)).hexdigest()
# val = int(hash_val, 16) % 100
#
# return val < decider_value
#
# def set_experiment_value(self, experiment_name, value):
# """Set the value of an experiment and update in zookeeper if we are on adminapp
# Ex: decider.set_experiment_value(config.decider.NEW_BOARD_PIN_TUPLES_READ, 80)
# Args:
# experiment_name: a string, the decider's name
# value: an int, the value you want to set
# enable_audit_history: whether to save the change to audit history
# author: A string, the committer of the change.
# comment: A string, a brief description of the change
#
# """
# if experiment_name.lower() != experiment_name:
# raise Exception("Only use lower case for experiment names")
#
# if value < 0 or value > 100:
# raise Exception("Invalid experiment value")
#
# self.decider_map.set(experiment_name, value)
. Output only the next line. | self.decider = Decider() |
Predict the next line after this snippet: <|code_start|># You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""The policy on whether to retry a thrift request on a given exception."""
class RetryPolicy(object):
"""This class encapsulate the logic on whether to retry a thrift request
given a particular exception.
"""
def should_retry(self, exception):
"""Whether to retry a thrift request on the given exception.
Args:
exception: The exception thrown by the previous thrift request.
Returns:
True, if the request should be retried; False, otherwise.
"""
# only service specific exceptions need to be considered
<|code_end|>
using the current file's imports:
from .ttypes import RetriableRPCException
and any relevant context from other files:
# Path: kingpin/thrift_utils/ttypes.py
# class RetriableRPCException(TException):
# """
# Attributes:
# - errorCode
# - message
# """
#
# thrift_spec = (
# None, # 0
# (1, TType.I32, 'errorCode', None, None, ), # 1
# (2, TType.STRING, 'message', None, None, ), # 2
# )
#
# def __init__(self, errorCode=None, message=None,):
# self.errorCode = errorCode
# self.message = message
#
# def read(self, iprot):
# if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
# fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
# return
# iprot.readStructBegin()
# while True:
# (fname, ftype, fid) = iprot.readFieldBegin()
# if ftype == TType.STOP:
# break
# if fid == 1:
# if ftype == TType.I32:
# self.errorCode = iprot.readI32();
# else:
# iprot.skip(ftype)
# elif fid == 2:
# if ftype == TType.STRING:
# self.message = iprot.readString();
# else:
# iprot.skip(ftype)
# else:
# iprot.skip(ftype)
# iprot.readFieldEnd()
# iprot.readStructEnd()
#
# def write(self, oprot):
# if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
# oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
# return
# oprot.writeStructBegin('RetriableRPCException')
# if self.errorCode is not None:
# oprot.writeFieldBegin('errorCode', TType.I32, 1)
# oprot.writeI32(self.errorCode)
# oprot.writeFieldEnd()
# if self.message is not None:
# oprot.writeFieldBegin('message', TType.STRING, 2)
# oprot.writeString(self.message)
# oprot.writeFieldEnd()
# oprot.writeFieldStop()
# oprot.writeStructEnd()
#
# def validate(self):
# return
#
#
# def __str__(self):
# return repr(self)
#
# def __repr__(self):
# L = ['%s=%r' % (key, value)
# for key, value in self.__dict__.iteritems()]
# return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
#
# def __eq__(self, other):
# return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
#
# def __ne__(self, other):
# return not (self == other)
. Output only the next line. | return isinstance(exception, RetriableRPCException) |
Given snippet: <|code_start|>#!/usr/bin/python
#
# Copyright 2016 Pinterest, Inc
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for common decorators."""
class SingletonsTestCase(unittest.TestCase):
def test_singleton_metaclass(self):
"""Test singleton metaclass."""
class Foo(object):
"""Metaclass enforced singleton."""
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import unittest
from kingpin.kazoo_utils import decorators
and context:
# Path: kingpin/kazoo_utils/decorators.py
# class SingletonMetaclass(type):
# def __init__(cls, *args, **kwargs):
# def __call__(cls, *args, **kwargs):
which might include code, classes, or functions. Output only the next line. | __metaclass__ = decorators.SingletonMetaclass |
Here is a snippet: <|code_start|>
# Currently the polling is by default to run every 30 seconds.
# The class is a singleton, we can come up a way to allow customizing
# the frequency in the future if necessary.
_POLLING_WAIT_IN_SECONDS = 30
def timeout_after(secs):
"""Decorator to timeout a function.
It raises a gevent.Timeout exception after the specified seconds in
the decorated function. The timeout will work only if the decorated
function yields, e.g. performing blocking operations through gevent.
"""
def timeout_enforced(f):
@wraps(f)
def g(*args, **kwargs):
return gevent.with_timeout(secs, f, *args, **kwargs)
return g
return timeout_enforced
class FileWatch:
__metaclass__ = SingletonMetaclass
def __init__(self, polling=True,
polling_wait_in_seconds=_POLLING_WAIT_IN_SECONDS,
<|code_end|>
. Write the next line using the current file imports:
from collections import namedtuple
from functools import wraps
from .utils import dummy_statsd
from .utils import hostname
from .utils import _escape_path_for_stats_name
from .decorators import SingletonMetaclass
from ..thrift_utils.periodical import Periodical
import datetime
import gevent
import hashlib
import logging
import os
and context from other files:
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# def __init__(self, *args, **kwargs):
# def increment(self, stats, sample_rate=1, tags={}):
# def gauge(self, stats, value, sample_rate=1, tags={}):
# class DummyStatsdClient:
#
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# def __init__(self, *args, **kwargs):
# def increment(self, stats, sample_rate=1, tags={}):
# def gauge(self, stats, value, sample_rate=1, tags={}):
# class DummyStatsdClient:
#
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# # Do some formatting the file path.
# if path is None:
# return None
# if path.startswith("/"):
# path = path[1:]
# return path.replace("/", "_")
#
# Path: kingpin/kazoo_utils/decorators.py
# class SingletonMetaclass(type):
# """Singleton class that ensures there is only one instance of the object.
#
# Instead of using ``singleton`` decorator use this metaclass. This ensures
# that classes remain classes as opposed to
# functions that return classes, as that is the approach the decorator takes.
#
# For more details consult
# http://stackoverflow.com/questions/8563130/python-singleton-class.
#
# To make your class singleton add ``__metaclass__``::
#
# class Highlander(object)
# '''There can be only one!'''
#
# __metaclass__ = SingletonMetaclass
#
# def __init__(self):
# self.x = 1
#
# """
# def __init__(cls, *args, **kwargs):
# super(SingletonMetaclass, cls).__init__(*args, **kwargs)
# cls.__instance = None
# cls.__lock = threading.RLock()
#
# def __call__(cls, *args, **kwargs):
# # Make this thread safe.
# with cls.__lock:
# if cls.__instance is None:
# cls.__instance = super(SingletonMetaclass, cls).__call__(
# *args, **kwargs)
# return cls.__instance
#
# Path: kingpin/thrift_utils/periodical.py
# class Periodical(object):
# def __init__(self, name, interval_secs, start_after_secs,
# f, *args, **kwargs):
# """Constructor.
#
# Args:
# name: name of the periodical for bookkeeping.
# interval_secs: frequency to run.
# start_after_secs: first run starts after start_after_secs.
# f: function to run.
# args: args passed to f
# kwargs: kwargs passed to f
#
# """
# self.name = name
# self.interval_secs = interval_secs
#
# self.f = f
# self.args = args
# self.kwargs = kwargs
#
# self.last_timestamp = time.time() + start_after_secs - interval_secs
# self.greenlet = gevent.spawn(self._run)
#
# def _run(self):
# """Run the wrapped function periodically"""
# try:
# while True:
# ts = time.time()
# if self.last_timestamp + self.interval_secs <= ts:
# self.last_timestamp = ts
# try:
# self.f(*self.args, **self.kwargs)
# except gevent.GreenletExit:
# # We are notified to exit.
# raise
# except BaseException as e:
# # We ignore other exceptions.
# log.error("Exception %s caught in Periodical %s " % (
# repr(e), self.name))
#
# # sleep until the time for the next run.
# sleep_secs = self.last_timestamp + self.interval_secs \
# - time.time()
#
# if sleep_secs < 0:
# sleep_secs = 0
#
# gevent.sleep(sleep_secs)
#
# except gevent.GreenletExit:
# log.info("Periodical %s stopped." % self.name)
#
# def stop(self):
# """Stop the periodical.
#
# It must be called in order to garbage collect this object.
#
# """
# self.greenlet.kill(block=True)
, which may include functions, classes, or code. Output only the next line. | sc=dummy_statsd): |
Here is a snippet: <|code_start|> file_content = f.read()
try:
self._invoke_callback(
on_change, watch_type, file_content,
self.Stat(version=last_update_time))
except Exception:
log.exception("Exception in watcher callback for %s, "
"ignoring" % file_path)
log.debug('The last modified timestamp of file %s is %f'
% (file_path, last_update_time))
md5_hash = self._compute_md5_hash(file_content)
log.debug('The md5 hash of file %s is %s' % (
file_path, md5_hash))
key = (file_path, watch_type)
if key in self._watched_file_map:
# Append on_change to the file_path's existing callbacks
self._watched_file_map[key][2].append(on_change)
else:
self._watched_file_map[key] = (
last_update_time, md5_hash, [on_change])
log.info("successfully added file watch of type %s, on %s" % (
watch_type, file_path))
break
except Exception, gevent.Timeout:
log.exception("failed to add file watch of type %s, on %s" % (
watch_type, file_path))
self._sc.increment(
"errors.file.{}watch.failure.{}.{}".format(
<|code_end|>
. Write the next line using the current file imports:
from collections import namedtuple
from functools import wraps
from .utils import dummy_statsd
from .utils import hostname
from .utils import _escape_path_for_stats_name
from .decorators import SingletonMetaclass
from ..thrift_utils.periodical import Periodical
import datetime
import gevent
import hashlib
import logging
import os
and context from other files:
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# def __init__(self, *args, **kwargs):
# def increment(self, stats, sample_rate=1, tags={}):
# def gauge(self, stats, value, sample_rate=1, tags={}):
# class DummyStatsdClient:
#
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# def __init__(self, *args, **kwargs):
# def increment(self, stats, sample_rate=1, tags={}):
# def gauge(self, stats, value, sample_rate=1, tags={}):
# class DummyStatsdClient:
#
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# # Do some formatting the file path.
# if path is None:
# return None
# if path.startswith("/"):
# path = path[1:]
# return path.replace("/", "_")
#
# Path: kingpin/kazoo_utils/decorators.py
# class SingletonMetaclass(type):
# """Singleton class that ensures there is only one instance of the object.
#
# Instead of using ``singleton`` decorator use this metaclass. This ensures
# that classes remain classes as opposed to
# functions that return classes, as that is the approach the decorator takes.
#
# For more details consult
# http://stackoverflow.com/questions/8563130/python-singleton-class.
#
# To make your class singleton add ``__metaclass__``::
#
# class Highlander(object)
# '''There can be only one!'''
#
# __metaclass__ = SingletonMetaclass
#
# def __init__(self):
# self.x = 1
#
# """
# def __init__(cls, *args, **kwargs):
# super(SingletonMetaclass, cls).__init__(*args, **kwargs)
# cls.__instance = None
# cls.__lock = threading.RLock()
#
# def __call__(cls, *args, **kwargs):
# # Make this thread safe.
# with cls.__lock:
# if cls.__instance is None:
# cls.__instance = super(SingletonMetaclass, cls).__call__(
# *args, **kwargs)
# return cls.__instance
#
# Path: kingpin/thrift_utils/periodical.py
# class Periodical(object):
# def __init__(self, name, interval_secs, start_after_secs,
# f, *args, **kwargs):
# """Constructor.
#
# Args:
# name: name of the periodical for bookkeeping.
# interval_secs: frequency to run.
# start_after_secs: first run starts after start_after_secs.
# f: function to run.
# args: args passed to f
# kwargs: kwargs passed to f
#
# """
# self.name = name
# self.interval_secs = interval_secs
#
# self.f = f
# self.args = args
# self.kwargs = kwargs
#
# self.last_timestamp = time.time() + start_after_secs - interval_secs
# self.greenlet = gevent.spawn(self._run)
#
# def _run(self):
# """Run the wrapped function periodically"""
# try:
# while True:
# ts = time.time()
# if self.last_timestamp + self.interval_secs <= ts:
# self.last_timestamp = ts
# try:
# self.f(*self.args, **self.kwargs)
# except gevent.GreenletExit:
# # We are notified to exit.
# raise
# except BaseException as e:
# # We ignore other exceptions.
# log.error("Exception %s caught in Periodical %s " % (
# repr(e), self.name))
#
# # sleep until the time for the next run.
# sleep_secs = self.last_timestamp + self.interval_secs \
# - time.time()
#
# if sleep_secs < 0:
# sleep_secs = 0
#
# gevent.sleep(sleep_secs)
#
# except gevent.GreenletExit:
# log.info("Periodical %s stopped." % self.name)
#
# def stop(self):
# """Stop the periodical.
#
# It must be called in order to garbage collect this object.
#
# """
# self.greenlet.kill(block=True)
, which may include functions, classes, or code. Output only the next line. | watch_type, file_path_stat_name, hostname), |
Based on the snippet: <|code_start|> backoff_in_secs: how much to backoff between retries. retry
backoff will be exponentially backoff.
max_wait_in_secs: max wait in seconds between retries.
"""
num_tries = 0
assert file_path
assert on_change
self._validate_watch_type(watch_type)
if not keep_retrying:
# If not keep retrying, this is a synchronous call,
# if fails then it fails.
last_update_time = os.path.getmtime(file_path)
else:
# Running the background greenlet, keep retrying until the
# serverset file is there.
while True:
if os.path.isfile(file_path):
last_update_time = os.path.getmtime(file_path)
break
else:
log.exception("non existing file of type %s, on %s" % (
watch_type, file_path))
# exponential backoff
gevent.sleep(self._calculate_backoff_time(
num_tries, backoff_in_secs, max_wait_in_secs))
num_tries += 1
num_tries = 0
<|code_end|>
, predict the immediate next line with the help of imports:
from collections import namedtuple
from functools import wraps
from .utils import dummy_statsd
from .utils import hostname
from .utils import _escape_path_for_stats_name
from .decorators import SingletonMetaclass
from ..thrift_utils.periodical import Periodical
import datetime
import gevent
import hashlib
import logging
import os
and context (classes, functions, sometimes code) from other files:
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# def __init__(self, *args, **kwargs):
# def increment(self, stats, sample_rate=1, tags={}):
# def gauge(self, stats, value, sample_rate=1, tags={}):
# class DummyStatsdClient:
#
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# def __init__(self, *args, **kwargs):
# def increment(self, stats, sample_rate=1, tags={}):
# def gauge(self, stats, value, sample_rate=1, tags={}):
# class DummyStatsdClient:
#
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# # Do some formatting the file path.
# if path is None:
# return None
# if path.startswith("/"):
# path = path[1:]
# return path.replace("/", "_")
#
# Path: kingpin/kazoo_utils/decorators.py
# class SingletonMetaclass(type):
# """Singleton class that ensures there is only one instance of the object.
#
# Instead of using ``singleton`` decorator use this metaclass. This ensures
# that classes remain classes as opposed to
# functions that return classes, as that is the approach the decorator takes.
#
# For more details consult
# http://stackoverflow.com/questions/8563130/python-singleton-class.
#
# To make your class singleton add ``__metaclass__``::
#
# class Highlander(object)
# '''There can be only one!'''
#
# __metaclass__ = SingletonMetaclass
#
# def __init__(self):
# self.x = 1
#
# """
# def __init__(cls, *args, **kwargs):
# super(SingletonMetaclass, cls).__init__(*args, **kwargs)
# cls.__instance = None
# cls.__lock = threading.RLock()
#
# def __call__(cls, *args, **kwargs):
# # Make this thread safe.
# with cls.__lock:
# if cls.__instance is None:
# cls.__instance = super(SingletonMetaclass, cls).__call__(
# *args, **kwargs)
# return cls.__instance
#
# Path: kingpin/thrift_utils/periodical.py
# class Periodical(object):
# def __init__(self, name, interval_secs, start_after_secs,
# f, *args, **kwargs):
# """Constructor.
#
# Args:
# name: name of the periodical for bookkeeping.
# interval_secs: frequency to run.
# start_after_secs: first run starts after start_after_secs.
# f: function to run.
# args: args passed to f
# kwargs: kwargs passed to f
#
# """
# self.name = name
# self.interval_secs = interval_secs
#
# self.f = f
# self.args = args
# self.kwargs = kwargs
#
# self.last_timestamp = time.time() + start_after_secs - interval_secs
# self.greenlet = gevent.spawn(self._run)
#
# def _run(self):
# """Run the wrapped function periodically"""
# try:
# while True:
# ts = time.time()
# if self.last_timestamp + self.interval_secs <= ts:
# self.last_timestamp = ts
# try:
# self.f(*self.args, **self.kwargs)
# except gevent.GreenletExit:
# # We are notified to exit.
# raise
# except BaseException as e:
# # We ignore other exceptions.
# log.error("Exception %s caught in Periodical %s " % (
# repr(e), self.name))
#
# # sleep until the time for the next run.
# sleep_secs = self.last_timestamp + self.interval_secs \
# - time.time()
#
# if sleep_secs < 0:
# sleep_secs = 0
#
# gevent.sleep(sleep_secs)
#
# except gevent.GreenletExit:
# log.info("Periodical %s stopped." % self.name)
#
# def stop(self):
# """Stop the periodical.
#
# It must be called in order to garbage collect this object.
#
# """
# self.greenlet.kill(block=True)
. Output only the next line. | file_path_stat_name = _escape_path_for_stats_name(file_path) |
Next line prediction: <|code_start|>
log = logging.getLogger(__name__)
# Currently the polling is by default to run every 30 seconds.
# The class is a singleton, we can come up a way to allow customizing
# the frequency in the future if necessary.
_POLLING_WAIT_IN_SECONDS = 30
def timeout_after(secs):
"""Decorator to timeout a function.
It raises a gevent.Timeout exception after the specified seconds in
the decorated function. The timeout will work only if the decorated
function yields, e.g. performing blocking operations through gevent.
"""
def timeout_enforced(f):
@wraps(f)
def g(*args, **kwargs):
return gevent.with_timeout(secs, f, *args, **kwargs)
return g
return timeout_enforced
class FileWatch:
<|code_end|>
. Use current file imports:
(from collections import namedtuple
from functools import wraps
from .utils import dummy_statsd
from .utils import hostname
from .utils import _escape_path_for_stats_name
from .decorators import SingletonMetaclass
from ..thrift_utils.periodical import Periodical
import datetime
import gevent
import hashlib
import logging
import os)
and context including class names, function names, or small code snippets from other files:
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# def __init__(self, *args, **kwargs):
# def increment(self, stats, sample_rate=1, tags={}):
# def gauge(self, stats, value, sample_rate=1, tags={}):
# class DummyStatsdClient:
#
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# def __init__(self, *args, **kwargs):
# def increment(self, stats, sample_rate=1, tags={}):
# def gauge(self, stats, value, sample_rate=1, tags={}):
# class DummyStatsdClient:
#
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# # Do some formatting the file path.
# if path is None:
# return None
# if path.startswith("/"):
# path = path[1:]
# return path.replace("/", "_")
#
# Path: kingpin/kazoo_utils/decorators.py
# class SingletonMetaclass(type):
# """Singleton class that ensures there is only one instance of the object.
#
# Instead of using ``singleton`` decorator use this metaclass. This ensures
# that classes remain classes as opposed to
# functions that return classes, as that is the approach the decorator takes.
#
# For more details consult
# http://stackoverflow.com/questions/8563130/python-singleton-class.
#
# To make your class singleton add ``__metaclass__``::
#
# class Highlander(object)
# '''There can be only one!'''
#
# __metaclass__ = SingletonMetaclass
#
# def __init__(self):
# self.x = 1
#
# """
# def __init__(cls, *args, **kwargs):
# super(SingletonMetaclass, cls).__init__(*args, **kwargs)
# cls.__instance = None
# cls.__lock = threading.RLock()
#
# def __call__(cls, *args, **kwargs):
# # Make this thread safe.
# with cls.__lock:
# if cls.__instance is None:
# cls.__instance = super(SingletonMetaclass, cls).__call__(
# *args, **kwargs)
# return cls.__instance
#
# Path: kingpin/thrift_utils/periodical.py
# class Periodical(object):
# def __init__(self, name, interval_secs, start_after_secs,
# f, *args, **kwargs):
# """Constructor.
#
# Args:
# name: name of the periodical for bookkeeping.
# interval_secs: frequency to run.
# start_after_secs: first run starts after start_after_secs.
# f: function to run.
# args: args passed to f
# kwargs: kwargs passed to f
#
# """
# self.name = name
# self.interval_secs = interval_secs
#
# self.f = f
# self.args = args
# self.kwargs = kwargs
#
# self.last_timestamp = time.time() + start_after_secs - interval_secs
# self.greenlet = gevent.spawn(self._run)
#
# def _run(self):
# """Run the wrapped function periodically"""
# try:
# while True:
# ts = time.time()
# if self.last_timestamp + self.interval_secs <= ts:
# self.last_timestamp = ts
# try:
# self.f(*self.args, **self.kwargs)
# except gevent.GreenletExit:
# # We are notified to exit.
# raise
# except BaseException as e:
# # We ignore other exceptions.
# log.error("Exception %s caught in Periodical %s " % (
# repr(e), self.name))
#
# # sleep until the time for the next run.
# sleep_secs = self.last_timestamp + self.interval_secs \
# - time.time()
#
# if sleep_secs < 0:
# sleep_secs = 0
#
# gevent.sleep(sleep_secs)
#
# except gevent.GreenletExit:
# log.info("Periodical %s stopped." % self.name)
#
# def stop(self):
# """Stop the periodical.
#
# It must be called in order to garbage collect this object.
#
# """
# self.greenlet.kill(block=True)
. Output only the next line. | __metaclass__ = SingletonMetaclass |
Predict the next line for this snippet: <|code_start|> function yields, e.g. performing blocking operations through gevent.
"""
def timeout_enforced(f):
@wraps(f)
def g(*args, **kwargs):
return gevent.with_timeout(secs, f, *args, **kwargs)
return g
return timeout_enforced
class FileWatch:
__metaclass__ = SingletonMetaclass
def __init__(self, polling=True,
polling_wait_in_seconds=_POLLING_WAIT_IN_SECONDS,
sc=dummy_statsd):
"""
Args:
polling: flag to indicate whether the greenlet for polling
file changes is started, having this option is mainly for unit
testing so that tests can disable polling.
polling_wait_in_seconds: Mostly for testing, allow to inject a small
wait time so tests can go through quickly.
"""
# a map from (file_path, watch_type) to (timestamp, hash, [func])
self._watched_file_map = {}
self._sc = sc
if polling:
<|code_end|>
with the help of current file imports:
from collections import namedtuple
from functools import wraps
from .utils import dummy_statsd
from .utils import hostname
from .utils import _escape_path_for_stats_name
from .decorators import SingletonMetaclass
from ..thrift_utils.periodical import Periodical
import datetime
import gevent
import hashlib
import logging
import os
and context from other files:
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# def __init__(self, *args, **kwargs):
# def increment(self, stats, sample_rate=1, tags={}):
# def gauge(self, stats, value, sample_rate=1, tags={}):
# class DummyStatsdClient:
#
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# def __init__(self, *args, **kwargs):
# def increment(self, stats, sample_rate=1, tags={}):
# def gauge(self, stats, value, sample_rate=1, tags={}):
# class DummyStatsdClient:
#
# Path: kingpin/kazoo_utils/utils.py
# def _escape_path_for_stats_name(path):
# # Do some formatting the file path.
# if path is None:
# return None
# if path.startswith("/"):
# path = path[1:]
# return path.replace("/", "_")
#
# Path: kingpin/kazoo_utils/decorators.py
# class SingletonMetaclass(type):
# """Singleton class that ensures there is only one instance of the object.
#
# Instead of using ``singleton`` decorator use this metaclass. This ensures
# that classes remain classes as opposed to
# functions that return classes, as that is the approach the decorator takes.
#
# For more details consult
# http://stackoverflow.com/questions/8563130/python-singleton-class.
#
# To make your class singleton add ``__metaclass__``::
#
# class Highlander(object)
# '''There can be only one!'''
#
# __metaclass__ = SingletonMetaclass
#
# def __init__(self):
# self.x = 1
#
# """
# def __init__(cls, *args, **kwargs):
# super(SingletonMetaclass, cls).__init__(*args, **kwargs)
# cls.__instance = None
# cls.__lock = threading.RLock()
#
# def __call__(cls, *args, **kwargs):
# # Make this thread safe.
# with cls.__lock:
# if cls.__instance is None:
# cls.__instance = super(SingletonMetaclass, cls).__call__(
# *args, **kwargs)
# return cls.__instance
#
# Path: kingpin/thrift_utils/periodical.py
# class Periodical(object):
# def __init__(self, name, interval_secs, start_after_secs,
# f, *args, **kwargs):
# """Constructor.
#
# Args:
# name: name of the periodical for bookkeeping.
# interval_secs: frequency to run.
# start_after_secs: first run starts after start_after_secs.
# f: function to run.
# args: args passed to f
# kwargs: kwargs passed to f
#
# """
# self.name = name
# self.interval_secs = interval_secs
#
# self.f = f
# self.args = args
# self.kwargs = kwargs
#
# self.last_timestamp = time.time() + start_after_secs - interval_secs
# self.greenlet = gevent.spawn(self._run)
#
# def _run(self):
# """Run the wrapped function periodically"""
# try:
# while True:
# ts = time.time()
# if self.last_timestamp + self.interval_secs <= ts:
# self.last_timestamp = ts
# try:
# self.f(*self.args, **self.kwargs)
# except gevent.GreenletExit:
# # We are notified to exit.
# raise
# except BaseException as e:
# # We ignore other exceptions.
# log.error("Exception %s caught in Periodical %s " % (
# repr(e), self.name))
#
# # sleep until the time for the next run.
# sleep_secs = self.last_timestamp + self.interval_secs \
# - time.time()
#
# if sleep_secs < 0:
# sleep_secs = 0
#
# gevent.sleep(sleep_secs)
#
# except gevent.GreenletExit:
# log.info("Periodical %s stopped." % self.name)
#
# def stop(self):
# """Stop the periodical.
#
# It must be called in order to garbage collect this object.
#
# """
# self.greenlet.kill(block=True)
, which may contain function names, class names, or code. Output only the next line. | Periodical( |
Given snippet: <|code_start|># You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Decider is built on top of managedhashmap to be a key_value store whose keys
are strings (experiment name), values are integer ranging from 0 to 100.
This is widely used in Pinterest to decide the % / branching of code logic
and deciding experiments in real time.
Before using Decider, you need to create the ManagedData for decider, for example
using metaconfig_shell.py in examples/.
The domain of manageddata is "admin", key is "decider".
"""
log = logging.getLogger(__name__)
class Decider(object):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import logging
import hashlib
import random
from managed_datastructures import ManagedHashMap
from ..kazoo_utils.decorators import SingletonMetaclass
and context:
# Path: kingpin/kazoo_utils/decorators.py
# class SingletonMetaclass(type):
# """Singleton class that ensures there is only one instance of the object.
#
# Instead of using ``singleton`` decorator use this metaclass. This ensures
# that classes remain classes as opposed to
# functions that return classes, as that is the approach the decorator takes.
#
# For more details consult
# http://stackoverflow.com/questions/8563130/python-singleton-class.
#
# To make your class singleton add ``__metaclass__``::
#
# class Highlander(object)
# '''There can be only one!'''
#
# __metaclass__ = SingletonMetaclass
#
# def __init__(self):
# self.x = 1
#
# """
# def __init__(cls, *args, **kwargs):
# super(SingletonMetaclass, cls).__init__(*args, **kwargs)
# cls.__instance = None
# cls.__lock = threading.RLock()
#
# def __call__(cls, *args, **kwargs):
# # Make this thread safe.
# with cls.__lock:
# if cls.__instance is None:
# cls.__instance = super(SingletonMetaclass, cls).__call__(
# *args, **kwargs)
# return cls.__instance
which might include code, classes, or functions. Output only the next line. | __metaclass__ = SingletonMetaclass |
Given the following code snippet before the placeholder: <|code_start|># WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
try:
except ImportError:
LARGE_SERVERSET_EXAMPLE_FILE_PATH = 'kingpin/tests/zk_update_monitor/large_serverset'
SMALL_SERVERSET_EXAMPLE = '10.168.233.131:9107,10.181.110.62:9145,10.233.95.194:9142,10.123.198.226:9130,10.239.174.184:9131'
class ZKUpdateMonitorTestCase(TestCase):
""" Test cases for transforming zk_download_data command basing
on different size of serversets
Small serverset should pass in cmd line directly,
large serverset should be written to a temp file
"""
def test_transform_command_for_large_serverset(self):
try:
command = '/usr/local/bin/zk_download_data.py -f /var/serverset/discovery.stingray_dsl_mapper.prod -p /discovery/stingray_dsl_mapper/prod -m serverset'
notification_timestamp = 1426859717.707331
with open(LARGE_SERVERSET_EXAMPLE_FILE_PATH) as f:
large_serverset_value = f.readline()
(transformed_command, tmp_filepath) = transform_command_with_value(
command, large_serverset_value, notification_timestamp)
santinized_value = large_serverset_value.strip('\n').strip('\r')
<|code_end|>
, predict the next line using imports from the current file:
from unittest import TestCase
from kingpin.zk_update_monitor import zk_util
from kingpin.zk_update_monitor.zk_update_monitor import transform_command_with_value
import os
import simplejson as json
import json
and context including class names, function names, and sometimes code from other files:
# Path: kingpin/zk_update_monitor/zk_util.py
# def get_md5_digest(zk_data):
# def get_md5_hash_sum(zk_data):
# def split_problematic_endpoints_line(line):
# def construct_s3_path(s3_key, timestamp):
# def _kazoo_client(zk_hosts):
# def _zk_path_exists(zk_hosts, path):
# def _kill(message):
# def parse_zk_hosts_file(zk_hosts_file_path):
#
# Path: kingpin/zk_update_monitor/zk_update_monitor.py
# def transform_command_with_value(command, value, notification_timestamp):
# python_download_script = 'zk_download_data.py'
#
# if len(value) > _LONG_VALUE_THRESHOLD:
# # If the value is too long (serverset is too large), OSError may be thrown.
# # Instead of passing it in command line, write to a temp file and
# # let zk_download_data read from it.
# value = value.replace("\n", "").replace("\r", "")
# md5digest = zk_util.get_md5_digest(value)
# tmp_filename = 'zk_update_largefile_' + md5digest + '_' + str(notification_timestamp)
# tmp_dir = tempfile.gettempprefix()
# tmp_filepath = os.path.join('/', tmp_dir, tmp_filename)
#
# log.info("This is a long value, write it to temp file %s", tmp_filepath)
# try:
# with open(tmp_filepath, 'w') as f:
# f.write(value + '\n' + md5digest)
# except Exception as e:
# log.exception(
# "%s: Failed to generate temp file %s for storing large size values"
# % (e.message, tmp_filepath))
# return (None, None)
# finally:
# f.close()
# transformed_command = command.replace(
# python_download_script, "%s -l %s" % (
# python_download_script, tmp_filepath))
# return transformed_command, tmp_filepath
# else:
# transformed_command = command.replace(
# python_download_script, "%s -v '%s'" % (
# python_download_script, value))
# return transformed_command, None
. Output only the next line. | expected_tmp_filepath = '/tmp/zk_update_largefile_' + zk_util.get_md5_digest( |
Using the snippet: <|code_start|>#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
try:
except ImportError:
LARGE_SERVERSET_EXAMPLE_FILE_PATH = 'kingpin/tests/zk_update_monitor/large_serverset'
SMALL_SERVERSET_EXAMPLE = '10.168.233.131:9107,10.181.110.62:9145,10.233.95.194:9142,10.123.198.226:9130,10.239.174.184:9131'
class ZKUpdateMonitorTestCase(TestCase):
""" Test cases for transforming zk_download_data command basing
on different size of serversets
Small serverset should pass in cmd line directly,
large serverset should be written to a temp file
"""
def test_transform_command_for_large_serverset(self):
try:
command = '/usr/local/bin/zk_download_data.py -f /var/serverset/discovery.stingray_dsl_mapper.prod -p /discovery/stingray_dsl_mapper/prod -m serverset'
notification_timestamp = 1426859717.707331
with open(LARGE_SERVERSET_EXAMPLE_FILE_PATH) as f:
large_serverset_value = f.readline()
<|code_end|>
, determine the next line of code. You have imports:
from unittest import TestCase
from kingpin.zk_update_monitor import zk_util
from kingpin.zk_update_monitor.zk_update_monitor import transform_command_with_value
import os
import simplejson as json
import json
and context (class names, function names, or code) available:
# Path: kingpin/zk_update_monitor/zk_util.py
# def get_md5_digest(zk_data):
# def get_md5_hash_sum(zk_data):
# def split_problematic_endpoints_line(line):
# def construct_s3_path(s3_key, timestamp):
# def _kazoo_client(zk_hosts):
# def _zk_path_exists(zk_hosts, path):
# def _kill(message):
# def parse_zk_hosts_file(zk_hosts_file_path):
#
# Path: kingpin/zk_update_monitor/zk_update_monitor.py
# def transform_command_with_value(command, value, notification_timestamp):
# python_download_script = 'zk_download_data.py'
#
# if len(value) > _LONG_VALUE_THRESHOLD:
# # If the value is too long (serverset is too large), OSError may be thrown.
# # Instead of passing it in command line, write to a temp file and
# # let zk_download_data read from it.
# value = value.replace("\n", "").replace("\r", "")
# md5digest = zk_util.get_md5_digest(value)
# tmp_filename = 'zk_update_largefile_' + md5digest + '_' + str(notification_timestamp)
# tmp_dir = tempfile.gettempprefix()
# tmp_filepath = os.path.join('/', tmp_dir, tmp_filename)
#
# log.info("This is a long value, write it to temp file %s", tmp_filepath)
# try:
# with open(tmp_filepath, 'w') as f:
# f.write(value + '\n' + md5digest)
# except Exception as e:
# log.exception(
# "%s: Failed to generate temp file %s for storing large size values"
# % (e.message, tmp_filepath))
# return (None, None)
# finally:
# f.close()
# transformed_command = command.replace(
# python_download_script, "%s -l %s" % (
# python_download_script, tmp_filepath))
# return transformed_command, tmp_filepath
# else:
# transformed_command = command.replace(
# python_download_script, "%s -v '%s'" % (
# python_download_script, value))
# return transformed_command, None
. Output only the next line. | (transformed_command, tmp_filepath) = transform_command_with_value( |
Based on the snippet: <|code_start|> is_player = True
is_permanent = False
is_creature = False
is_land = False
is_spell = False
def __init__(self, deck, name='player',
startingLife=20, maxHandSize=7, game=None):
self.name = name
self.game = game
self.timestamp = -1
self.life = startingLife
self.startingLife = startingLife
self.maxHandSize = maxHandSize
self.landPerTurn = 1
self.landPlayed = 0
self.passPriorityUntil = None
self.autoPayMana = False
self.autoOrderTriggers = True
self.autoDiscard = False
self.library = zone.Library(self, deck)
for card in self.library:
card.controller = self
card._owner = self
self.battlefield = zone.Battlefield(self)
self.hand = zone.Hand(self)
self.graveyard = zone.Graveyard(self)
self.exile = zone.Exile(self)
<|code_end|>
, predict the immediate next line with the help of imports:
import pdb
import traceback
import random
from copy import deepcopy
from collections import defaultdict
from MTG import mana
from MTG import zone
from MTG import play
from MTG import gamesteps
from MTG import cards
from MTG import triggers
from MTG import token
from MTG.exceptions import *
and context (classes, functions, sometimes code) from other files:
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
#
# Path: MTG/zone.py
# class ZoneType(Enum):
# class Zone():
# class Battlefield(Zone):
# class Stack(Zone):
# class Hand(Zone):
# class Graveyard(Zone):
# class Exile(Zone):
# class Library(Zone):
# LIBRARY = 0
# HAND = 1
# BATTLEFIELD = 2
# GRAVEYARD = 3
# STACK = 4
# EXILE = 5
# def str_to_zone_type(z):
# def __init__(self, controller=None, elements: list=None):
# def __repr__(self):
# def __str__(self):
# def __len__(self):
# def __bool__(self):
# def __getitem__(self, pos):
# def isEmpty(self):
# def add(self, obj):
# def remove(self, obj):
# def filter(self, characteristics=None, filter_func=None):
# def count(self, characteristics=None, filter_func=None):
# def get_card_by_name(self, name):
# def pop(self, pos=-1):
# def clear(self):
# def add(self, obj, status_mod=None, modi_func=None):
# def shuffle(self):
# def __init__(self, controller=None, elements: list=None):
# def add(self, obj, from_top=0, shuffle=True):
# def remove(self, obj, shuffle=False):
#
# Path: MTG/play.py
# class Play(gameobject.GameObject):
# def __init__(self, apply_func, apply_condition=lambda: True,
# card=None, source=None, name=None,
# targets_chosen=None, target_criterias=None, is_mana_ability=False):
# def __repr__(self):
# def can_be_countered(self, source=None):
# def counter(self, source):
# def apply(self):
#
# Path: MTG/gamesteps.py
# class Phase(Enum):
# class Step(Enum):
# BEGINNING = 0
# PRECOMBAT_MAIN = 1
# COMBAT = 2
# POSTCOMBAT_MAIN = 3
# ENDING = 4
# UNTAP = 0
# UPKEEP = 1
# DRAW = 2
# PRECOMBAT_MAIN = 3
# BEGINNING_OF_COMBAT = 4
# DECLARE_ATTACKERS = 5
# DECLARE_BLOCKERS = 6
# FIRST_STRIKE_COMBAT_DAMAGE = 7
# COMBAT_DAMAGE = 8
# END_OF_COMBAT = 9
# POSTCOMBAT_MAIN = 10
# END = 11
# CLEANUP = 12
# def steps(self):
# def phase(self):
#
# Path: MTG/cards.py
# SETPREFIX = ['M15', 'sm_set', 'cube']
# ID = name_to_id(name)
# def id_to_name(ID):
# def name_to_id(name):
# def str_to_class(str):
# def card_from_name(name, get_instance=True):
# def read_deck(filename):
# def add_activated_ability(cardname, cost, effect, target_criterias=None, prompts=None):
# def add_targets(cardname, criterias=[lambda self, p: True], prompts=None):
# def add_play_func_with_targets(cardname, outcome=lambda self, t, l: True):
# def play_func(self):
# def add_play_func_no_target(cardname, outcome=lambda self: True):
# def add_aura_effect(cardname, effects, target_criterias=['creature']):
# def add_trigger(cardname, condition, effect, requirements=None,
# target_criterias=None, target_prompts=None, intervening_if=None):
# def add_static_effect(cardname, apply_to, name, value, toggle_func=lambda eff: False):
# def indentation_lv(s):
# def parse_card_from_lines(lines, log=None):
# def setup_cards(FILES=['data/m15_cards.txt', 'data/cube_cards.txt']):
#
# Path: MTG/triggers.py
# class triggerConditions(Enum):
#
# Path: MTG/token.py
# class Token(permanent.Permanent):
# def __init__(self, characteristics, controller, activated_abilities=[]):
# def create_token(attributes, controller, num=1, keyword_abilities=[], activated_abilities=[]):
. Output only the next line. | self.mana = mana.ManaPool(self) |
Using the snippet: <|code_start|>
class Player():
is_player = True
is_permanent = False
is_creature = False
is_land = False
is_spell = False
def __init__(self, deck, name='player',
startingLife=20, maxHandSize=7, game=None):
self.name = name
self.game = game
self.timestamp = -1
self.life = startingLife
self.startingLife = startingLife
self.maxHandSize = maxHandSize
self.landPerTurn = 1
self.landPlayed = 0
self.passPriorityUntil = None
self.autoPayMana = False
self.autoOrderTriggers = True
self.autoDiscard = False
<|code_end|>
, determine the next line of code. You have imports:
import pdb
import traceback
import random
from copy import deepcopy
from collections import defaultdict
from MTG import mana
from MTG import zone
from MTG import play
from MTG import gamesteps
from MTG import cards
from MTG import triggers
from MTG import token
from MTG.exceptions import *
and context (class names, function names, or code) available:
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
#
# Path: MTG/zone.py
# class ZoneType(Enum):
# class Zone():
# class Battlefield(Zone):
# class Stack(Zone):
# class Hand(Zone):
# class Graveyard(Zone):
# class Exile(Zone):
# class Library(Zone):
# LIBRARY = 0
# HAND = 1
# BATTLEFIELD = 2
# GRAVEYARD = 3
# STACK = 4
# EXILE = 5
# def str_to_zone_type(z):
# def __init__(self, controller=None, elements: list=None):
# def __repr__(self):
# def __str__(self):
# def __len__(self):
# def __bool__(self):
# def __getitem__(self, pos):
# def isEmpty(self):
# def add(self, obj):
# def remove(self, obj):
# def filter(self, characteristics=None, filter_func=None):
# def count(self, characteristics=None, filter_func=None):
# def get_card_by_name(self, name):
# def pop(self, pos=-1):
# def clear(self):
# def add(self, obj, status_mod=None, modi_func=None):
# def shuffle(self):
# def __init__(self, controller=None, elements: list=None):
# def add(self, obj, from_top=0, shuffle=True):
# def remove(self, obj, shuffle=False):
#
# Path: MTG/play.py
# class Play(gameobject.GameObject):
# def __init__(self, apply_func, apply_condition=lambda: True,
# card=None, source=None, name=None,
# targets_chosen=None, target_criterias=None, is_mana_ability=False):
# def __repr__(self):
# def can_be_countered(self, source=None):
# def counter(self, source):
# def apply(self):
#
# Path: MTG/gamesteps.py
# class Phase(Enum):
# class Step(Enum):
# BEGINNING = 0
# PRECOMBAT_MAIN = 1
# COMBAT = 2
# POSTCOMBAT_MAIN = 3
# ENDING = 4
# UNTAP = 0
# UPKEEP = 1
# DRAW = 2
# PRECOMBAT_MAIN = 3
# BEGINNING_OF_COMBAT = 4
# DECLARE_ATTACKERS = 5
# DECLARE_BLOCKERS = 6
# FIRST_STRIKE_COMBAT_DAMAGE = 7
# COMBAT_DAMAGE = 8
# END_OF_COMBAT = 9
# POSTCOMBAT_MAIN = 10
# END = 11
# CLEANUP = 12
# def steps(self):
# def phase(self):
#
# Path: MTG/cards.py
# SETPREFIX = ['M15', 'sm_set', 'cube']
# ID = name_to_id(name)
# def id_to_name(ID):
# def name_to_id(name):
# def str_to_class(str):
# def card_from_name(name, get_instance=True):
# def read_deck(filename):
# def add_activated_ability(cardname, cost, effect, target_criterias=None, prompts=None):
# def add_targets(cardname, criterias=[lambda self, p: True], prompts=None):
# def add_play_func_with_targets(cardname, outcome=lambda self, t, l: True):
# def play_func(self):
# def add_play_func_no_target(cardname, outcome=lambda self: True):
# def add_aura_effect(cardname, effects, target_criterias=['creature']):
# def add_trigger(cardname, condition, effect, requirements=None,
# target_criterias=None, target_prompts=None, intervening_if=None):
# def add_static_effect(cardname, apply_to, name, value, toggle_func=lambda eff: False):
# def indentation_lv(s):
# def parse_card_from_lines(lines, log=None):
# def setup_cards(FILES=['data/m15_cards.txt', 'data/cube_cards.txt']):
#
# Path: MTG/triggers.py
# class triggerConditions(Enum):
#
# Path: MTG/token.py
# class Token(permanent.Permanent):
# def __init__(self, characteristics, controller, activated_abilities=[]):
# def create_token(attributes, controller, num=1, keyword_abilities=[], activated_abilities=[]):
. Output only the next line. | self.library = zone.Library(self, deck) |
Given snippet: <|code_start|> elif len(color) > 1:
color = self.make_choice(
"What color would you like to add? {}".format(color))
assert color in mana.manachr
else:
color = color[0]
color = mana.chr_to_mana(color)
creatures_to_tap.append(_creature)
if cost[color]:
cost[color] -= 1
else:
if cost[mana.Mana.GENERIC]:
cost[mana.Mana.GENERIC] -= 1
else:
raise ValueError
except (IndexError, ValueError):
print("error processing creature for convoke")
pass
can_pay = self.mana.canPay(cost)
if can_play and can_target and can_pay:
self.hand.remove(card)
self.mana.pay(can_pay)
for _creature in creatures_to_tap:
_creature.tap()
print("{} playing {} targeting {}\n".format(self, card, card.targets_chosen))
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pdb
import traceback
import random
from copy import deepcopy
from collections import defaultdict
from MTG import mana
from MTG import zone
from MTG import play
from MTG import gamesteps
from MTG import cards
from MTG import triggers
from MTG import token
from MTG.exceptions import *
and context:
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
#
# Path: MTG/zone.py
# class ZoneType(Enum):
# class Zone():
# class Battlefield(Zone):
# class Stack(Zone):
# class Hand(Zone):
# class Graveyard(Zone):
# class Exile(Zone):
# class Library(Zone):
# LIBRARY = 0
# HAND = 1
# BATTLEFIELD = 2
# GRAVEYARD = 3
# STACK = 4
# EXILE = 5
# def str_to_zone_type(z):
# def __init__(self, controller=None, elements: list=None):
# def __repr__(self):
# def __str__(self):
# def __len__(self):
# def __bool__(self):
# def __getitem__(self, pos):
# def isEmpty(self):
# def add(self, obj):
# def remove(self, obj):
# def filter(self, characteristics=None, filter_func=None):
# def count(self, characteristics=None, filter_func=None):
# def get_card_by_name(self, name):
# def pop(self, pos=-1):
# def clear(self):
# def add(self, obj, status_mod=None, modi_func=None):
# def shuffle(self):
# def __init__(self, controller=None, elements: list=None):
# def add(self, obj, from_top=0, shuffle=True):
# def remove(self, obj, shuffle=False):
#
# Path: MTG/play.py
# class Play(gameobject.GameObject):
# def __init__(self, apply_func, apply_condition=lambda: True,
# card=None, source=None, name=None,
# targets_chosen=None, target_criterias=None, is_mana_ability=False):
# def __repr__(self):
# def can_be_countered(self, source=None):
# def counter(self, source):
# def apply(self):
#
# Path: MTG/gamesteps.py
# class Phase(Enum):
# class Step(Enum):
# BEGINNING = 0
# PRECOMBAT_MAIN = 1
# COMBAT = 2
# POSTCOMBAT_MAIN = 3
# ENDING = 4
# UNTAP = 0
# UPKEEP = 1
# DRAW = 2
# PRECOMBAT_MAIN = 3
# BEGINNING_OF_COMBAT = 4
# DECLARE_ATTACKERS = 5
# DECLARE_BLOCKERS = 6
# FIRST_STRIKE_COMBAT_DAMAGE = 7
# COMBAT_DAMAGE = 8
# END_OF_COMBAT = 9
# POSTCOMBAT_MAIN = 10
# END = 11
# CLEANUP = 12
# def steps(self):
# def phase(self):
#
# Path: MTG/cards.py
# SETPREFIX = ['M15', 'sm_set', 'cube']
# ID = name_to_id(name)
# def id_to_name(ID):
# def name_to_id(name):
# def str_to_class(str):
# def card_from_name(name, get_instance=True):
# def read_deck(filename):
# def add_activated_ability(cardname, cost, effect, target_criterias=None, prompts=None):
# def add_targets(cardname, criterias=[lambda self, p: True], prompts=None):
# def add_play_func_with_targets(cardname, outcome=lambda self, t, l: True):
# def play_func(self):
# def add_play_func_no_target(cardname, outcome=lambda self: True):
# def add_aura_effect(cardname, effects, target_criterias=['creature']):
# def add_trigger(cardname, condition, effect, requirements=None,
# target_criterias=None, target_prompts=None, intervening_if=None):
# def add_static_effect(cardname, apply_to, name, value, toggle_func=lambda eff: False):
# def indentation_lv(s):
# def parse_card_from_lines(lines, log=None):
# def setup_cards(FILES=['data/m15_cards.txt', 'data/cube_cards.txt']):
#
# Path: MTG/triggers.py
# class triggerConditions(Enum):
#
# Path: MTG/token.py
# class Token(permanent.Permanent):
# def __init__(self, characteristics, controller, activated_abilities=[]):
# def create_token(attributes, controller, num=1, keyword_abilities=[], activated_abilities=[]):
which might include code, classes, or functions. Output only the next line. | _play = play.Play(card.play_func, |
Predict the next line after this snippet: <|code_start|> self.mana.add_str('WWWWWUUUUUBBBBBRRRRRGGGGG11111')
elif answer == 'debug':
pdb.set_trace()
pass
elif answer[:2] == '__': # for dev purposes
exec(answer[2:])
return '__continue'
elif answer[0] == 'p': # playing card from hand
try:
# 'p 3' == plays third card in hand
num = int(answer[2:])
assert num < len(self.hand)
card = self.hand[num]
except:
name = answer[2:] # 'p Island' == plays 'Island'
card = self.hand.get_card_by_name(name)
assert card
# timing & restrictions
can_play = True
if card.is_land and self.landPlayed >= self.landPerTurn:
can_play = False
if not (card.is_instant or card.has_ability('Flash')) and (
self.game.stack
or self.game.step.phase not in [
<|code_end|>
using the current file's imports:
import pdb
import traceback
import random
from copy import deepcopy
from collections import defaultdict
from MTG import mana
from MTG import zone
from MTG import play
from MTG import gamesteps
from MTG import cards
from MTG import triggers
from MTG import token
from MTG.exceptions import *
and any relevant context from other files:
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
#
# Path: MTG/zone.py
# class ZoneType(Enum):
# class Zone():
# class Battlefield(Zone):
# class Stack(Zone):
# class Hand(Zone):
# class Graveyard(Zone):
# class Exile(Zone):
# class Library(Zone):
# LIBRARY = 0
# HAND = 1
# BATTLEFIELD = 2
# GRAVEYARD = 3
# STACK = 4
# EXILE = 5
# def str_to_zone_type(z):
# def __init__(self, controller=None, elements: list=None):
# def __repr__(self):
# def __str__(self):
# def __len__(self):
# def __bool__(self):
# def __getitem__(self, pos):
# def isEmpty(self):
# def add(self, obj):
# def remove(self, obj):
# def filter(self, characteristics=None, filter_func=None):
# def count(self, characteristics=None, filter_func=None):
# def get_card_by_name(self, name):
# def pop(self, pos=-1):
# def clear(self):
# def add(self, obj, status_mod=None, modi_func=None):
# def shuffle(self):
# def __init__(self, controller=None, elements: list=None):
# def add(self, obj, from_top=0, shuffle=True):
# def remove(self, obj, shuffle=False):
#
# Path: MTG/play.py
# class Play(gameobject.GameObject):
# def __init__(self, apply_func, apply_condition=lambda: True,
# card=None, source=None, name=None,
# targets_chosen=None, target_criterias=None, is_mana_ability=False):
# def __repr__(self):
# def can_be_countered(self, source=None):
# def counter(self, source):
# def apply(self):
#
# Path: MTG/gamesteps.py
# class Phase(Enum):
# class Step(Enum):
# BEGINNING = 0
# PRECOMBAT_MAIN = 1
# COMBAT = 2
# POSTCOMBAT_MAIN = 3
# ENDING = 4
# UNTAP = 0
# UPKEEP = 1
# DRAW = 2
# PRECOMBAT_MAIN = 3
# BEGINNING_OF_COMBAT = 4
# DECLARE_ATTACKERS = 5
# DECLARE_BLOCKERS = 6
# FIRST_STRIKE_COMBAT_DAMAGE = 7
# COMBAT_DAMAGE = 8
# END_OF_COMBAT = 9
# POSTCOMBAT_MAIN = 10
# END = 11
# CLEANUP = 12
# def steps(self):
# def phase(self):
#
# Path: MTG/cards.py
# SETPREFIX = ['M15', 'sm_set', 'cube']
# ID = name_to_id(name)
# def id_to_name(ID):
# def name_to_id(name):
# def str_to_class(str):
# def card_from_name(name, get_instance=True):
# def read_deck(filename):
# def add_activated_ability(cardname, cost, effect, target_criterias=None, prompts=None):
# def add_targets(cardname, criterias=[lambda self, p: True], prompts=None):
# def add_play_func_with_targets(cardname, outcome=lambda self, t, l: True):
# def play_func(self):
# def add_play_func_no_target(cardname, outcome=lambda self: True):
# def add_aura_effect(cardname, effects, target_criterias=['creature']):
# def add_trigger(cardname, condition, effect, requirements=None,
# target_criterias=None, target_prompts=None, intervening_if=None):
# def add_static_effect(cardname, apply_to, name, value, toggle_func=lambda eff: False):
# def indentation_lv(s):
# def parse_card_from_lines(lines, log=None):
# def setup_cards(FILES=['data/m15_cards.txt', 'data/cube_cards.txt']):
#
# Path: MTG/triggers.py
# class triggerConditions(Enum):
#
# Path: MTG/token.py
# class Token(permanent.Permanent):
# def __init__(self, characteristics, controller, activated_abilities=[]):
# def create_token(attributes, controller, num=1, keyword_abilities=[], activated_abilities=[]):
. Output only the next line. | gamesteps.Phase.PRECOMBAT_MAIN, |
Predict the next line after this snippet: <|code_start|> """Pass player-init triggers to relevant permanents
e.g. onControllerLifeGain
"""
if isinstance(condition, str):
condition = triggers.triggerConditions[condition]
if condition == triggers.triggerConditions.onUpkeep:
def f(p):
p.status.summoning_sick = False
self.apply_to_battlefield(f)
elif condition == triggers.triggerConditions.onCleanup:
def f(p):
p.status.damage_taken = 0
self.apply_to_battlefield(f)
if condition in self.trigger_listeners:
# make copy so we can remove while iterating
for p, tstamp in self.trigger_listeners[condition][:]:
if p.timestamp == tstamp:
p.trigger(condition, source, amount)
else: # expired
print("player-based trigger {} expired".format((p, tstamp)))
self.trigger_listeners[condition].remove((p, tstamp))
def play_card(self, card):
if isinstance(card, str): # convert card name to Card object
<|code_end|>
using the current file's imports:
import pdb
import traceback
import random
from copy import deepcopy
from collections import defaultdict
from MTG import mana
from MTG import zone
from MTG import play
from MTG import gamesteps
from MTG import cards
from MTG import triggers
from MTG import token
from MTG.exceptions import *
and any relevant context from other files:
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
#
# Path: MTG/zone.py
# class ZoneType(Enum):
# class Zone():
# class Battlefield(Zone):
# class Stack(Zone):
# class Hand(Zone):
# class Graveyard(Zone):
# class Exile(Zone):
# class Library(Zone):
# LIBRARY = 0
# HAND = 1
# BATTLEFIELD = 2
# GRAVEYARD = 3
# STACK = 4
# EXILE = 5
# def str_to_zone_type(z):
# def __init__(self, controller=None, elements: list=None):
# def __repr__(self):
# def __str__(self):
# def __len__(self):
# def __bool__(self):
# def __getitem__(self, pos):
# def isEmpty(self):
# def add(self, obj):
# def remove(self, obj):
# def filter(self, characteristics=None, filter_func=None):
# def count(self, characteristics=None, filter_func=None):
# def get_card_by_name(self, name):
# def pop(self, pos=-1):
# def clear(self):
# def add(self, obj, status_mod=None, modi_func=None):
# def shuffle(self):
# def __init__(self, controller=None, elements: list=None):
# def add(self, obj, from_top=0, shuffle=True):
# def remove(self, obj, shuffle=False):
#
# Path: MTG/play.py
# class Play(gameobject.GameObject):
# def __init__(self, apply_func, apply_condition=lambda: True,
# card=None, source=None, name=None,
# targets_chosen=None, target_criterias=None, is_mana_ability=False):
# def __repr__(self):
# def can_be_countered(self, source=None):
# def counter(self, source):
# def apply(self):
#
# Path: MTG/gamesteps.py
# class Phase(Enum):
# class Step(Enum):
# BEGINNING = 0
# PRECOMBAT_MAIN = 1
# COMBAT = 2
# POSTCOMBAT_MAIN = 3
# ENDING = 4
# UNTAP = 0
# UPKEEP = 1
# DRAW = 2
# PRECOMBAT_MAIN = 3
# BEGINNING_OF_COMBAT = 4
# DECLARE_ATTACKERS = 5
# DECLARE_BLOCKERS = 6
# FIRST_STRIKE_COMBAT_DAMAGE = 7
# COMBAT_DAMAGE = 8
# END_OF_COMBAT = 9
# POSTCOMBAT_MAIN = 10
# END = 11
# CLEANUP = 12
# def steps(self):
# def phase(self):
#
# Path: MTG/cards.py
# SETPREFIX = ['M15', 'sm_set', 'cube']
# ID = name_to_id(name)
# def id_to_name(ID):
# def name_to_id(name):
# def str_to_class(str):
# def card_from_name(name, get_instance=True):
# def read_deck(filename):
# def add_activated_ability(cardname, cost, effect, target_criterias=None, prompts=None):
# def add_targets(cardname, criterias=[lambda self, p: True], prompts=None):
# def add_play_func_with_targets(cardname, outcome=lambda self, t, l: True):
# def play_func(self):
# def add_play_func_no_target(cardname, outcome=lambda self: True):
# def add_aura_effect(cardname, effects, target_criterias=['creature']):
# def add_trigger(cardname, condition, effect, requirements=None,
# target_criterias=None, target_prompts=None, intervening_if=None):
# def add_static_effect(cardname, apply_to, name, value, toggle_func=lambda eff: False):
# def indentation_lv(s):
# def parse_card_from_lines(lines, log=None):
# def setup_cards(FILES=['data/m15_cards.txt', 'data/cube_cards.txt']):
#
# Path: MTG/triggers.py
# class triggerConditions(Enum):
#
# Path: MTG/token.py
# class Token(permanent.Permanent):
# def __init__(self, characteristics, controller, activated_abilities=[]):
# def create_token(attributes, controller, num=1, keyword_abilities=[], activated_abilities=[]):
. Output only the next line. | card = cards.card_from_name(card) |
Next line prediction: <|code_start|> return chosen
def add_static_effect(self, name, value, source, toggle_func, exempt_source=False):
""" toggle_func: condition func on which permanents the static effect affects -- lambda eff: True
e.g. lambda eff: eff.source.is_creature applies to all creatures
exempt_source: True if the effect only applies to 'other permanents'
"""
self.static_effects.append((name, value, source, toggle_func))
for p in self.battlefield:
p.add_effect(name, value, source=source, is_active=False, toggle_func=toggle_func)
if not exempt_source: # when this func is called during permanent.__init__(),
# the card isn't on the battlefield yet.
source.add_effect(name, value, source=source, is_active=False, toggle_func=toggle_func)
def remove_static_effect(self, source):
""" remove all effects from a certain source """
self.static_effects = [eff for eff in self.static_effects if eff[2] != source]
# each permanent should auto-remove since source's timestamp has changed
def trigger(self, condition, source=None, amount=1):
"""Pass player-init triggers to relevant permanents
e.g. onControllerLifeGain
"""
if isinstance(condition, str):
<|code_end|>
. Use current file imports:
(import pdb
import traceback
import random
from copy import deepcopy
from collections import defaultdict
from MTG import mana
from MTG import zone
from MTG import play
from MTG import gamesteps
from MTG import cards
from MTG import triggers
from MTG import token
from MTG.exceptions import *)
and context including class names, function names, or small code snippets from other files:
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
#
# Path: MTG/zone.py
# class ZoneType(Enum):
# class Zone():
# class Battlefield(Zone):
# class Stack(Zone):
# class Hand(Zone):
# class Graveyard(Zone):
# class Exile(Zone):
# class Library(Zone):
# LIBRARY = 0
# HAND = 1
# BATTLEFIELD = 2
# GRAVEYARD = 3
# STACK = 4
# EXILE = 5
# def str_to_zone_type(z):
# def __init__(self, controller=None, elements: list=None):
# def __repr__(self):
# def __str__(self):
# def __len__(self):
# def __bool__(self):
# def __getitem__(self, pos):
# def isEmpty(self):
# def add(self, obj):
# def remove(self, obj):
# def filter(self, characteristics=None, filter_func=None):
# def count(self, characteristics=None, filter_func=None):
# def get_card_by_name(self, name):
# def pop(self, pos=-1):
# def clear(self):
# def add(self, obj, status_mod=None, modi_func=None):
# def shuffle(self):
# def __init__(self, controller=None, elements: list=None):
# def add(self, obj, from_top=0, shuffle=True):
# def remove(self, obj, shuffle=False):
#
# Path: MTG/play.py
# class Play(gameobject.GameObject):
# def __init__(self, apply_func, apply_condition=lambda: True,
# card=None, source=None, name=None,
# targets_chosen=None, target_criterias=None, is_mana_ability=False):
# def __repr__(self):
# def can_be_countered(self, source=None):
# def counter(self, source):
# def apply(self):
#
# Path: MTG/gamesteps.py
# class Phase(Enum):
# class Step(Enum):
# BEGINNING = 0
# PRECOMBAT_MAIN = 1
# COMBAT = 2
# POSTCOMBAT_MAIN = 3
# ENDING = 4
# UNTAP = 0
# UPKEEP = 1
# DRAW = 2
# PRECOMBAT_MAIN = 3
# BEGINNING_OF_COMBAT = 4
# DECLARE_ATTACKERS = 5
# DECLARE_BLOCKERS = 6
# FIRST_STRIKE_COMBAT_DAMAGE = 7
# COMBAT_DAMAGE = 8
# END_OF_COMBAT = 9
# POSTCOMBAT_MAIN = 10
# END = 11
# CLEANUP = 12
# def steps(self):
# def phase(self):
#
# Path: MTG/cards.py
# SETPREFIX = ['M15', 'sm_set', 'cube']
# ID = name_to_id(name)
# def id_to_name(ID):
# def name_to_id(name):
# def str_to_class(str):
# def card_from_name(name, get_instance=True):
# def read_deck(filename):
# def add_activated_ability(cardname, cost, effect, target_criterias=None, prompts=None):
# def add_targets(cardname, criterias=[lambda self, p: True], prompts=None):
# def add_play_func_with_targets(cardname, outcome=lambda self, t, l: True):
# def play_func(self):
# def add_play_func_no_target(cardname, outcome=lambda self: True):
# def add_aura_effect(cardname, effects, target_criterias=['creature']):
# def add_trigger(cardname, condition, effect, requirements=None,
# target_criterias=None, target_prompts=None, intervening_if=None):
# def add_static_effect(cardname, apply_to, name, value, toggle_func=lambda eff: False):
# def indentation_lv(s):
# def parse_card_from_lines(lines, log=None):
# def setup_cards(FILES=['data/m15_cards.txt', 'data/cube_cards.txt']):
#
# Path: MTG/triggers.py
# class triggerConditions(Enum):
#
# Path: MTG/token.py
# class Token(permanent.Permanent):
# def __init__(self, characteristics, controller, activated_abilities=[]):
# def create_token(attributes, controller, num=1, keyword_abilities=[], activated_abilities=[]):
. Output only the next line. | condition = triggers.triggerConditions[condition] |
Next line prediction: <|code_start|>
if not answer: # '' to auto discard
print("Auto discarding\n")
else:
answer = answer.split(" ")
try:
for ind in answer:
ind = int(ind)
if ind < len(self.hand):
cards_to_discard.append(self.hand[ind])
else:
print("Card #{} is out of bounds\n".format(ind))
continue
except:
traceback.print_exc()
print("Error processing discard")
cards_left = num - len(cards_to_discard)
if cards_left > 0:
cards_to_discard.extend(self.hand[-cards_left:])
self.hand.remove(cards_to_discard)
return self.graveyard.add(cards_to_discard)
def mill(self, num=1):
for i in range(min(num, len(self.library))):
self.graveyard.add(self.library.pop())
return True
def create_token(self, attributes, num=1, keyword_abilities=[], activated_abilities=[]):
<|code_end|>
. Use current file imports:
(import pdb
import traceback
import random
from copy import deepcopy
from collections import defaultdict
from MTG import mana
from MTG import zone
from MTG import play
from MTG import gamesteps
from MTG import cards
from MTG import triggers
from MTG import token
from MTG.exceptions import *)
and context including class names, function names, or small code snippets from other files:
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
#
# Path: MTG/zone.py
# class ZoneType(Enum):
# class Zone():
# class Battlefield(Zone):
# class Stack(Zone):
# class Hand(Zone):
# class Graveyard(Zone):
# class Exile(Zone):
# class Library(Zone):
# LIBRARY = 0
# HAND = 1
# BATTLEFIELD = 2
# GRAVEYARD = 3
# STACK = 4
# EXILE = 5
# def str_to_zone_type(z):
# def __init__(self, controller=None, elements: list=None):
# def __repr__(self):
# def __str__(self):
# def __len__(self):
# def __bool__(self):
# def __getitem__(self, pos):
# def isEmpty(self):
# def add(self, obj):
# def remove(self, obj):
# def filter(self, characteristics=None, filter_func=None):
# def count(self, characteristics=None, filter_func=None):
# def get_card_by_name(self, name):
# def pop(self, pos=-1):
# def clear(self):
# def add(self, obj, status_mod=None, modi_func=None):
# def shuffle(self):
# def __init__(self, controller=None, elements: list=None):
# def add(self, obj, from_top=0, shuffle=True):
# def remove(self, obj, shuffle=False):
#
# Path: MTG/play.py
# class Play(gameobject.GameObject):
# def __init__(self, apply_func, apply_condition=lambda: True,
# card=None, source=None, name=None,
# targets_chosen=None, target_criterias=None, is_mana_ability=False):
# def __repr__(self):
# def can_be_countered(self, source=None):
# def counter(self, source):
# def apply(self):
#
# Path: MTG/gamesteps.py
# class Phase(Enum):
# class Step(Enum):
# BEGINNING = 0
# PRECOMBAT_MAIN = 1
# COMBAT = 2
# POSTCOMBAT_MAIN = 3
# ENDING = 4
# UNTAP = 0
# UPKEEP = 1
# DRAW = 2
# PRECOMBAT_MAIN = 3
# BEGINNING_OF_COMBAT = 4
# DECLARE_ATTACKERS = 5
# DECLARE_BLOCKERS = 6
# FIRST_STRIKE_COMBAT_DAMAGE = 7
# COMBAT_DAMAGE = 8
# END_OF_COMBAT = 9
# POSTCOMBAT_MAIN = 10
# END = 11
# CLEANUP = 12
# def steps(self):
# def phase(self):
#
# Path: MTG/cards.py
# SETPREFIX = ['M15', 'sm_set', 'cube']
# ID = name_to_id(name)
# def id_to_name(ID):
# def name_to_id(name):
# def str_to_class(str):
# def card_from_name(name, get_instance=True):
# def read_deck(filename):
# def add_activated_ability(cardname, cost, effect, target_criterias=None, prompts=None):
# def add_targets(cardname, criterias=[lambda self, p: True], prompts=None):
# def add_play_func_with_targets(cardname, outcome=lambda self, t, l: True):
# def play_func(self):
# def add_play_func_no_target(cardname, outcome=lambda self: True):
# def add_aura_effect(cardname, effects, target_criterias=['creature']):
# def add_trigger(cardname, condition, effect, requirements=None,
# target_criterias=None, target_prompts=None, intervening_if=None):
# def add_static_effect(cardname, apply_to, name, value, toggle_func=lambda eff: False):
# def indentation_lv(s):
# def parse_card_from_lines(lines, log=None):
# def setup_cards(FILES=['data/m15_cards.txt', 'data/cube_cards.txt']):
#
# Path: MTG/triggers.py
# class triggerConditions(Enum):
#
# Path: MTG/token.py
# class Token(permanent.Permanent):
# def __init__(self, characteristics, controller, activated_abilities=[]):
# def create_token(attributes, controller, num=1, keyword_abilities=[], activated_abilities=[]):
. Output only the next line. | token.create_token(attributes, self, num, keyword_abilities, activated_abilities) |
Here is a snippet: <|code_start|> self.is_attacking = []
self.is_blocking = []
self.counters = defaultdict(lambda: 0)
class Effect():
""" name: name of effct (dict key to self.effects)
expiration: either a float representing timestamp (usually eot),
or a function (lambda eff: ...) that when evaluated to True signals expiration
toggle_func is the function that, while inactive, if evaluated to True toggles on the effct
while active, the toggle function is negated; thus, it is passed into Effect(...)
as a boolean dictionary (toggle_funcs)
"""
def __init__(self, value, timestamp, apply_target=None, source=None, expiration=math.inf, is_active=True,
toggle_func=lambda eff: False):
self.value = value
self.source = source
self.expiration = expiration
self.is_active = is_active
self.toggle_funcs = {False: toggle_func,
True: lambda eff: not toggle_func(eff)}
self.timestamp = timestamp
self.apply_target = apply_target
<|code_end|>
. Write the next line using the current file imports:
import sys
import pdb
import math
import re
from collections import defaultdict, namedtuple
from sortedcontainers import SortedListWithKey
from functools import reduce
from MTG import gameobject
from MTG import zone
from MTG import cardtype
from MTG import triggers
from MTG import play
from MTG import abilities
and context from other files:
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/zone.py
# class ZoneType(Enum):
# class Zone():
# class Battlefield(Zone):
# class Stack(Zone):
# class Hand(Zone):
# class Graveyard(Zone):
# class Exile(Zone):
# class Library(Zone):
# LIBRARY = 0
# HAND = 1
# BATTLEFIELD = 2
# GRAVEYARD = 3
# STACK = 4
# EXILE = 5
# def str_to_zone_type(z):
# def __init__(self, controller=None, elements: list=None):
# def __repr__(self):
# def __str__(self):
# def __len__(self):
# def __bool__(self):
# def __getitem__(self, pos):
# def isEmpty(self):
# def add(self, obj):
# def remove(self, obj):
# def filter(self, characteristics=None, filter_func=None):
# def count(self, characteristics=None, filter_func=None):
# def get_card_by_name(self, name):
# def pop(self, pos=-1):
# def clear(self):
# def add(self, obj, status_mod=None, modi_func=None):
# def shuffle(self):
# def __init__(self, controller=None, elements: list=None):
# def add(self, obj, from_top=0, shuffle=True):
# def remove(self, obj, shuffle=False):
#
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/triggers.py
# class triggerConditions(Enum):
#
# Path: MTG/play.py
# class Play(gameobject.GameObject):
# def __init__(self, apply_func, apply_condition=lambda: True,
# card=None, source=None, name=None,
# targets_chosen=None, target_criterias=None, is_mana_ability=False):
# def __repr__(self):
# def can_be_countered(self, source=None):
# def counter(self, source):
# def apply(self):
#
# Path: MTG/abilities.py
# class Ability(gameobject.GameObject):
# class ActivatedAbility(Ability):
# class TriggeredAbility(Ability):
# def __init__(self, card, effect, target_criterias=None,
# prompts=None):
# def __str__(self):
# def __repr__(self):
# def resolve(self):
# def __init__(self, card, cost, effect, target_criterias=None, prompts=None, is_mana_ability=False):
# def can_activate(self):
# def __init__(self, card, effect, requirements, target_criterias=None,
# prompts=None, intervening_if=None):
# def condition_satisfied(self):
# def put_on_stack(self):
, which may include functions, classes, or code. Output only the next line. | class Permanent(gameobject.GameObject): |
Given the following code snippet before the placeholder: <|code_start|>
class Effect():
""" name: name of effct (dict key to self.effects)
expiration: either a float representing timestamp (usually eot),
or a function (lambda eff: ...) that when evaluated to True signals expiration
toggle_func is the function that, while inactive, if evaluated to True toggles on the effct
while active, the toggle function is negated; thus, it is passed into Effect(...)
as a boolean dictionary (toggle_funcs)
"""
def __init__(self, value, timestamp, apply_target=None, source=None, expiration=math.inf, is_active=True,
toggle_func=lambda eff: False):
self.value = value
self.source = source
self.expiration = expiration
self.is_active = is_active
self.toggle_funcs = {False: toggle_func,
True: lambda eff: not toggle_func(eff)}
self.timestamp = timestamp
self.apply_target = apply_target
class Permanent(gameobject.GameObject):
def __init__(self, characteristics, controller, owner=None, original_card=None,
status=None, modifications=[]):
self.characteristics = characteristics
self.controller = controller
self._owner = owner
<|code_end|>
, predict the next line using imports from the current file:
import sys
import pdb
import math
import re
from collections import defaultdict, namedtuple
from sortedcontainers import SortedListWithKey
from functools import reduce
from MTG import gameobject
from MTG import zone
from MTG import cardtype
from MTG import triggers
from MTG import play
from MTG import abilities
and context including class names, function names, and sometimes code from other files:
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/zone.py
# class ZoneType(Enum):
# class Zone():
# class Battlefield(Zone):
# class Stack(Zone):
# class Hand(Zone):
# class Graveyard(Zone):
# class Exile(Zone):
# class Library(Zone):
# LIBRARY = 0
# HAND = 1
# BATTLEFIELD = 2
# GRAVEYARD = 3
# STACK = 4
# EXILE = 5
# def str_to_zone_type(z):
# def __init__(self, controller=None, elements: list=None):
# def __repr__(self):
# def __str__(self):
# def __len__(self):
# def __bool__(self):
# def __getitem__(self, pos):
# def isEmpty(self):
# def add(self, obj):
# def remove(self, obj):
# def filter(self, characteristics=None, filter_func=None):
# def count(self, characteristics=None, filter_func=None):
# def get_card_by_name(self, name):
# def pop(self, pos=-1):
# def clear(self):
# def add(self, obj, status_mod=None, modi_func=None):
# def shuffle(self):
# def __init__(self, controller=None, elements: list=None):
# def add(self, obj, from_top=0, shuffle=True):
# def remove(self, obj, shuffle=False):
#
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/triggers.py
# class triggerConditions(Enum):
#
# Path: MTG/play.py
# class Play(gameobject.GameObject):
# def __init__(self, apply_func, apply_condition=lambda: True,
# card=None, source=None, name=None,
# targets_chosen=None, target_criterias=None, is_mana_ability=False):
# def __repr__(self):
# def can_be_countered(self, source=None):
# def counter(self, source):
# def apply(self):
#
# Path: MTG/abilities.py
# class Ability(gameobject.GameObject):
# class ActivatedAbility(Ability):
# class TriggeredAbility(Ability):
# def __init__(self, card, effect, target_criterias=None,
# prompts=None):
# def __str__(self):
# def __repr__(self):
# def resolve(self):
# def __init__(self, card, cost, effect, target_criterias=None, prompts=None, is_mana_ability=False):
# def can_activate(self):
# def __init__(self, card, effect, requirements, target_criterias=None,
# prompts=None, intervening_if=None):
# def condition_satisfied(self):
# def put_on_stack(self):
. Output only the next line. | self.zone = self.controller.battlefield |
Predict the next line after this snippet: <|code_start|>
if card.static_effects == []:
card.static_effects = []
card.static_effects.append((apply_to, name, value, toggle_func))
def indentation_lv(s):
""" Must be tab indented """
lv = 0
for i in s:
if i == '\t':
lv += 1
else:
break
return lv
def parse_card_from_lines(lines, log=None):
""" Lines are formatted according to 'data/cards.txt'
Each set of lines correspond to all abilities/effects of a single card
"""
stage = 'new card'
substage = ''
name = ''
effects = []
<|code_end|>
using the current file's imports:
import sys
import pickle
import math
import re
from collections import namedtuple
from MTG.parsedcards import *
from MTG.exceptions import *
from MTG import abilities
from MTG import triggers
from MTG import mana
from MTG import utils
from MTG import permanent
and any relevant context from other files:
# Path: MTG/abilities.py
# class Ability(gameobject.GameObject):
# class ActivatedAbility(Ability):
# class TriggeredAbility(Ability):
# def __init__(self, card, effect, target_criterias=None,
# prompts=None):
# def __str__(self):
# def __repr__(self):
# def resolve(self):
# def __init__(self, card, cost, effect, target_criterias=None, prompts=None, is_mana_ability=False):
# def can_activate(self):
# def __init__(self, card, effect, requirements, target_criterias=None,
# prompts=None, intervening_if=None):
# def condition_satisfied(self):
# def put_on_stack(self):
#
# Path: MTG/triggers.py
# class triggerConditions(Enum):
#
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
#
# Path: MTG/utils.py
# def get_card_from_user_input(player, string):
# def choose_targets(source):
# def parse_targets(criterias):
# def parse_ability_costs(cost):
#
# Path: MTG/permanent.py
# class Status():
# class Effect():
# class Permanent(gameobject.GameObject):
# class Aura(Permanent):
# def __init__(self):
# def __repr__(self):
# def __str__(self):
# def reset(self):
# def __init__(self, value, timestamp, apply_target=None, source=None, expiration=math.inf, is_active=True,
# toggle_func=lambda eff: False):
# def __init__(self, characteristics, controller, owner=None, original_card=None,
# status=None, modifications=[]):
# def __repr__(self):
# def __str__(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __hash__(self):
# def activate_ability(self, num=0):
# def add_effect(self, name, value, source=None, expiration=math.inf,
# is_active=True, toggle_func=lambda eff: True):
# def get_effect(self, name):
# def check_effect_expiration(self):
# def tap(self):
# def untap(self):
# def freeze(self):
# def power(self):
# def toughness(self):
# def add_counter(self, counter="+1/+1", num=1):
# def num_counters(self, counter):
# def _calculate_pt(self):
# def is_summoning_sick(self):
# def can_attack(self):
# def can_block(self, attackers=None):
# def attacks(self, player):
# def blocks(self, creature):
# def in_combat(self):
# def exits_combat(self):
# def take_damage(self, source, dmg, is_combat=False):
# def deals_damage(self, target, dmg, is_combat=False):
# def trigger(self, condition, source=None, amount=1):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
# def dies(self):
# def destroy(self):
# def sacrifice(self):
# def exile(self):
# def bounce(self):
# def flicker(self):
# def __init__(self, enchant_target, characteristics, controller, owner=None, original_card=None):
# def enchant(self, target):
# def disenchant(self):
# def add_ability(self, ability):
# def add_pt(self, PT):
# def make_permanent(card, status_mod=None, modi_func=None):
# def make_aura(card, enchant_target):
. Output only the next line. | abilities = [] |
Predict the next line after this snippet: <|code_start|>
def add_aura_effect(cardname, effects, target_criterias=['creature']):
add_targets(cardname, target_criterias)
add_play_func_with_targets(cardname, lambda self, targets, l: permanent.make_aura(self, targets[0]))
# add aura enchant effects
card = card_from_name(cardname, get_instance=False)
card.continuous_effects = effects
def add_trigger(cardname, condition, effect, requirements=None,
target_criterias=None, target_prompts=None, intervening_if=None):
"""
Each effect is a function of the form
lambda self: do_something
It will be passed into the stack as
play.Play(lambda: effect(self))
where self is the source of the trigger (the permanent)
"""
if not name_to_id(cardname):
return
card = card_from_name(cardname, get_instance=False)
if not requirements:
requirements = lambda self: True
# make it a variable specific to card rather than a card.Card class var
# normally, trigger_listeners is defined in card.Card,
# and our parsed card classes just inherit that
<|code_end|>
using the current file's imports:
import sys
import pickle
import math
import re
from collections import namedtuple
from MTG.parsedcards import *
from MTG.exceptions import *
from MTG import abilities
from MTG import triggers
from MTG import mana
from MTG import utils
from MTG import permanent
and any relevant context from other files:
# Path: MTG/abilities.py
# class Ability(gameobject.GameObject):
# class ActivatedAbility(Ability):
# class TriggeredAbility(Ability):
# def __init__(self, card, effect, target_criterias=None,
# prompts=None):
# def __str__(self):
# def __repr__(self):
# def resolve(self):
# def __init__(self, card, cost, effect, target_criterias=None, prompts=None, is_mana_ability=False):
# def can_activate(self):
# def __init__(self, card, effect, requirements, target_criterias=None,
# prompts=None, intervening_if=None):
# def condition_satisfied(self):
# def put_on_stack(self):
#
# Path: MTG/triggers.py
# class triggerConditions(Enum):
#
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
#
# Path: MTG/utils.py
# def get_card_from_user_input(player, string):
# def choose_targets(source):
# def parse_targets(criterias):
# def parse_ability_costs(cost):
#
# Path: MTG/permanent.py
# class Status():
# class Effect():
# class Permanent(gameobject.GameObject):
# class Aura(Permanent):
# def __init__(self):
# def __repr__(self):
# def __str__(self):
# def reset(self):
# def __init__(self, value, timestamp, apply_target=None, source=None, expiration=math.inf, is_active=True,
# toggle_func=lambda eff: False):
# def __init__(self, characteristics, controller, owner=None, original_card=None,
# status=None, modifications=[]):
# def __repr__(self):
# def __str__(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __hash__(self):
# def activate_ability(self, num=0):
# def add_effect(self, name, value, source=None, expiration=math.inf,
# is_active=True, toggle_func=lambda eff: True):
# def get_effect(self, name):
# def check_effect_expiration(self):
# def tap(self):
# def untap(self):
# def freeze(self):
# def power(self):
# def toughness(self):
# def add_counter(self, counter="+1/+1", num=1):
# def num_counters(self, counter):
# def _calculate_pt(self):
# def is_summoning_sick(self):
# def can_attack(self):
# def can_block(self, attackers=None):
# def attacks(self, player):
# def blocks(self, creature):
# def in_combat(self):
# def exits_combat(self):
# def take_damage(self, source, dmg, is_combat=False):
# def deals_damage(self, target, dmg, is_combat=False):
# def trigger(self, condition, source=None, amount=1):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
# def dies(self):
# def destroy(self):
# def sacrifice(self):
# def exile(self):
# def bounce(self):
# def flicker(self):
# def __init__(self, enchant_target, characteristics, controller, owner=None, original_card=None):
# def enchant(self, target):
# def disenchant(self):
# def add_ability(self, ability):
# def add_pt(self, PT):
# def make_permanent(card, status_mod=None, modi_func=None):
# def make_aura(card, enchant_target):
. Output only the next line. | if card.triggers == {}: |
Based on the snippet: <|code_start|> 10 Oreskos Swiftclaw
"""
with open(filename, 'r') as f:
file = f.read().split("\n")
deck = []
for line in file:
try:
i = line.index(" ")
num = int(line[:i])
for j in range(num): # add NUM copies of CARDNAME
card = card_from_name(line[i + 1:])
if card:
deck.append(card)
# print(deck[-1].name)
else:
pass
# print("card {} does not exist\n".format(line[i+1:]))
except:
raise DecklistFormatException
return deck
def add_activated_ability(cardname, cost, effect, target_criterias=None, prompts=None):
if not name_to_id(cardname):
return
card = card_from_name(cardname, get_instance=False)
is_mana_ability = 'mana.add' in effect
<|code_end|>
, predict the immediate next line with the help of imports:
import sys
import pickle
import math
import re
from collections import namedtuple
from MTG.parsedcards import *
from MTG.exceptions import *
from MTG import abilities
from MTG import triggers
from MTG import mana
from MTG import utils
from MTG import permanent
and context (classes, functions, sometimes code) from other files:
# Path: MTG/abilities.py
# class Ability(gameobject.GameObject):
# class ActivatedAbility(Ability):
# class TriggeredAbility(Ability):
# def __init__(self, card, effect, target_criterias=None,
# prompts=None):
# def __str__(self):
# def __repr__(self):
# def resolve(self):
# def __init__(self, card, cost, effect, target_criterias=None, prompts=None, is_mana_ability=False):
# def can_activate(self):
# def __init__(self, card, effect, requirements, target_criterias=None,
# prompts=None, intervening_if=None):
# def condition_satisfied(self):
# def put_on_stack(self):
#
# Path: MTG/triggers.py
# class triggerConditions(Enum):
#
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
#
# Path: MTG/utils.py
# def get_card_from_user_input(player, string):
# def choose_targets(source):
# def parse_targets(criterias):
# def parse_ability_costs(cost):
#
# Path: MTG/permanent.py
# class Status():
# class Effect():
# class Permanent(gameobject.GameObject):
# class Aura(Permanent):
# def __init__(self):
# def __repr__(self):
# def __str__(self):
# def reset(self):
# def __init__(self, value, timestamp, apply_target=None, source=None, expiration=math.inf, is_active=True,
# toggle_func=lambda eff: False):
# def __init__(self, characteristics, controller, owner=None, original_card=None,
# status=None, modifications=[]):
# def __repr__(self):
# def __str__(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __hash__(self):
# def activate_ability(self, num=0):
# def add_effect(self, name, value, source=None, expiration=math.inf,
# is_active=True, toggle_func=lambda eff: True):
# def get_effect(self, name):
# def check_effect_expiration(self):
# def tap(self):
# def untap(self):
# def freeze(self):
# def power(self):
# def toughness(self):
# def add_counter(self, counter="+1/+1", num=1):
# def num_counters(self, counter):
# def _calculate_pt(self):
# def is_summoning_sick(self):
# def can_attack(self):
# def can_block(self, attackers=None):
# def attacks(self, player):
# def blocks(self, creature):
# def in_combat(self):
# def exits_combat(self):
# def take_damage(self, source, dmg, is_combat=False):
# def deals_damage(self, target, dmg, is_combat=False):
# def trigger(self, condition, source=None, amount=1):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
# def dies(self):
# def destroy(self):
# def sacrifice(self):
# def exile(self):
# def bounce(self):
# def flicker(self):
# def __init__(self, enchant_target, characteristics, controller, owner=None, original_card=None):
# def enchant(self, target):
# def disenchant(self):
# def add_ability(self, ability):
# def add_pt(self, PT):
# def make_permanent(card, status_mod=None, modi_func=None):
# def make_aura(card, enchant_target):
. Output only the next line. | costs = utils.parse_ability_costs(cost) |
Given the code snippet: <|code_start|> if not name_to_id(cardname):
return
card = card_from_name(cardname, get_instance=False)
def play_func(self):
legality = self.target_legality()
if any(legality):
outcome(self, self.targets_chosen, legality)
if not self.is_aura:
self.controller.graveyard.add(self)
return True
else:
# no valid target on a spell that requires target
self.controller.graveyard.add(self)
return False
card.play_func = play_func
def add_play_func_no_target(cardname, outcome=lambda self: True):
if not name_to_id(cardname):
return
card = card_from_name(cardname, get_instance=False)
card.play_func = outcome
def add_aura_effect(cardname, effects, target_criterias=['creature']):
add_targets(cardname, target_criterias)
<|code_end|>
, generate the next line using the imports in this file:
import sys
import pickle
import math
import re
from collections import namedtuple
from MTG.parsedcards import *
from MTG.exceptions import *
from MTG import abilities
from MTG import triggers
from MTG import mana
from MTG import utils
from MTG import permanent
and context (functions, classes, or occasionally code) from other files:
# Path: MTG/abilities.py
# class Ability(gameobject.GameObject):
# class ActivatedAbility(Ability):
# class TriggeredAbility(Ability):
# def __init__(self, card, effect, target_criterias=None,
# prompts=None):
# def __str__(self):
# def __repr__(self):
# def resolve(self):
# def __init__(self, card, cost, effect, target_criterias=None, prompts=None, is_mana_ability=False):
# def can_activate(self):
# def __init__(self, card, effect, requirements, target_criterias=None,
# prompts=None, intervening_if=None):
# def condition_satisfied(self):
# def put_on_stack(self):
#
# Path: MTG/triggers.py
# class triggerConditions(Enum):
#
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
#
# Path: MTG/utils.py
# def get_card_from_user_input(player, string):
# def choose_targets(source):
# def parse_targets(criterias):
# def parse_ability_costs(cost):
#
# Path: MTG/permanent.py
# class Status():
# class Effect():
# class Permanent(gameobject.GameObject):
# class Aura(Permanent):
# def __init__(self):
# def __repr__(self):
# def __str__(self):
# def reset(self):
# def __init__(self, value, timestamp, apply_target=None, source=None, expiration=math.inf, is_active=True,
# toggle_func=lambda eff: False):
# def __init__(self, characteristics, controller, owner=None, original_card=None,
# status=None, modifications=[]):
# def __repr__(self):
# def __str__(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __hash__(self):
# def activate_ability(self, num=0):
# def add_effect(self, name, value, source=None, expiration=math.inf,
# is_active=True, toggle_func=lambda eff: True):
# def get_effect(self, name):
# def check_effect_expiration(self):
# def tap(self):
# def untap(self):
# def freeze(self):
# def power(self):
# def toughness(self):
# def add_counter(self, counter="+1/+1", num=1):
# def num_counters(self, counter):
# def _calculate_pt(self):
# def is_summoning_sick(self):
# def can_attack(self):
# def can_block(self, attackers=None):
# def attacks(self, player):
# def blocks(self, creature):
# def in_combat(self):
# def exits_combat(self):
# def take_damage(self, source, dmg, is_combat=False):
# def deals_damage(self, target, dmg, is_combat=False):
# def trigger(self, condition, source=None, amount=1):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
# def dies(self):
# def destroy(self):
# def sacrifice(self):
# def exile(self):
# def bounce(self):
# def flicker(self):
# def __init__(self, enchant_target, characteristics, controller, owner=None, original_card=None):
# def enchant(self, target):
# def disenchant(self):
# def add_ability(self, ability):
# def add_pt(self, PT):
# def make_permanent(card, status_mod=None, modi_func=None):
# def make_aura(card, enchant_target):
. Output only the next line. | add_play_func_with_targets(cardname, lambda self, targets, l: permanent.make_aura(self, targets[0])) |
Using the snippet: <|code_start|>
class c383180(card.Card):
"Ajani Steadfast"
def __init__(self):
<|code_end|>
, determine the next line of code. You have imports:
from MTG import card
from MTG import gameobject
from MTG import cardtype
from MTG import static_abilities
from MTG import mana
and context (class names, function names, or code) available:
# Path: MTG/card.py
# class Attributes():
# class Card(gameobject.GameObject):
# def __init__(self):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None, previousState=None):
# def ID(self):
# def play_func(self): # defaults to permanent
#
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
#
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
. Output only the next line. | super(c383180, self).__init__(gameobject.Characteristics(**{'mana_cost': '3W', 'text': '+1: Until end of turn, up to one target creature gets +1/+1 and gains first strike, vigilance, and lifelink.\n−2: Put a +1/+1 counter on each creature you control and a loyalty counter on each other planeswalker you control.\n−7: You get an emblem with "If a source would deal damage to you or a planeswalker you control, prevent all but 1 of that damage."', 'subtype': ['Ajani'], 'name': 'Ajani Steadfast', 'color': ['W']}, supertype=[], types=[cardtype.CardType.PLANESWALKER], abilities=[static_abilities.StaticAbilities.Vigilance])) |
Here is a snippet: <|code_start|>
class c383180(card.Card):
"Ajani Steadfast"
def __init__(self):
<|code_end|>
. Write the next line using the current file imports:
from MTG import card
from MTG import gameobject
from MTG import cardtype
from MTG import static_abilities
from MTG import mana
and context from other files:
# Path: MTG/card.py
# class Attributes():
# class Card(gameobject.GameObject):
# def __init__(self):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None, previousState=None):
# def ID(self):
# def play_func(self): # defaults to permanent
#
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
#
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
, which may include functions, classes, or code. Output only the next line. | super(c383180, self).__init__(gameobject.Characteristics(**{'mana_cost': '3W', 'text': '+1: Until end of turn, up to one target creature gets +1/+1 and gains first strike, vigilance, and lifelink.\n−2: Put a +1/+1 counter on each creature you control and a loyalty counter on each other planeswalker you control.\n−7: You get an emblem with "If a source would deal damage to you or a planeswalker you control, prevent all but 1 of that damage."', 'subtype': ['Ajani'], 'name': 'Ajani Steadfast', 'color': ['W']}, supertype=[], types=[cardtype.CardType.PLANESWALKER], abilities=[static_abilities.StaticAbilities.Vigilance])) |
Next line prediction: <|code_start|>
class c383180(card.Card):
"Ajani Steadfast"
def __init__(self):
<|code_end|>
. Use current file imports:
(from MTG import card
from MTG import gameobject
from MTG import cardtype
from MTG import static_abilities
from MTG import mana)
and context including class names, function names, or small code snippets from other files:
# Path: MTG/card.py
# class Attributes():
# class Card(gameobject.GameObject):
# def __init__(self):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None, previousState=None):
# def ID(self):
# def play_func(self): # defaults to permanent
#
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
#
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
. Output only the next line. | super(c383180, self).__init__(gameobject.Characteristics(**{'mana_cost': '3W', 'text': '+1: Until end of turn, up to one target creature gets +1/+1 and gains first strike, vigilance, and lifelink.\n−2: Put a +1/+1 counter on each creature you control and a loyalty counter on each other planeswalker you control.\n−7: You get an emblem with "If a source would deal damage to you or a planeswalker you control, prevent all but 1 of that damage."', 'subtype': ['Ajani'], 'name': 'Ajani Steadfast', 'color': ['W']}, supertype=[], types=[cardtype.CardType.PLANESWALKER], abilities=[static_abilities.StaticAbilities.Vigilance])) |
Here is a snippet: <|code_start|> def can_activate(self):
""" choose targets, pays ability's costs, attempt to activate """
cost = self.cost
_card = self.card
targets_chosen = self.choose_targets()
return targets_chosen and (lambda self: eval(cost))(_card)
class TriggeredAbility(Ability):
def __init__(self, card, effect, requirements, target_criterias=None,
prompts=None, intervening_if=None):
super(TriggeredAbility, self).__init__(card, effect, target_criterias, prompts)
self.requirements = requirements
if not intervening_if:
self.intervening_if = lambda self: True
else:
self.intervening_if = intervening_if
self.trigger_amount = 1
self.trigger_source = None
def condition_satisfied(self):
return self.requirements(self) and self.intervening_if(self)
def put_on_stack(self):
if self.choose_targets():
<|code_end|>
. Write the next line using the current file imports:
from enum import Enum
from MTG import mana
from MTG import play
from MTG import gameobject
and context from other files:
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
#
# Path: MTG/play.py
# class Play(gameobject.GameObject):
# def __init__(self, apply_func, apply_condition=lambda: True,
# card=None, source=None, name=None,
# targets_chosen=None, target_criterias=None, is_mana_ability=False):
# def __repr__(self):
# def can_be_countered(self, source=None):
# def counter(self, source):
# def apply(self):
#
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
, which may include functions, classes, or code. Output only the next line. | return play.Play(lambda: self.resolve(), |
Next line prediction: <|code_start|> ID = 'c' + str(card["multiverseid"])
else:
continue
# ID = 'c' + str(card["id"])
name = card["name"]
characteristics = {'name': name}
characteristics['text'] = card["text"] if "text" in card else ''
characteristics['color'] = card["colorIdentity"] if "colorIdentity" in card else ''
characteristics['mana_cost'] = (card["manaCost"].replace('{', '').replace('}', '')
if "manaCost" in card else '')
# types
if "supertypes" in card:
supertype = ('['
+ ', '.join(['cardtype.SuperType.' + i.upper()
for i in card["supertypes"]])
+ ']')
types = '[' + ', '.join(['cardtype.CardType.' + i.upper()
for i in card["types"]]) + ']'
if 'Creature' in card["types"]:
characteristics['power'], characteristics['toughness'] = star_or_int(
card["power"]), star_or_int(card["toughness"])
if "subtypes" in card:
characteristics["subtype"] = card["subtypes"]
# static abilities
texts = characteristics['text'].replace(' ', '_')
<|code_end|>
. Use current file imports:
(import sys
import json
import pickle
from MTG import static_abilities)
and context including class names, function names, or small code snippets from other files:
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
. Output only the next line. | for ability in static_abilities.StaticAbilities._member_names_: |
Given the following code snippet before the placeholder: <|code_start|> p, t = map(int, pt.split('/'))
types = [cardtype.CardType.CREATURE]
if 'artifact' in c_type:
types.append(cardtype.CardType.ARTIFACT)
c_type.remove('artifact')
else:
p, t = None, None
color, *c_type = attributes.split(' ')
types = [cardtype.CardType[c_type.pop().upper()]]
color = {'colorless': 'C',
'white': 'W',
'blue': 'U',
'black': 'B',
'red': 'R',
'green': 'G'}[color]
name = ' '.join(c_type)
print("making token... %s" % attributes)
if isinstance(keyword_abilities, str):
keyword_abilities = [keyword_abilities]
print("with %s" % ' '.join(keyword_abilities))
for ablty in activated_abilities:
ablty[0] = utils.parse_ability_costs(ablty[0])
for i in range(num):
<|code_end|>
, predict the next line using imports from the current file:
import re
from collections import defaultdict
from MTG import permanent
from MTG import gameobject
from MTG import cardtype
from MTG import static_abilities
from MTG import utils
and context including class names, function names, and sometimes code from other files:
# Path: MTG/permanent.py
# class Status():
# class Effect():
# class Permanent(gameobject.GameObject):
# class Aura(Permanent):
# def __init__(self):
# def __repr__(self):
# def __str__(self):
# def reset(self):
# def __init__(self, value, timestamp, apply_target=None, source=None, expiration=math.inf, is_active=True,
# toggle_func=lambda eff: False):
# def __init__(self, characteristics, controller, owner=None, original_card=None,
# status=None, modifications=[]):
# def __repr__(self):
# def __str__(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __hash__(self):
# def activate_ability(self, num=0):
# def add_effect(self, name, value, source=None, expiration=math.inf,
# is_active=True, toggle_func=lambda eff: True):
# def get_effect(self, name):
# def check_effect_expiration(self):
# def tap(self):
# def untap(self):
# def freeze(self):
# def power(self):
# def toughness(self):
# def add_counter(self, counter="+1/+1", num=1):
# def num_counters(self, counter):
# def _calculate_pt(self):
# def is_summoning_sick(self):
# def can_attack(self):
# def can_block(self, attackers=None):
# def attacks(self, player):
# def blocks(self, creature):
# def in_combat(self):
# def exits_combat(self):
# def take_damage(self, source, dmg, is_combat=False):
# def deals_damage(self, target, dmg, is_combat=False):
# def trigger(self, condition, source=None, amount=1):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
# def dies(self):
# def destroy(self):
# def sacrifice(self):
# def exile(self):
# def bounce(self):
# def flicker(self):
# def __init__(self, enchant_target, characteristics, controller, owner=None, original_card=None):
# def enchant(self, target):
# def disenchant(self):
# def add_ability(self, ability):
# def add_pt(self, PT):
# def make_permanent(card, status_mod=None, modi_func=None):
# def make_aura(card, enchant_target):
#
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
#
# Path: MTG/utils.py
# def get_card_from_user_input(player, string):
# def choose_targets(source):
# def parse_targets(criterias):
# def parse_ability_costs(cost):
. Output only the next line. | characteristics = gameobject.Characteristics(name='Token: %s' % name, |
Given snippet: <|code_start|> p, t = None, None
color, *c_type = attributes.split(' ')
types = [cardtype.CardType[c_type.pop().upper()]]
color = {'colorless': 'C',
'white': 'W',
'blue': 'U',
'black': 'B',
'red': 'R',
'green': 'G'}[color]
name = ' '.join(c_type)
print("making token... %s" % attributes)
if isinstance(keyword_abilities, str):
keyword_abilities = [keyword_abilities]
print("with %s" % ' '.join(keyword_abilities))
for ablty in activated_abilities:
ablty[0] = utils.parse_ability_costs(ablty[0])
for i in range(num):
characteristics = gameobject.Characteristics(name='Token: %s' % name,
types=types,
power=p,
toughness=t,
subtype=c_type,
color=[color],
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import re
from collections import defaultdict
from MTG import permanent
from MTG import gameobject
from MTG import cardtype
from MTG import static_abilities
from MTG import utils
and context:
# Path: MTG/permanent.py
# class Status():
# class Effect():
# class Permanent(gameobject.GameObject):
# class Aura(Permanent):
# def __init__(self):
# def __repr__(self):
# def __str__(self):
# def reset(self):
# def __init__(self, value, timestamp, apply_target=None, source=None, expiration=math.inf, is_active=True,
# toggle_func=lambda eff: False):
# def __init__(self, characteristics, controller, owner=None, original_card=None,
# status=None, modifications=[]):
# def __repr__(self):
# def __str__(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __hash__(self):
# def activate_ability(self, num=0):
# def add_effect(self, name, value, source=None, expiration=math.inf,
# is_active=True, toggle_func=lambda eff: True):
# def get_effect(self, name):
# def check_effect_expiration(self):
# def tap(self):
# def untap(self):
# def freeze(self):
# def power(self):
# def toughness(self):
# def add_counter(self, counter="+1/+1", num=1):
# def num_counters(self, counter):
# def _calculate_pt(self):
# def is_summoning_sick(self):
# def can_attack(self):
# def can_block(self, attackers=None):
# def attacks(self, player):
# def blocks(self, creature):
# def in_combat(self):
# def exits_combat(self):
# def take_damage(self, source, dmg, is_combat=False):
# def deals_damage(self, target, dmg, is_combat=False):
# def trigger(self, condition, source=None, amount=1):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
# def dies(self):
# def destroy(self):
# def sacrifice(self):
# def exile(self):
# def bounce(self):
# def flicker(self):
# def __init__(self, enchant_target, characteristics, controller, owner=None, original_card=None):
# def enchant(self, target):
# def disenchant(self):
# def add_ability(self, ability):
# def add_pt(self, PT):
# def make_permanent(card, status_mod=None, modi_func=None):
# def make_aura(card, enchant_target):
#
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
#
# Path: MTG/utils.py
# def get_card_from_user_input(player, string):
# def choose_targets(source):
# def parse_targets(criterias):
# def parse_ability_costs(cost):
which might include code, classes, or functions. Output only the next line. | abilities=[static_abilities.StaticAbilities[a] for a in keyword_abilities]) |
Given snippet: <|code_start|>
class c270446(card.Card):
"Sphinx of the Steel Wind"
def __init__(self):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from MTG import card
from MTG import gameobject
from MTG import cardtype
from MTG import static_abilities
from MTG import mana
and context:
# Path: MTG/card.py
# class Attributes():
# class Card(gameobject.GameObject):
# def __init__(self):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None, previousState=None):
# def ID(self):
# def play_func(self): # defaults to permanent
#
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
#
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
which might include code, classes, or functions. Output only the next line. | super(c270446, self).__init__(gameobject.Characteristics(**{'name': 'Sphinx of the Steel Wind', 'text': 'Flying, first strike, vigilance, lifelink, protection from red and from green', 'color': ['W', 'U', 'B'], 'mana_cost': '5WUB', 'power': 6, 'toughness': 6, 'subtype': ['Sphinx']}, supertype=[], types=[cardtype.CardType.ARTIFACT, cardtype.CardType.CREATURE], abilities=[static_abilities.StaticAbilities.First_Strike, static_abilities.StaticAbilities.Flying, static_abilities.StaticAbilities.Lifelink, static_abilities.StaticAbilities.Vigilance])) |
Given the code snippet: <|code_start|>
class c270446(card.Card):
"Sphinx of the Steel Wind"
def __init__(self):
<|code_end|>
, generate the next line using the imports in this file:
from MTG import card
from MTG import gameobject
from MTG import cardtype
from MTG import static_abilities
from MTG import mana
and context (functions, classes, or occasionally code) from other files:
# Path: MTG/card.py
# class Attributes():
# class Card(gameobject.GameObject):
# def __init__(self):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None, previousState=None):
# def ID(self):
# def play_func(self): # defaults to permanent
#
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
#
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
. Output only the next line. | super(c270446, self).__init__(gameobject.Characteristics(**{'name': 'Sphinx of the Steel Wind', 'text': 'Flying, first strike, vigilance, lifelink, protection from red and from green', 'color': ['W', 'U', 'B'], 'mana_cost': '5WUB', 'power': 6, 'toughness': 6, 'subtype': ['Sphinx']}, supertype=[], types=[cardtype.CardType.ARTIFACT, cardtype.CardType.CREATURE], abilities=[static_abilities.StaticAbilities.First_Strike, static_abilities.StaticAbilities.Flying, static_abilities.StaticAbilities.Lifelink, static_abilities.StaticAbilities.Vigilance])) |
Given snippet: <|code_start|>
class c270446(card.Card):
"Sphinx of the Steel Wind"
def __init__(self):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from MTG import card
from MTG import gameobject
from MTG import cardtype
from MTG import static_abilities
from MTG import mana
and context:
# Path: MTG/card.py
# class Attributes():
# class Card(gameobject.GameObject):
# def __init__(self):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None, previousState=None):
# def ID(self):
# def play_func(self): # defaults to permanent
#
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
#
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
which might include code, classes, or functions. Output only the next line. | super(c270446, self).__init__(gameobject.Characteristics(**{'name': 'Sphinx of the Steel Wind', 'text': 'Flying, first strike, vigilance, lifelink, protection from red and from green', 'color': ['W', 'U', 'B'], 'mana_cost': '5WUB', 'power': 6, 'toughness': 6, 'subtype': ['Sphinx']}, supertype=[], types=[cardtype.CardType.ARTIFACT, cardtype.CardType.CREATURE], abilities=[static_abilities.StaticAbilities.First_Strike, static_abilities.StaticAbilities.Flying, static_abilities.StaticAbilities.Lifelink, static_abilities.StaticAbilities.Vigilance])) |
Given the following code snippet before the placeholder: <|code_start|># from copy import deepcopy
# test cases will fail if this is run
# inside setUpClass, b/c cards get set up multiple times
cards.setup_cards()
class TestGameBase(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.f = open('test_game_time.log', 'w')
@classmethod
def tearDownClass(cls):
cls.f.close()
def setUp(self):
self.startTime = time.time()
decks = [cards.read_deck('data/decks/deck1.txt'),
cards.read_deck('data/decks/deck1.txt')]
<|code_end|>
, predict the next line using imports from the current file:
import mock
import unittest
import time
from MTG import game
from MTG import cards
from MTG import permanent
from MTG.exceptions import *
and context including class names, function names, and sometimes code from other files:
# Path: MTG/game.py
# class Game(object):
# def __init__(self, decks, test=False):
# def timestamp(self):
# def eot_time(self):
# def APNAP(self):
# def opponent(self, player):
# def apply_to_players(self, func):
# def add_static_effect(self, name, value, source, toggle_func):
# def trigger(self, condition, source=None, amount=1):
# def apply_stack_item(self, stack_item):
# def apply_to_zone(self, apply_func, _zone, condition=lambda p: True):
# def apply_to_battlefield(self, apply_func, condition=lambda p: True):
# def apply_state_based_actions(self):
# def any_action():
# def handle_priority(self, step, priority=None):
# def handle_beginning_phase(self, step):
# def handle_main_phase(self, step):
# def handle_combat_phase(self, step):
# def handle_end_phase(self, step):
# def handle_turn(self):
# def print_game_state(self):
# def setup_game(self):
# def run_game(self):
# def start_game():
# GAME = Game(decks)
# GAME_PREVIOUS_STATE = None
#
# Path: MTG/cards.py
# SETPREFIX = ['M15', 'sm_set', 'cube']
# ID = name_to_id(name)
# def id_to_name(ID):
# def name_to_id(name):
# def str_to_class(str):
# def card_from_name(name, get_instance=True):
# def read_deck(filename):
# def add_activated_ability(cardname, cost, effect, target_criterias=None, prompts=None):
# def add_targets(cardname, criterias=[lambda self, p: True], prompts=None):
# def add_play_func_with_targets(cardname, outcome=lambda self, t, l: True):
# def play_func(self):
# def add_play_func_no_target(cardname, outcome=lambda self: True):
# def add_aura_effect(cardname, effects, target_criterias=['creature']):
# def add_trigger(cardname, condition, effect, requirements=None,
# target_criterias=None, target_prompts=None, intervening_if=None):
# def add_static_effect(cardname, apply_to, name, value, toggle_func=lambda eff: False):
# def indentation_lv(s):
# def parse_card_from_lines(lines, log=None):
# def setup_cards(FILES=['data/m15_cards.txt', 'data/cube_cards.txt']):
#
# Path: MTG/permanent.py
# class Status():
# class Effect():
# class Permanent(gameobject.GameObject):
# class Aura(Permanent):
# def __init__(self):
# def __repr__(self):
# def __str__(self):
# def reset(self):
# def __init__(self, value, timestamp, apply_target=None, source=None, expiration=math.inf, is_active=True,
# toggle_func=lambda eff: False):
# def __init__(self, characteristics, controller, owner=None, original_card=None,
# status=None, modifications=[]):
# def __repr__(self):
# def __str__(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __hash__(self):
# def activate_ability(self, num=0):
# def add_effect(self, name, value, source=None, expiration=math.inf,
# is_active=True, toggle_func=lambda eff: True):
# def get_effect(self, name):
# def check_effect_expiration(self):
# def tap(self):
# def untap(self):
# def freeze(self):
# def power(self):
# def toughness(self):
# def add_counter(self, counter="+1/+1", num=1):
# def num_counters(self, counter):
# def _calculate_pt(self):
# def is_summoning_sick(self):
# def can_attack(self):
# def can_block(self, attackers=None):
# def attacks(self, player):
# def blocks(self, creature):
# def in_combat(self):
# def exits_combat(self):
# def take_damage(self, source, dmg, is_combat=False):
# def deals_damage(self, target, dmg, is_combat=False):
# def trigger(self, condition, source=None, amount=1):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
# def dies(self):
# def destroy(self):
# def sacrifice(self):
# def exile(self):
# def bounce(self):
# def flicker(self):
# def __init__(self, enchant_target, characteristics, controller, owner=None, original_card=None):
# def enchant(self, target):
# def disenchant(self):
# def add_ability(self, ability):
# def add_pt(self, PT):
# def make_permanent(card, status_mod=None, modi_func=None):
# def make_aura(card, enchant_target):
. Output only the next line. | self.GAME = game.Game(decks, test=True) |
Predict the next line after this snippet: <|code_start|> with mock.patch('builtins.input', side_effect=[
'__self.discard(-1)',
'__self.add_card_to_hand("Devouring Deep")',
'', '', '', '',
'__self.mana.add(mana.Mana.BLUE, 3)',
'p Devouring Deep', '',
's draw', # go to next turn
's draw',
'', '', '', '', '', '', # skipping to declare_attackers
'0', # attacking w/ Devouring Deep
# check that it's tapped and attacking
'__self.tmp = (self.battlefield.get_card_by_name("Devouring Deep")'
'.status.is_attacking == self.game.players_list[1]'
' and self.battlefield.get_card_by_name("Devouring Deep")'
'.status.tapped)',
's precombat_main',
's precombat_main',
'']):
self.GAME.handle_turn()
self.GAME.current_player = self.player
self.GAME.handle_turn()
self.assertTrue(self.player.tmp)
self.assertTrue(self.player.battlefield.get_card_by_name(
"Devouring Deep").status.tapped)
self.assertFalse(self.player.battlefield.get_card_by_name(
"Devouring Deep").in_combat)
self.assertEqual(self.opponent.life, 19, "incorrect combat damage")
<|code_end|>
using the current file's imports:
import mock
import unittest
import time
from MTG import game
from MTG import cards
from MTG import permanent
from MTG.exceptions import *
and any relevant context from other files:
# Path: MTG/game.py
# class Game(object):
# def __init__(self, decks, test=False):
# def timestamp(self):
# def eot_time(self):
# def APNAP(self):
# def opponent(self, player):
# def apply_to_players(self, func):
# def add_static_effect(self, name, value, source, toggle_func):
# def trigger(self, condition, source=None, amount=1):
# def apply_stack_item(self, stack_item):
# def apply_to_zone(self, apply_func, _zone, condition=lambda p: True):
# def apply_to_battlefield(self, apply_func, condition=lambda p: True):
# def apply_state_based_actions(self):
# def any_action():
# def handle_priority(self, step, priority=None):
# def handle_beginning_phase(self, step):
# def handle_main_phase(self, step):
# def handle_combat_phase(self, step):
# def handle_end_phase(self, step):
# def handle_turn(self):
# def print_game_state(self):
# def setup_game(self):
# def run_game(self):
# def start_game():
# GAME = Game(decks)
# GAME_PREVIOUS_STATE = None
#
# Path: MTG/cards.py
# SETPREFIX = ['M15', 'sm_set', 'cube']
# ID = name_to_id(name)
# def id_to_name(ID):
# def name_to_id(name):
# def str_to_class(str):
# def card_from_name(name, get_instance=True):
# def read_deck(filename):
# def add_activated_ability(cardname, cost, effect, target_criterias=None, prompts=None):
# def add_targets(cardname, criterias=[lambda self, p: True], prompts=None):
# def add_play_func_with_targets(cardname, outcome=lambda self, t, l: True):
# def play_func(self):
# def add_play_func_no_target(cardname, outcome=lambda self: True):
# def add_aura_effect(cardname, effects, target_criterias=['creature']):
# def add_trigger(cardname, condition, effect, requirements=None,
# target_criterias=None, target_prompts=None, intervening_if=None):
# def add_static_effect(cardname, apply_to, name, value, toggle_func=lambda eff: False):
# def indentation_lv(s):
# def parse_card_from_lines(lines, log=None):
# def setup_cards(FILES=['data/m15_cards.txt', 'data/cube_cards.txt']):
#
# Path: MTG/permanent.py
# class Status():
# class Effect():
# class Permanent(gameobject.GameObject):
# class Aura(Permanent):
# def __init__(self):
# def __repr__(self):
# def __str__(self):
# def reset(self):
# def __init__(self, value, timestamp, apply_target=None, source=None, expiration=math.inf, is_active=True,
# toggle_func=lambda eff: False):
# def __init__(self, characteristics, controller, owner=None, original_card=None,
# status=None, modifications=[]):
# def __repr__(self):
# def __str__(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __hash__(self):
# def activate_ability(self, num=0):
# def add_effect(self, name, value, source=None, expiration=math.inf,
# is_active=True, toggle_func=lambda eff: True):
# def get_effect(self, name):
# def check_effect_expiration(self):
# def tap(self):
# def untap(self):
# def freeze(self):
# def power(self):
# def toughness(self):
# def add_counter(self, counter="+1/+1", num=1):
# def num_counters(self, counter):
# def _calculate_pt(self):
# def is_summoning_sick(self):
# def can_attack(self):
# def can_block(self, attackers=None):
# def attacks(self, player):
# def blocks(self, creature):
# def in_combat(self):
# def exits_combat(self):
# def take_damage(self, source, dmg, is_combat=False):
# def deals_damage(self, target, dmg, is_combat=False):
# def trigger(self, condition, source=None, amount=1):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
# def dies(self):
# def destroy(self):
# def sacrifice(self):
# def exile(self):
# def bounce(self):
# def flicker(self):
# def __init__(self, enchant_target, characteristics, controller, owner=None, original_card=None):
# def enchant(self, target):
# def disenchant(self):
# def add_ability(self, ability):
# def add_pt(self, PT):
# def make_permanent(card, status_mod=None, modi_func=None):
# def make_aura(card, enchant_target):
. Output only the next line. | @mock.patch.object(permanent.Permanent, 'take_damage') |
Given snippet: <|code_start|>
class c27255(card.Card):
"Lightning Bolt"
def __init__(self):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from MTG import card
from MTG import gameobject
from MTG import cardtype
from MTG import static_abilities
from MTG import mana
and context:
# Path: MTG/card.py
# class Attributes():
# class Card(gameobject.GameObject):
# def __init__(self):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None, previousState=None):
# def ID(self):
# def play_func(self): # defaults to permanent
#
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
#
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
which might include code, classes, or functions. Output only the next line. | super(c27255, self).__init__(gameobject.Characteristics(**{'text': 'Lightning Bolt deals 3 damage to target creature or player.', 'mana_cost': 'R', 'name': 'Lightning Bolt', 'color': ['R']}, supertype=[], types=[cardtype.CardType.INSTANT], abilities=[])) |
Given snippet: <|code_start|>
class c27255(card.Card):
"Lightning Bolt"
def __init__(self):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from MTG import card
from MTG import gameobject
from MTG import cardtype
from MTG import static_abilities
from MTG import mana
and context:
# Path: MTG/card.py
# class Attributes():
# class Card(gameobject.GameObject):
# def __init__(self):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None, previousState=None):
# def ID(self):
# def play_func(self): # defaults to permanent
#
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
#
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
which might include code, classes, or functions. Output only the next line. | super(c27255, self).__init__(gameobject.Characteristics(**{'text': 'Lightning Bolt deals 3 damage to target creature or player.', 'mana_cost': 'R', 'name': 'Lightning Bolt', 'color': ['R']}, supertype=[], types=[cardtype.CardType.INSTANT], abilities=[])) |
Given snippet: <|code_start|> super(c221309, self).__init__(gameobject.Characteristics(**{'text': 'W', 'mana_cost': '', 'name': 'Plains', 'color': [], 'subtype': ['Plains']}, supertype=[cardtype.SuperType.BASIC], types=[cardtype.CardType.LAND], abilities=[]))
class c221300(card.Card):
"Island"
def __init__(self):
super(c221300, self).__init__(gameobject.Characteristics(**{'text': 'U', 'mana_cost': '', 'name': 'Island', 'color': [], 'subtype': ['Island']}, supertype=[cardtype.SuperType.BASIC], types=[cardtype.CardType.LAND], abilities=[]))
class c221311(card.Card):
"Swamp"
def __init__(self):
super(c221311, self).__init__(gameobject.Characteristics(**{'text': 'B', 'mana_cost': '', 'name': 'Swamp', 'color': [], 'subtype': ['Swamp']}, supertype=[cardtype.SuperType.BASIC], types=[cardtype.CardType.LAND], abilities=[]))
class c221297(card.Card):
"Forest"
def __init__(self):
super(c221297, self).__init__(gameobject.Characteristics(**{'text': 'G', 'mana_cost': '', 'name': 'Forest', 'color': [], 'subtype': ['Forest']}, supertype=[cardtype.SuperType.BASIC], types=[cardtype.CardType.LAND], abilities=[]))
class c983(card.Card):
"Mountain"
def __init__(self):
super(c983, self).__init__(gameobject.Characteristics(**{'text': 'R', 'mana_cost': '', 'name': 'Mountain', 'color': [], 'subtype': ['Mountain']}, supertype=[cardtype.SuperType.BASIC], types=[cardtype.CardType.LAND], abilities=[]))
class c26805(card.Card):
"Tundra Kavu"
def __init__(self):
super(c26805, self).__init__(gameobject.Characteristics(**{'power': 2, 'mana_cost': '2R', 'color': ['R'], 'text': '{T}: Target land becomes a Plains or an Island until end of turn.', 'toughness': 2, 'name': 'Tundra Kavu', 'subtype': ['Kavu']}, supertype=[], types=[cardtype.CardType.CREATURE], abilities=[]))
class c79145(card.Card):
"Hundred-Talon Kami"
def __init__(self):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from MTG import card
from MTG import gameobject
from MTG import cardtype
from MTG import static_abilities
from MTG import mana
and context:
# Path: MTG/card.py
# class Attributes():
# class Card(gameobject.GameObject):
# def __init__(self):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None, previousState=None):
# def ID(self):
# def play_func(self): # defaults to permanent
#
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
#
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
which might include code, classes, or functions. Output only the next line. | super(c79145, self).__init__(gameobject.Characteristics(**{'power': 2, 'mana_cost': '4W', 'color': ['W'], 'text': 'Flying\nSoulshift 4 (When this creature dies, you may return target Spirit card with converted mana cost 4 or less from your graveyard to your hand.)', 'toughness': 3, 'name': 'Hundred-Talon Kami', 'subtype': ['Spirit']}, supertype=[], types=[cardtype.CardType.CREATURE], abilities=[static_abilities.StaticAbilities.Flying])) |
Based on the snippet: <|code_start|> def is_spell(self):
# TODO: what about abilities?
return self.zone.zone_type == 'STACK' if self.zone else False
@property
def name(self):
return self.characteristics.name
@property
def raw_manacost(self):
return self.characteristics.mana_cost
@property
def manacost(self):
cost = self.controller.mana.determine_costs(self.characteristics.mana_cost)
# reduce/add costs
if self.effects['additionalCost']:
pass
for effect in self.effects['reduceCost']:
pass
# TODO
return cost
# @property
# def CMC(self):
@property
def is_land(self):
<|code_end|>
, predict the immediate next line with the help of imports:
import pdb
import time
import math
from collections import defaultdict, namedtuple
from sortedcontainers import SortedListWithKey
from MTG import cardtype
from MTG import static_abilities
from MTG import utils
and context (classes, functions, sometimes code) from other files:
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
#
# Path: MTG/utils.py
# def get_card_from_user_input(player, string):
# def choose_targets(source):
# def parse_targets(criterias):
# def parse_ability_costs(cost):
. Output only the next line. | return cardtype.CardType.LAND in self.characteristics.types |
Predict the next line after this snippet: <|code_start|> def is_artifact(self):
return cardtype.CardType.ARTIFACT in self.characteristics.types
@property
def is_enchantment(self):
return cardtype.CardType.ENCHANTMENT in self.characteristics.types
@property
def is_aura(self):
return self.is_enchantment and 'Aura' in self.characteristics.subtype
@property
def is_equipment(self):
return self.is_artifact and 'Equipment' in self.characteristics.subtype
@property
def power(self):
return self.characteristics.power if self.is_creature else None
@property
def toughness(self):
return self.characteristics.toughness if self.is_creature else None
def has_ability(self, ability):
for effect in self.effects['gainAbility']:
if ability in effect.value:
return True
ability = ability.replace(' ', '_')
<|code_end|>
using the current file's imports:
import pdb
import time
import math
from collections import defaultdict, namedtuple
from sortedcontainers import SortedListWithKey
from MTG import cardtype
from MTG import static_abilities
from MTG import utils
and any relevant context from other files:
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
#
# Path: MTG/utils.py
# def get_card_from_user_input(player, string):
# def choose_targets(source):
# def parse_targets(criterias):
# def parse_ability_costs(cost):
. Output only the next line. | return static_abilities.StaticAbilities[ability] in self.characteristics.abilities |
Predict the next line after this snippet: <|code_start|>
def has_color(self, color):
return color in self.characteristics.color
def is_color(self, color):
""" color is a list"""
return color == self.characteristics.color
@property
def is_monocolored(self):
return len(self.characteristics.color) == 1
@property
def is_multicolored(self):
return len(self.characteristics.color) > 1
@property
def is_colorless(self):
return len(self.characteristics.color) == 0
def has_subtype(self, subtype):
return subtype in self.characteristics.subtype
def exile(self):
self.change_zone(self.owner.exile)
### Targeting ###
def targets(self):
<|code_end|>
using the current file's imports:
import pdb
import time
import math
from collections import defaultdict, namedtuple
from sortedcontainers import SortedListWithKey
from MTG import cardtype
from MTG import static_abilities
from MTG import utils
and any relevant context from other files:
# Path: MTG/cardtype.py
# class SuperType(Enum):
# class CardType(Enum):
# class LandType(Enum):
# BASIC = 0
# LEGENDARY = 1
# SNOW = 2
# WORLD = 3
# ARTIFACT = 0
# CREATURE = 1
# ENCHANTMENT = 2
# INSTANT = 3
# LAND = 4
# PLANESWALKER = 5
# SORCERY = 6
# TRIBAL = 7
# PLAINS = 0
# ISLAND = 1
# SWAMP = 2
# MOUNTAIN = 3
# FOREST = 4
#
# Path: MTG/static_abilities.py
# class StaticAbilities(Enum):
#
# Path: MTG/utils.py
# def get_card_from_user_input(player, string):
# def choose_targets(source):
# def parse_targets(criterias):
# def parse_ability_costs(cost):
. Output only the next line. | targets_chosen = utils.choose_targets(self) |
Predict the next line after this snippet: <|code_start|>
class Attributes():
def __init__(self):
# attributes goes here
self.num_creatures_can_block = 1
<|code_end|>
using the current file's imports:
import traceback
from MTG import gameobject
from MTG import permanent
and any relevant context from other files:
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/permanent.py
# class Status():
# class Effect():
# class Permanent(gameobject.GameObject):
# class Aura(Permanent):
# def __init__(self):
# def __repr__(self):
# def __str__(self):
# def reset(self):
# def __init__(self, value, timestamp, apply_target=None, source=None, expiration=math.inf, is_active=True,
# toggle_func=lambda eff: False):
# def __init__(self, characteristics, controller, owner=None, original_card=None,
# status=None, modifications=[]):
# def __repr__(self):
# def __str__(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __hash__(self):
# def activate_ability(self, num=0):
# def add_effect(self, name, value, source=None, expiration=math.inf,
# is_active=True, toggle_func=lambda eff: True):
# def get_effect(self, name):
# def check_effect_expiration(self):
# def tap(self):
# def untap(self):
# def freeze(self):
# def power(self):
# def toughness(self):
# def add_counter(self, counter="+1/+1", num=1):
# def num_counters(self, counter):
# def _calculate_pt(self):
# def is_summoning_sick(self):
# def can_attack(self):
# def can_block(self, attackers=None):
# def attacks(self, player):
# def blocks(self, creature):
# def in_combat(self):
# def exits_combat(self):
# def take_damage(self, source, dmg, is_combat=False):
# def deals_damage(self, target, dmg, is_combat=False):
# def trigger(self, condition, source=None, amount=1):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
# def dies(self):
# def destroy(self):
# def sacrifice(self):
# def exile(self):
# def bounce(self):
# def flicker(self):
# def __init__(self, enchant_target, characteristics, controller, owner=None, original_card=None):
# def enchant(self, target):
# def disenchant(self):
# def add_ability(self, ability):
# def add_pt(self, PT):
# def make_permanent(card, status_mod=None, modi_func=None):
# def make_aura(card, enchant_target):
. Output only the next line. | class Card(gameobject.GameObject): |
Based on the snippet: <|code_start|>
class Attributes():
def __init__(self):
# attributes goes here
self.num_creatures_can_block = 1
class Card(gameobject.GameObject):
triggers = {}
activated_abilities = []
static_effects = []
continuous_effects = ''
status = None
def __init__(self, characteristics=None,
controller=None, owner=None, zone=None, previousState=None):
super(Card, self).__init__(characteristics,
controller, owner, zone, previousState)
self.attributes = Attributes()
def ID(self):
pass
def play_func(self): # defaults to permanent
<|code_end|>
, predict the immediate next line with the help of imports:
import traceback
from MTG import gameobject
from MTG import permanent
and context (classes, functions, sometimes code) from other files:
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/permanent.py
# class Status():
# class Effect():
# class Permanent(gameobject.GameObject):
# class Aura(Permanent):
# def __init__(self):
# def __repr__(self):
# def __str__(self):
# def reset(self):
# def __init__(self, value, timestamp, apply_target=None, source=None, expiration=math.inf, is_active=True,
# toggle_func=lambda eff: False):
# def __init__(self, characteristics, controller, owner=None, original_card=None,
# status=None, modifications=[]):
# def __repr__(self):
# def __str__(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __hash__(self):
# def activate_ability(self, num=0):
# def add_effect(self, name, value, source=None, expiration=math.inf,
# is_active=True, toggle_func=lambda eff: True):
# def get_effect(self, name):
# def check_effect_expiration(self):
# def tap(self):
# def untap(self):
# def freeze(self):
# def power(self):
# def toughness(self):
# def add_counter(self, counter="+1/+1", num=1):
# def num_counters(self, counter):
# def _calculate_pt(self):
# def is_summoning_sick(self):
# def can_attack(self):
# def can_block(self, attackers=None):
# def attacks(self, player):
# def blocks(self, creature):
# def in_combat(self):
# def exits_combat(self):
# def take_damage(self, source, dmg, is_combat=False):
# def deals_damage(self, target, dmg, is_combat=False):
# def trigger(self, condition, source=None, amount=1):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
# def dies(self):
# def destroy(self):
# def sacrifice(self):
# def exile(self):
# def bounce(self):
# def flicker(self):
# def __init__(self, enchant_target, characteristics, controller, owner=None, original_card=None):
# def enchant(self, target):
# def disenchant(self):
# def add_ability(self, ability):
# def add_pt(self, PT):
# def make_permanent(card, status_mod=None, modi_func=None):
# def make_aura(card, enchant_target):
. Output only the next line. | permanent.make_permanent(self) |
Given the code snippet: <|code_start|># mana payment
class TestManaPayment(unittest.TestCase):
@classmethod
def setUpClass(cls):
<|code_end|>
, generate the next line using the imports in this file:
import mock
import unittest
from collections import defaultdict
from MTG import mana
from MTG import player
and context (functions, classes, or occasionally code) from other files:
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
#
# Path: MTG/player.py
# class Player():
# def __init__(self, deck, name='player',
# startingLife=20, maxHandSize=7, game=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def is_active(self):
# def opponent(self):
# def creatures(self):
# def lands(self):
# def stack(self):
# def get_zone(self, zone_type):
# def get_action(self):
# def make_choice(self, prompt_string):
# def make_choice_items_in_list(self, items, num=1, up_to=False, repetition=False):
# def add_static_effect(self, name, value, source, toggle_func, exempt_source=False):
# def remove_static_effect(self, source):
# def trigger(self, condition, source=None, amount=1):
# def f(p):
# def f(p):
# def play_card(self, card):
# def draw(self, num=1):
# def add_card_to_hand(self, card):
# def search_lib(self, criteria_funcs, num=1, target_zone='hand', todo_func=None, face_up=True):
# def discard(self, num=1, down_to=None, rand=False):
# def mill(self, num=1):
# def create_token(self, attributes, num=1, keyword_abilities=[], activated_abilities=[]):
# def investigate(self, num=1):
# def boolster(self, num=1):
# def sacrifice(self, num=1, filter_func=lambda p: p.is_creature):
# def pay(self, mana=None, life=0):
# def take_damage(self, source, dmg, is_combat=False):
# def gain_life(self, amount):
# def lose_life(self, amount):
# def set_life_total(self, value):
# def end_turn(self):
# def controls(self, subtype=None, types=None, supertype=None):
# def apply_to_zone(self, apply_func, zone, condition=lambda p: True):
# def apply_to_battlefield(self, apply_func, condition=lambda p: True):
# def lose(self):
# def print_player_state(self):
# PLAYER_PREVIOUS_STATE = deepcopy(self)
. Output only the next line. | cls.m = mana.ManaPool() |
Given snippet: <|code_start|># mana payment
class TestManaPayment(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.m = mana.ManaPool()
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import mock
import unittest
from collections import defaultdict
from MTG import mana
from MTG import player
and context:
# Path: MTG/mana.py
# class Mana(Enum):
# class ManaPool():
# WHITE = 0
# BLUE = 1
# BLACK = 2
# RED = 3
# GREEN = 4
# COLORLESS = 5
# GENERIC = 6
# def str_to_mana_dict(manacost):
# def chr_to_mana(c):
# def __init__(self, controller=None):
# def add(self, mana, amount=1):
# def add_str(self, mana_str):
# def pay(self, manacost):
# def is_empty(self):
# def determine_costs(self, manacost):
# def canPay(self, manacost, convoke=False):
# def clear(self):
# def __repr__(self):
#
# Path: MTG/player.py
# class Player():
# def __init__(self, deck, name='player',
# startingLife=20, maxHandSize=7, game=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def is_active(self):
# def opponent(self):
# def creatures(self):
# def lands(self):
# def stack(self):
# def get_zone(self, zone_type):
# def get_action(self):
# def make_choice(self, prompt_string):
# def make_choice_items_in_list(self, items, num=1, up_to=False, repetition=False):
# def add_static_effect(self, name, value, source, toggle_func, exempt_source=False):
# def remove_static_effect(self, source):
# def trigger(self, condition, source=None, amount=1):
# def f(p):
# def f(p):
# def play_card(self, card):
# def draw(self, num=1):
# def add_card_to_hand(self, card):
# def search_lib(self, criteria_funcs, num=1, target_zone='hand', todo_func=None, face_up=True):
# def discard(self, num=1, down_to=None, rand=False):
# def mill(self, num=1):
# def create_token(self, attributes, num=1, keyword_abilities=[], activated_abilities=[]):
# def investigate(self, num=1):
# def boolster(self, num=1):
# def sacrifice(self, num=1, filter_func=lambda p: p.is_creature):
# def pay(self, mana=None, life=0):
# def take_damage(self, source, dmg, is_combat=False):
# def gain_life(self, amount):
# def lose_life(self, amount):
# def set_life_total(self, value):
# def end_turn(self):
# def controls(self, subtype=None, types=None, supertype=None):
# def apply_to_zone(self, apply_func, zone, condition=lambda p: True):
# def apply_to_battlefield(self, apply_func, condition=lambda p: True):
# def lose(self):
# def print_player_state(self):
# PLAYER_PREVIOUS_STATE = deepcopy(self)
which might include code, classes, or functions. Output only the next line. | cls.m.controller = player.Player([]) |
Here is a snippet: <|code_start|>
class Play(gameobject.GameObject):
"""
Represents an ability or spell on the stack.
Spells: card = original card
Abilities: source = card that owns this ability
"""
# TODO: unify this with gameObject init (particularly with targetting)
def __init__(self, apply_func, apply_condition=lambda: True,
card=None, source=None, name=None,
targets_chosen=None, target_criterias=None, is_mana_ability=False):
# TODO: okay this is really ugly and bug-prone.
# Think about how to fix this initialization.
if card:
controller = card.controller
elif source:
controller = source.controller
else:
controller = None
<|code_end|>
. Write the next line using the current file imports:
import inspect
from MTG import gameobject
from MTG import zone
and context from other files:
# Path: MTG/gameobject.py
# class Characteristics():
# class GameObject():
# def __init__(self,
# name='',
# mana_cost='',
# color=[],
# types=[],
# subtype=[],
# supertype=[],
# text='',
# abilities=[],
# power=None,
# toughness=None,
# loyalty=None):
# def __repr__(self):
# def satisfy(self, criteria):
# def __init__(self, characteristics=None,
# controller=None, owner=None, zone=None,
# previousState=None):
# def __repr__(self):
# def __str__(self):
# def __eq__(x, y):
# def __hash__(self):
# def owner(self):
# def game(self):
# def is_permanent(self):
# def is_spell(self):
# def name(self):
# def raw_manacost(self):
# def manacost(self):
# def is_land(self):
# def is_basic_land(self):
# def is_creature(self):
# def is_instant(self):
# def is_sorcery(self):
# def is_artifact(self):
# def is_enchantment(self):
# def is_aura(self):
# def is_equipment(self):
# def power(self):
# def toughness(self):
# def has_ability(self, ability):
# def share_color(self, other):
# def has_color(self, color):
# def is_color(self, color):
# def is_monocolored(self):
# def is_multicolored(self):
# def is_colorless(self):
# def has_subtype(self, subtype):
# def exile(self):
# def targets(self):
# def target_legality(self):
# def has_valid_target(self):
# def choose_targets(self):
# def change_zone(self, target_zone, from_top=0, shuffle=True,
# status_mod=None, modi_func=None):
#
# Path: MTG/zone.py
# class ZoneType(Enum):
# class Zone():
# class Battlefield(Zone):
# class Stack(Zone):
# class Hand(Zone):
# class Graveyard(Zone):
# class Exile(Zone):
# class Library(Zone):
# LIBRARY = 0
# HAND = 1
# BATTLEFIELD = 2
# GRAVEYARD = 3
# STACK = 4
# EXILE = 5
# def str_to_zone_type(z):
# def __init__(self, controller=None, elements: list=None):
# def __repr__(self):
# def __str__(self):
# def __len__(self):
# def __bool__(self):
# def __getitem__(self, pos):
# def isEmpty(self):
# def add(self, obj):
# def remove(self, obj):
# def filter(self, characteristics=None, filter_func=None):
# def count(self, characteristics=None, filter_func=None):
# def get_card_by_name(self, name):
# def pop(self, pos=-1):
# def clear(self):
# def add(self, obj, status_mod=None, modi_func=None):
# def shuffle(self):
# def __init__(self, controller=None, elements: list=None):
# def add(self, obj, from_top=0, shuffle=True):
# def remove(self, obj, shuffle=False):
, which may include functions, classes, or code. Output only the next line. | super().__init__(zone=controller.stack if controller else None, |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.