Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Here is a snippet: <|code_start|> def __init__(self, right_platform, attack=True):
self.right_platform = right_platform
self.interruptible = True
self.attack = attack
def step(self, gamestate, smashbot_state, opponent_state):
if self.logger:
self.logger.log("Notes", " right side platform: " + str(self.right_platform) + " ", concat=True)
platform_center = 0
platform_height, platform_left, platform_right = melee.side_platform_position(self.right_platform, gamestate.stage)
if platform_height is not None:
platform_center = (platform_left + platform_right) / 2
top_platform_height, _, _ = melee.top_platform_position(gamestate.stage)
# Where to dash dance to
pivot_point = platform_center
# If opponent is on the platform, get right under them
if platform_left < opponent_state.position.x < platform_right:
pivot_point = opponent_state.position.x
# Unless we don't need to attack them, then it's safe to just board asap
if not self.attack and (platform_left+2 < smashbot_state.position.x < platform_right-2):
pivot_point = smashbot_state.position.x
# If we're just using the side platform as a springboard, then go closer in than the middle
if top_platform_height is not None and (opponent_state.position.y >= top_platform_height):
if smashbot_state.position.x > 0:
pivot_point = platform_left + 8
<|code_end|>
. Write the next line using the current file imports:
import melee
import random
from Chains.chain import Chain
from melee.enums import Action, Button
and context from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
, which may include functions, classes, or code. Output only the next line. | else: |
Continue the code snippet: <|code_start|> controller.empty_input()
return
isshielding = smashbot_state.action == Action.SHIELD \
or smashbot_state.action == Action.SHIELD_START \
or smashbot_state.action == Action.SHIELD_REFLECT \
or smashbot_state.action == Action.SHIELD_STUN \
or smashbot_state.action == Action.SHIELD_RELEASE
# If we're in shield stun, we can let go
if smashbot_state.action == Action.SHIELD_STUN:
if smashbot_state.hitlag_left > 0:
self.interruptible = False
controller.release_button(Button.BUTTON_A)
controller.release_button(Button.BUTTON_Z)
controller.release_button(Button.BUTTON_L)
if controller.prev.main_stick[0] == 0.5:
if self.direction is None:
# Can we be in shine range after the hitlag?
di_distance = 3.96 * (smashbot_state.hitlag_left // 2)
shine_range = 11.8
shield_slide = 10
sdi_in = abs(opponent_state.position.x - smashbot_state.position.x) < di_distance + shine_range - shield_slide
if opponent_state.off_stage:
sdi_in = False
if sdi_in:
self.direction = int(opponent_state.position.x > smashbot_state.position.x)
else:
self.direction = int(opponent_state.position.x < smashbot_state.position.x)
controller.tilt_analog(Button.BUTTON_MAIN, self.direction, 0.5)
<|code_end|>
. Use current file imports:
import melee
from melee.enums import Action, Button, Character
from Chains.chain import Chain
and context (classes, functions, or code) from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | else: |
Here is a snippet: <|code_start|>
# Causes an empty_input if hitting left did not cause Smashbot to be TURNING or DASHING left, i.e. if Smashbot attempts a dashback during frames 1-3 of initial dash forward.
if (self.controller.prev.main_stick[0] == 0) and (smashbot_state.action == Action.DASHING and smashbot_state.facing):
self.controller.tilt_analog(melee.Button.BUTTON_MAIN, 0.5, 0.5)
return
if smashbot_state.action == Action.ON_HALO_WAIT:
self.controller.tilt_analog(melee.Button.BUTTON_MAIN, 0.5, 0)
return
if smashbot_state.action in [Action.LYING_GROUND_UP, Action.LYING_GROUND_DOWN]:
roll = random.randint(0, 3)
if roll <= 1:
self.controller.tilt_analog(melee.Button.BUTTON_MAIN, 0.5, 1)
return
elif roll == 2:
self.controller.tilt_analog(melee.Button.BUTTON_MAIN, 1, 0.5)
return
else:
self.controller.tilt_analog(melee.Button.BUTTON_MAIN, 0, 0.5)
return
# If we're in spotdodge or shield, do nothing
if smashbot_state.action in [Action.SPOTDODGE, Action.SHIELD_RELEASE]:
self.controller.empty_input()
return
# If we're stuck wavedashing, just hang out and do nothing
if smashbot_state.action == Action.LANDING_SPECIAL and smashbot_state.action_frame < 28:
<|code_end|>
. Write the next line using the current file imports:
import melee
import random
from Chains.chain import Chain
from melee.enums import Action, Button
and context from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
, which may include functions, classes, or code. Output only the next line. | self.controller.empty_input() |
Given snippet: <|code_start|>
#If we can't interrupt the chain, just continue it
if self.chain != None and not self.chain.interruptible:
self.chain.step(gamestate, smashbot_state, opponent_state)
return
if self.dashdance:
self.chain = None
# Don't try to dashdance if we know we can't
if smashbot_state.action in [Action.DOWN_B_GROUND_START, Action.DOWN_B_GROUND]:
distance = max(gamestate.distance / 20, 1)
self.pickchain(Chains.Wavedash, [distance])
return
self.pickchain(Chains.DashDance, [opponent_state.position.x])
return
# Keep a running count of how many shines we've done
if smashbot_state.action == Action.DOWN_B_GROUND_START and \
smashbot_state.action_frame == 2:
self.shinecount += 1
canshine = smashbot_state.action in [Action.TURNING, Action.STANDING, Action.WALK_SLOW, Action.WALK_MIDDLE, \
Action.WALK_FAST, Action.EDGE_TEETERING_START, Action.EDGE_TEETERING, Action.CROUCHING, \
Action.RUNNING, Action.DOWN_B_STUN, Action.DOWN_B_GROUND_START, Action.DOWN_B_GROUND, Action.KNEE_BEND]
candash = smashbot_state.action in [Action.DASHING, Action.TURNING, Action.RUNNING, \
Action.EDGE_TEETERING_START, Action.EDGE_TEETERING]
inshinerange = gamestate.distance < 11.80-3
# Where will opponent end up, after sliding is accounted for? (at the end of our grab)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import melee
import Chains
import random
from melee.enums import Action, Button
from Tactics.tactic import Tactic
from Chains.grabandthrow import THROW_DIRECTION
and context:
# Path: Chains/grabandthrow.py
# class THROW_DIRECTION(Enum):
# UP = 0
# DOWN = 1
# FORWARD = 2
# BACK = 3
which might include code, classes, or functions. Output only the next line. | endposition = opponent_state.position.x + self.framedata.slide_distance(opponent_state, opponent_state.speed_ground_x_self, 7) |
Next line prediction: <|code_start|>
# Edgestall
class Edgestall(Chain):
def step(self, gamestate, smashbot_state, opponent_state):
controller = self.controller
# If we just grabbed the edge, wait
if smashbot_state.action == Action.EDGE_CATCHING:
<|code_end|>
. Use current file imports:
(import melee
from melee.enums import Action, Button
from Chains.chain import Chain)
and context including class names, function names, or small code snippets from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | self.interruptible = True |
Next line prediction: <|code_start|>
class SD(Chain):
def step(self, gamestate, smashbot_state, opponent_state):
self.interruptible = True
if smashbot_state.action in [Action.FALLING, Action.ON_HALO_WAIT]:
self.controller.tilt_analog(Button.BUTTON_MAIN, .5, 0)
return
landingactionable = smashbot_state.action == Action.LANDING and smashbot_state.action_frame > 4
if smashbot_state.action in [Action.WALK_SLOW, Action.WALK_MIDDLE, Action.WALK_FAST, Action.CROUCH_START, Action.CROUCHING, Action.LANDING_SPECIAL] or landingactionable:
self.controller.empty_input()
return
onright = smashbot_state.position.x > 0
if onright:
<|code_end|>
. Use current file imports:
(import melee
from melee.enums import Action, Button
from Chains.chain import Chain)
and context including class names, function names, or small code snippets from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | self.controller.tilt_analog(Button.BUTTON_MAIN, 1, 0.5) |
Predict the next line for this snippet: <|code_start|> self.interruptible = True
controller.release_all()
return
# Drop down with a fastfall
if smashbot_state.action == Action.EDGE_HANGING:
self.interruptible = False
if self.controller.prev.c_stick[0] != 0.5:
controller.release_all()
return
controller.tilt_analog(melee.Button.BUTTON_C, int(not smashbot_state.facing), 0.5)
return
# Do the shine
if gamestate.distance < 11.8:
self.interruptible = True
controller.tilt_analog(melee.Button.BUTTON_MAIN, 0.5, 0)
controller.press_button(Button.BUTTON_B)
return
# End the chain if opponent is above us
elif opponent_state.position.y > smashbot_state.position.y:
self.interruptible = True
controller.release_all()
return
# Fastfall if we aren't already
# Fastfall speed is 3.4, but we need a little wiggle room
if smashbot_state.action == Action.FALLING and smashbot_state.speed_y_self > -3.35:
self.interruptible = False
<|code_end|>
with the help of current file imports:
import melee
from melee.enums import Action, Button, Character
from Chains.chain import Chain
and context from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
, which may contain function names, class names, or code. Output only the next line. | controller.tilt_analog(melee.Button.BUTTON_MAIN, 0.5, 0) |
Using the snippet: <|code_start|> endposition += self.framedata.slide_distance(opponent_state, speed, framesleft)
# But don't go off the end of the stage
if opponent_state.action in [Action.TECH_MISS_DOWN, Action.TECH_MISS_UP, Action.NEUTRAL_TECH]:
if abs(endposition) > melee.stages.EDGE_GROUND_POSITION[gamestate.stage]:
slideoff = True
endposition = max(endposition, -melee.stages.EDGE_GROUND_POSITION[gamestate.stage])
endposition = min(endposition, melee.stages.EDGE_GROUND_POSITION[gamestate.stage])
# And we're in range...
# Take our sliding into account
slidedistance = self.framedata.slide_distance(smashbot_state, smashbot_state.speed_ground_x_self, framesleft)
smashbot_endposition = slidedistance + smashbot_state.position.x
# Do we have to consider character pushing?
# Are we between the character's current and predicted position?
if opponent_state.position.x < smashbot_endposition < endposition or \
opponent_state.position.x > smashbot_endposition > endposition:
# Add a little bit of push distance along that path
# 0.3 pushing for max of 16 frames
#TODO Needs work here
onleft = smashbot_state.position.x < opponent_state.position.x
if onleft:
smashbot_endposition -= 4.8
else:
smashbot_endposition += 4.8
if self.logger:
self.logger.log("Notes", "endposition: " + str(endposition) + " ", concat=True)
<|code_end|>
, determine the next line of code. You have imports:
import melee
import Chains
import math
from melee.enums import Action, Button, Character
from Tactics.tactic import Tactic
from Chains.smashattack import SMASH_DIRECTION
from Chains.shffl import SHFFL_DIRECTION
from Chains.shieldaction import SHIELD_ACTION
and context (class names, function names, or code) available:
# Path: Chains/smashattack.py
# class SMASH_DIRECTION(Enum):
# UP = 0
# DOWN = 1
# LEFT = 2
# RIGHT = 3
#
# Path: Chains/shffl.py
# class SHFFL_DIRECTION(Enum):
# UP = 0
# DOWN = 1
# FORWARD = 2
# BACK = 3
# NEUTRAL = 4
#
# Path: Chains/shieldaction.py
# class SHIELD_ACTION(Enum):
# PSSHINE = 0
# PSUTILT = 1
# PSDTILT = 2
# PSJAB = 3
. Output only the next line. | self.logger.log("Notes", "smashbot_endposition: " + str(smashbot_endposition) + " ", concat=True) |
Predict the next line for this snippet: <|code_start|> if opponent_state.hitstun_frames_left > 0:
# Special case here for lying on the ground.
# For some reason, the hitstun count is totally wrong for these actions
if opponent_state.action in [Action.LYING_GROUND_UP, Action.LYING_GROUND_DOWN]:
return 1
# If opponent is in the air, we need to cap the return at when they will hit the ground
if opponent_state.position.y > .02 or not opponent_state.on_ground:
# When will they land?
speed = opponent_state.speed_y_attack + opponent_state.speed_y_self
height = opponent_state.position.y
gravity = framedata.characterdata[opponent_state.character]["Gravity"]
termvelocity = framedata.characterdata[opponent_state.character]["TerminalVelocity"]
count = 0
while height > 0:
height += speed
speed -= gravity
speed = max(speed, -termvelocity)
count += 1
# Shortcut if we get too far
if count > 120:
break
return min(count, opponent_state.hitstun_frames_left)
return opponent_state.hitstun_frames_left
# Exception for Jigglypuff rollout
# The action frames are weird for this action, and Jiggs is actionable during it in 1 frame
if opponent_state.character == Character.JIGGLYPUFF and \
opponent_state.action in [Action.SWORD_DANCE_1, Action.NEUTRAL_B_FULL_CHARGE_AIR, Action.SWORD_DANCE_4_LOW, \
<|code_end|>
with the help of current file imports:
import melee
import Chains
import math
from melee.enums import Action, Button, Character
from Tactics.tactic import Tactic
from Chains.smashattack import SMASH_DIRECTION
from Chains.shffl import SHFFL_DIRECTION
from Chains.shieldaction import SHIELD_ACTION
and context from other files:
# Path: Chains/smashattack.py
# class SMASH_DIRECTION(Enum):
# UP = 0
# DOWN = 1
# LEFT = 2
# RIGHT = 3
#
# Path: Chains/shffl.py
# class SHFFL_DIRECTION(Enum):
# UP = 0
# DOWN = 1
# FORWARD = 2
# BACK = 3
# NEUTRAL = 4
#
# Path: Chains/shieldaction.py
# class SHIELD_ACTION(Enum):
# PSSHINE = 0
# PSUTILT = 1
# PSDTILT = 2
# PSJAB = 3
, which may contain function names, class names, or code. Output only the next line. | Action.SWORD_DANCE_4_MID, Action.SWORD_DANCE_3_LOW]: |
Continue the code snippet: <|code_start|> # Can't punish opponent in shield
shieldactions = [Action.SHIELD_START, Action.SHIELD, Action.SHIELD_RELEASE, \
Action.SHIELD_STUN, Action.SHIELD_REFLECT]
if opponent_state.action in shieldactions:
return False
if smashbot_state.off_stage or opponent_state.off_stage:
return False
firefox = opponent_state.action == Action.SWORD_DANCE_3_LOW and opponent_state.character in [Character.FOX, Character.FALCO]
if firefox and opponent_state.position.y > 15:
return False
left = Punish.framesleft(opponent_state, framedata, smashbot_state)
# Will our opponent be invulnerable for the entire punishable window?
if left <= opponent_state.invulnerability_left:
return False
if left < 1:
return False
if framedata.is_roll(opponent_state.character, opponent_state.action):
return True
# Don't punish if the vertical difference is too great.
if abs(smashbot_state.position.y - opponent_state.position.y) > 10:
return False
# Can we shine right now without any movement?
shineablestates = [Action.TURNING, Action.STANDING, Action.WALK_SLOW, Action.WALK_MIDDLE, \
<|code_end|>
. Use current file imports:
import melee
import Chains
import math
from melee.enums import Action, Button, Character
from Tactics.tactic import Tactic
from Chains.smashattack import SMASH_DIRECTION
from Chains.shffl import SHFFL_DIRECTION
from Chains.shieldaction import SHIELD_ACTION
and context (classes, functions, or code) from other files:
# Path: Chains/smashattack.py
# class SMASH_DIRECTION(Enum):
# UP = 0
# DOWN = 1
# LEFT = 2
# RIGHT = 3
#
# Path: Chains/shffl.py
# class SHFFL_DIRECTION(Enum):
# UP = 0
# DOWN = 1
# FORWARD = 2
# BACK = 3
# NEUTRAL = 4
#
# Path: Chains/shieldaction.py
# class SHIELD_ACTION(Enum):
# PSSHINE = 0
# PSUTILT = 1
# PSDTILT = 2
# PSJAB = 3
. Output only the next line. | Action.WALK_FAST, Action.EDGE_TEETERING_START, Action.EDGE_TEETERING, Action.CROUCHING, \ |
Given the following code snippet before the placeholder: <|code_start|>
class Run(Chain):
def __init__(self, rundirection):
self.rundirection = rundirection
def step(self, gamestate, smashbot_state, opponent_state):
#If we're starting the turn around animation, keep pressing that way or
# else we'll get stuck in the slow turnaround
if smashbot_state.action == Action.TURNING and smashbot_state.action_frame == 1:
return
controller = self.controller
if smashbot_state.action in [Action.SHIELD_REFLECT, Action.SHIELD_STUN]:
<|code_end|>
, predict the next line using imports from the current file:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
and context including class names, function names, and sometimes code from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | self.interruptible = True |
Using the snippet: <|code_start|>
class Glide(Chain):
def __init__(self, pivot_point):
self.pivot_point = pivot_point
def step(self, gamestate, smashbot_state, opponent_state):
controller = self.controller
self.interruptible = True
if gamestate.frame % 2 == 0:
x = 0.4
if smashbot_state.position.x < self.pivot_point:
x = 0.6
<|code_end|>
, determine the next line of code. You have imports:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
and context (class names, function names, or code) available:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | controller.tilt_analog(Button.BUTTON_MAIN, x, 0.5) |
Next line prediction: <|code_start|>
# Shine turnaround
if smashbot_state.action == Action.DOWN_B_STUN and not facinginwards:
self.interruptible = False
controller.tilt_analog(melee.Button.BUTTON_MAIN, int(not smashbot_state.facing), .5)
return
# Jump out of shine
if smashbot_state.action == Action.DOWN_B_AIR and facinginwards:
self.interruptible = False
controller.release_button(Button.BUTTON_B)
controller.tilt_analog(Button.BUTTON_MAIN, 0.5, 0.5)
if controller.prev.button[Button.BUTTON_Y]:
controller.release_button(Button.BUTTON_Y)
return
else:
controller.press_button(Button.BUTTON_Y)
return
# Firefox to grab edge
if smashbot_state.action == Action.JUMPING_ARIAL_FORWARD:
# Must be between 0 and -10
inxrange = -10 < (abs(edge_x) - abs(smashbot_state.position.x)) < 0
if -15 < smashbot_state.position.y < -5 and inxrange:
self.interruptible = False
controller.press_button(Button.BUTTON_B)
controller.tilt_analog(melee.Button.BUTTON_MAIN, 0.5, 1)
return
else:
self.interruptible = False
<|code_end|>
. Use current file imports:
(import melee
from melee.enums import Action, Button, Character
from Chains.chain import Chain)
and context including class names, function names, or small code snippets from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | controller.empty_input() |
Predict the next line after this snippet: <|code_start|> controller.tilt_analog(Button.BUTTON_MAIN, 0.5, 1)
controller.press_button(Button.BUTTON_B)
return
self.interruptible = False
controller.empty_input()
return
# If we are able to let go of the edge, do it
if smashbot_state.action == Action.EDGE_HANGING:
# If we already pressed back last frame, let go
if controller.prev.c_stick != (0.5, 0.5):
controller.empty_input()
return
self.interruptible = False
self.letgoframe = gamestate.frame
controller.tilt_analog(Button.BUTTON_C, int(smashbot_state.position.x > 0), 0.5)
return
# Once we're falling, jump
if smashbot_state.action == Action.FALLING:
self.interruptible = False
controller.tilt_analog(Button.BUTTON_MAIN, int(smashbot_state.position.x < 0), 0.5)
controller.press_button(Button.BUTTON_Y)
controller.tilt_analog(Button.BUTTON_C, 0.5, 0.5)
return
# Jumping, stay in the chain and DI in
if smashbot_state.action == Action.JUMPING_ARIAL_FORWARD:
# Wait until we're at least 0.25 above stage, or else we'll miss
<|code_end|>
using the current file's imports:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
and any relevant context from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | if smashbot_state.position.y + smashbot_state.ecb.bottom.y > 0.25: |
Predict the next line for this snippet: <|code_start|>
class Mitigate(Tactic):
def __init__(self, logger, controller, framedata, difficulty):
Tactic.__init__(self, logger, controller, framedata, difficulty)
self.random_di = random.randint(0, 1)
<|code_end|>
with the help of current file imports:
import melee
import Chains
import random
from melee.enums import Action, Button, Character
from Tactics.tactic import Tactic
from Chains.firefox import FIREFOX
and context from other files:
# Path: Chains/firefox.py
# class FIREFOX(Enum):
# HIGH = 0
# EDGE = 1
# HORIZONTAL = 2
# RANDOM = 3
# # Added SAFERANDOM option so Smashbot wouldn't random a straight horizontal upB and SD below the stage
# SAFERANDOM = 4
, which may contain function names, class names, or code. Output only the next line. | def needsmitigation(smashbot_state): |
Given the code snippet: <|code_start|>
# Don't multishine off the stage
if abs(abs(smashbot_state.position.x) - melee.stages.EDGE_GROUND_POSITION[gamestate.stage]) < 10:
self.direction = MULTISHINE_DIRECTION.NEUTRAL
# Pivot if we're dashing. Or else we might dash right off stage, which is annoying
if smashbot_state.action in [Action.DASHING]:
self.interruptible = True
controller.tilt_analog(Button.BUTTON_MAIN, int(not smashbot_state.facing), 0.5)
return
actionable_landing = smashbot_state.action == Action.LANDING and smashbot_state.action_frame >= 4
#If standing or turning, shine
if smashbot_state.action in [Action.STANDING, Action.TURNING] or actionable_landing:
controller.press_button(Button.BUTTON_B)
controller.tilt_analog(Button.BUTTON_MAIN, .5, 0)
self.interruptible = False
return
#Shine on frame 3 of knee bend, else nothing
if smashbot_state.action == Action.KNEE_BEND:
if smashbot_state.action_frame == 3:
controller.press_button(Button.BUTTON_B)
controller.tilt_analog(Button.BUTTON_MAIN, .5, 0)
self.interruptible = False
return
if smashbot_state.action_frame == 2:
self.interruptible = False
if self.direction == MULTISHINE_DIRECTION.FORWARD:
<|code_end|>
, generate the next line using the imports in this file:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
from enum import Enum
and context (functions, classes, or occasionally code) from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | controller.tilt_analog(Button.BUTTON_MAIN, int(smashbot_state.facing), .5) #advancing JC shine
|
Given the following code snippet before the placeholder: <|code_start|>
class SpotDodge(Chain):
def step(self, gamestate, smashbot_state, opponent_state):
controller = self.controller
# Don't try to spot dodge in the air
if not smashbot_state.on_ground:
self.interruptible = True
controller.empty_input()
return
# If we're shielding, do the spot dodge
if smashbot_state.action == Action.SHIELD_REFLECT:
self.interruptible = False
controller.tilt_analog(Button.BUTTON_MAIN, .5, 0)
return
# Let go once we're in the spotdodge
if smashbot_state.action == Action.SPOTDODGE:
self.interruptible = True
controller.empty_input()
return
# If we already pressed L last frame, let go
<|code_end|>
, predict the next line using imports from the current file:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
and context including class names, function names, and sometimes code from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | if controller.prev.button[Button.BUTTON_L]: |
Given the following code snippet before the placeholder: <|code_start|> controller = self.controller
# Don't try to spot dodge in the air
if not smashbot_state.on_ground:
self.interruptible = True
controller.empty_input()
return
# If we're shielding, do the roll
if smashbot_state.action in [Action.SHIELD_REFLECT, Action.SHIELD, Action.SHIELD_START]:
if controller.prev.main_stick != (.5, .5):
controller.tilt_analog(Button.BUTTON_MAIN, .5, .5)
return
self.interruptible = False
controller.tilt_analog(Button.BUTTON_MAIN, int(smashbot_state.position.x < opponent_state.position.x), 0.5)
return
# Let go once we're in the roll
if smashbot_state.action in [Action.ROLL_BACKWARD, Action.ROLL_FORWARD]:
self.interruptible = True
controller.empty_input()
return
# If we already pressed L last frame, let go
if controller.prev.button[Button.BUTTON_L]:
self.interruptible = True
controller.empty_input()
return
self.interruptible = False
<|code_end|>
, predict the next line using imports from the current file:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
and context including class names, function names, and sometimes code from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | controller.press_button(Button.BUTTON_L) |
Based on the snippet: <|code_start|>
class DI(Chain):
def __init__(self, x=0.5, y=0.5, cx = 0.5, cy = 0.5):
self.x = x
self.y = y
self.cx = cx
self.cy = cy
def step(self, gamestate, smashbot_state, opponent_state):
controller = self.controller
self.interruptible = True
controller.release_button(Button.BUTTON_L)
controller.release_button(Button.BUTTON_Y)
<|code_end|>
, predict the immediate next line with the help of imports:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
and context (classes, functions, sometimes code) from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | controller.tilt_analog(Button.BUTTON_MAIN, self.x, self.y) |
Continue the code snippet: <|code_start|> return
# If somehow we are off stage, give up immediately
if smashbot_state.off_stage:
self.interruptible = True
controller.empty_input()
return
# We shouldn't need these. It's just there in case we miss the knee bend somehow
jumping = [Action.JUMPING_ARIAL_FORWARD, Action.JUMPING_ARIAL_BACKWARD]
jumpcancel = (smashbot_state.action == Action.KNEE_BEND) and (smashbot_state.action_frame == 3)
isInShineStart = smashbot_state.action in [Action.DOWN_B_STUN, Action.DOWN_B_GROUND_START, \
Action.DOWN_B_GROUND]
# Jump out of shine
if isInShineStart and smashbot_state.action_frame >= 3 and smashbot_state.on_ground:
self.interruptible = False
controller.press_button(Button.BUTTON_Y)
return
shielding = smashbot_state.action in [Action.SHIELD_START, Action.SHIELD, \
Action.SHIELD_RELEASE, Action.SHIELD_STUN, Action.SHIELD_REFLECT]
neutral = smashbot_state.action in [Action.STANDING, Action.DASHING, Action.TURNING, \
Action.RUNNING, Action.EDGE_TEETERING_START, Action.EDGE_TEETERING]
# Jump out of shield or neutral
if shielding or neutral:
# If we already pressed Y last frame, let go
if controller.prev.button[Button.BUTTON_Y]:
<|code_end|>
. Use current file imports:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
and context (classes, functions, or code) from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | controller.empty_input() |
Next line prediction: <|code_start|>
class TECH_DIRECTION(Enum):
TECH_IN_PLACE = 0
TECH_BACK = 1
TECH_FORWARD = 2
TECH_RANDOM = 3
# Grab and throw opponent
class Tech(Chain):
<|code_end|>
. Use current file imports:
(import melee
import random
from melee.enums import Action, Button
from Chains.chain import Chain
from enum import Enum)
and context including class names, function names, or small code snippets from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | def __init__(self, direction=TECH_DIRECTION.TECH_RANDOM): |
Continue the code snippet: <|code_start|> PSDTILT = 2
PSJAB = 3
class ShieldAction(Chain):
def __init__(self, action=SHIELD_ACTION.PSSHINE):
self.action = action
def step(self, gamestate, smashbot_state, opponent_state):
controller = self.controller
self.interruptible = True
# Let go of A if we were already pressing A
if controller.prev.button[Button.BUTTON_A]:
controller.empty_input()
return
# Let go of B if we were already pressing B
if controller.prev.button[Button.BUTTON_B]:
controller.empty_input()
return
# Consider adding redundancy to check for SHIELD_RELEASE, but this just has button inputs atm
if self.action == SHIELD_ACTION.PSSHINE:
if smashbot_state.action == Action.SHIELD_RELEASE and not gamestate.custom["powershielded_last"]:
self.interruptible = True
controller.press_button(Button.BUTTON_Y)
return
controller.press_button(Button.BUTTON_B)
controller.tilt_analog(Button.BUTTON_MAIN, .5, .3)
<|code_end|>
. Use current file imports:
import melee
import Tactics
from melee.enums import Action, Button
from Chains.chain import Chain
from enum import Enum
and context (classes, functions, or code) from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | return |
Here is a snippet: <|code_start|>
class Airdodge(Chain):
def __init__(self, x=0.5, y=0.5):
self.x = x
self.y = y
def step(self, gamestate, smashbot_state, opponent_state):
<|code_end|>
. Write the next line using the current file imports:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
and context from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
, which may include functions, classes, or code. Output only the next line. | controller = self.controller |
Given the following code snippet before the placeholder: <|code_start|> # Unless we're RIGHT on top of the edge. In which case the only safe wavedash is back on the stage
edge_x = melee.stages.EDGE_GROUND_POSITION[gamestate.stage]
if opponent_state.position.x < 0:
edge_x = -edge_x
edgedistance = abs(edge_x - smashbot_state.position.x)
if edgedistance < 0.5:
direction = smashbot_state.position.x < 0
# Don't waveshine off the stage facing away
facinginwards = smashbot_state.facing == (smashbot_state.position.x < 0)
moving_out = direction == (0 < smashbot_state.position.x)
if edgedistance < 18.5 and moving_out and not facinginwards:
self.distance = 0
# Normalize distance from (0->1) to (-0.5 -> 0.5)
delta = (self.distance / 2) # 0->0.5
if not direction:
delta = -delta
controller.tilt_analog(Button.BUTTON_MAIN, 0.5 + delta, .35)
return
# If we're sliding and have shined, then we're all done here
if smashbot_state.action == Action.LANDING_SPECIAL: #removed and self.hasshined
self.interruptible = True
controller.empty_input()
return
if smashbot_state.action in [Action.SWORD_DANCE_4_MID_AIR, Action.SWORD_DANCE_4_LOW_AIR]:
self.interruptible = False
else:
<|code_end|>
, predict the next line using imports from the current file:
import melee
import random
from melee.enums import Action, Button
from Chains.chain import Chain
and context including class names, function names, and sometimes code from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | self.interruptible = True |
Continue the code snippet: <|code_start|>
class Jump(Chain):
def __init__(self, x=0.5):
self.x = x
def step(self, gamestate, smashbot_state, opponent_state):
controller = self.controller
self.interruptible = True
controller.tilt_analog(Button.BUTTON_MAIN, self.x, 0.5)
if controller.prev.button[Button.BUTTON_Y]:
<|code_end|>
. Use current file imports:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
and context (classes, functions, or code) from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | controller.release_button(Button.BUTTON_Y) |
Given the following code snippet before the placeholder: <|code_start|>
class SHFFL_DIRECTION(Enum):
UP = 0
DOWN = 1
FORWARD = 2
BACK = 3
NEUTRAL = 4
class Shffl(Chain):
def __init__(self, direction=SHFFL_DIRECTION.DOWN):
self.direction = direction
def step(self, gamestate, smashbot_state, opponent_state):
controller = self.controller
if smashbot_state.action == Action.FALLING:
self.interruptible = True
controller.empty_input()
# If we're in knee bend, let go of jump. But move toward opponent
if smashbot_state.action == Action.KNEE_BEND:
self.interruptible = False
controller.release_button(Button.BUTTON_A)
controller.release_button(Button.BUTTON_Y)
jumpdirection = 1
<|code_end|>
, predict the next line using imports from the current file:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
from enum import Enum
and context including class names, function names, and sometimes code from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | if opponent_state.position.x < smashbot_state.position.x: |
Given the following code snippet before the placeholder: <|code_start|>
class THROW_DIRECTION(Enum):
UP = 0
DOWN = 1
FORWARD = 2
<|code_end|>
, predict the next line using imports from the current file:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
from enum import Enum
and context including class names, function names, and sometimes code from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | BACK = 3 |
Here is a snippet: <|code_start|>
# If we just grabbed the edge, wait
if smashbot_state.action == Action.EDGE_CATCHING:
self.interruptible = True
controller.empty_input()
return
# If we just grabbed the edge, wait
if smashbot_state.on_ground:
self.interruptible = True
controller.empty_input()
return
# If we are able to let go of the edge, do it
if smashbot_state.action == Action.EDGE_HANGING:
# If we already pressed back last frame, let go
if controller.prev.c_stick != (0.5, 0.5):
controller.empty_input()
return
x = 1
if smashbot_state.position.x < 0:
x = 0
self.interruptible = False
controller.tilt_analog(Button.BUTTON_C, x, 0.5)
return
# Once we're falling, jump, fade inwards
if smashbot_state.action == Action.FALLING:
self.interruptible = False
x = 0
<|code_end|>
. Write the next line using the current file imports:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
and context from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
, which may include functions, classes, or code. Output only the next line. | if smashbot_state.position.x < 0: |
Given the following code snippet before the placeholder: <|code_start|>
class SMASH_DIRECTION(Enum):
UP = 0
DOWN = 1
LEFT = 2
RIGHT = 3
class SmashAttack(Chain):
def __init__(self, charge=0, direction=SMASH_DIRECTION.UP):
self.charge = charge
self.direction = direction
self.frames_charged = 0
def step(self, gamestate, smashbot_state, opponent_state):
controller = self.controller
if smashbot_state.action == Action.LANDING_SPECIAL:
self.interruptible = True
controller.empty_input()
return
# Do we need to jump cancel?
jumpcancelactions = [Action.SHIELD, Action.SHIELD_RELEASE, Action.DASHING, Action.RUNNING]
if smashbot_state.action in jumpcancelactions:
if controller.prev.button[Button.BUTTON_Y]:
controller.empty_input()
return
self.interruptible = False
controller.press_button(Button.BUTTON_Y)
<|code_end|>
, predict the next line using imports from the current file:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
from enum import Enum
and context including class names, function names, and sometimes code from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | return |
Given snippet: <|code_start|>
# Struggle out of a grab
class Struggle(Chain):
def step(self, gamestate, smashbot_state, opponent_state):
# Just naively press and release every button every other frame
controller = self.controller
# Press every button
if gamestate.frame % 2:
controller.press_button(Button.BUTTON_A)
controller.press_button(Button.BUTTON_B)
controller.press_button(Button.BUTTON_X)
controller.press_button(Button.BUTTON_Y)
controller.press_button(Button.BUTTON_Z)
# Release every button
else:
controller.release_button(Button.BUTTON_A)
controller.release_button(Button.BUTTON_B)
controller.release_button(Button.BUTTON_X)
controller.release_button(Button.BUTTON_Y)
controller.release_button(Button.BUTTON_L)
controller.release_button(Button.BUTTON_R)
controller.release_button(Button.BUTTON_Z)
if (gamestate.frame % 4) == 0:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import melee
from melee.enums import Button
from Chains.chain import Chain
and context:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
which might include code, classes, or functions. Output only the next line. | controller.tilt_analog(Button.BUTTON_MAIN, .5, 0) |
Predict the next line after this snippet: <|code_start|>
class TILT_DIRECTION(Enum):
UP = 0
DOWN = 1
FORWARD = 2
class Tilt(Chain):
def __init__(self, direction=TILT_DIRECTION.UP):
"""NOTE: Don't call this from a dashing state. You need to pivot into it, but then the attack goes the wrong way.
It's not like shine, where it hits all around. And it'd be too complex here to figure out which way is the right way."""
<|code_end|>
using the current file's imports:
import melee
from melee.enums import Action, Button
from Chains.chain import Chain
from enum import Enum
and any relevant context from other files:
# Path: Chains/chain.py
# class Chain:
# __metaclass__ = ABCMeta
# interruptible = True
# logger = None
# controller = None
# framedata = None
# difficulty = None
#
# def step(self, gamestate, smashbot_state, opponent_state): ...
. Output only the next line. | self.direction = direction |
Continue the code snippet: <|code_start|> """
def __init__(self, parent):
self.parent = parent
# Central buffer for storing PDF code not in pages.
self.buffer = b''
# Offest is used to calculate the binary lengths in the cross-reference
# section
self.offset = 0
self.objects = []
# Creates the placeholders in the object list to maintain proper count.
self._create_placeholder_objects()
self.compression = False
self.drawn_color = None
self.color = None
self.project_dir = os.path.dirname(__file__)
if '/modules' in self.project_dir: # pypdflite is a submodule
self.project_dir, other = self.project_dir.split('/modules')
# Compression
def _set_compression(self, value):
""" May be used to compress PDF files. Code is more readable
for testing and inspection if not compressed. Requires a boolean. """
if isinstance(value, bool):
self.compression = value
<|code_end|>
. Use current file imports:
import os
from .pdfobjects.pdfobject import _PDFObject
and context (classes, functions, or code) from other files:
# Path: pypdflite/pdfobjects/pdfobject.py
# class _PDFObject(object):
#
# """ Mainly used in Session, to maintain
# ids and byte counts for the objects
# in session.buffer.
#
# """
#
# def __init__(self, given_id, offset):
# self.id = given_id
# self.offset = offset
. Output only the next line. | else:
|
Predict the next line after this snippet: <|code_start|> if name in self.color_dict:
self._set_from_dict(name)
else:
raise ValueError("Color (%s) not found." % name)
def set_color_by_number(self, r, g, b):
self.red = r
self.green = g
self.blue = b
self.value = (self.red, self.green, self.blue)
self.name = None
def copy(self):
new_color = PDFColor(self.red, self.green, self.blue, self.name)
new_color._set_type(self.color_type)
return new_color
# Used by other objects
def _set_type(self, color_type):
color_type = color_type[0].lower() # Just get the first letter right.
# Check to see if it's in the allowed types
if color_type in self.type_list:
self.color_type = color_type
else:
raise TypeError(
"Invalid color_type %s, must be draw, fill or text" % color_type)
def _set_from_dict(self, name):
<|code_end|>
using the current file's imports:
from .colorref import color_reference
and any relevant context from other files:
# Path: pypdflite/pdfobjects/colorref.py
. Output only the next line. | self.value = self.color_dict[name] # Triplet from color ref
|
Given snippet: <|code_start|>
class PDFGraphBackground(object):
def __init__(self, background_style=None, border_size=None, background_border_color=None, background_fill_color=None, padding=0.0, stroke=None):
self.style = background_style
self.size = border_size
self.border_color = background_border_color
self.fill_color = background_fill_color
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .pdfcolor import PDFColor
and context:
# Path: pypdflite/pdfobjects/pdfcolor.py
# class PDFColor(object):
# def __init__(self, r=0, g=0, b=0, name=None):
# # Get color dictionary
# self.color_dict = color_reference
#
# # Type may be "draw", "fill", or "text"
# self.type_list = ["d", "f", "t"]
# self.color_type = 'd'
#
# if name is not None:
# self.set_color_by_name(name)
# else:
# self.set_color_by_number(r, g, b)
#
# def __repr__(self):
# return "%s: (%s, %s, %s)" % (self.color_type, self.red, self.green, self.blue)
#
# def set_color_by_name(self, name):
# name = name.lower()
# if name in self.color_dict:
# self._set_from_dict(name)
# else:
# raise ValueError("Color (%s) not found." % name)
#
# def set_color_by_number(self, r, g, b):
# self.red = r
# self.green = g
# self.blue = b
#
# self.value = (self.red, self.green, self.blue)
# self.name = None
#
# def copy(self):
# new_color = PDFColor(self.red, self.green, self.blue, self.name)
# new_color._set_type(self.color_type)
# return new_color
#
# # Used by other objects
# def _set_type(self, color_type):
# color_type = color_type[0].lower() # Just get the first letter right.
#
# # Check to see if it's in the allowed types
# if color_type in self.type_list:
# self.color_type = color_type
# else:
# raise TypeError(
# "Invalid color_type %s, must be draw, fill or text" % color_type)
#
# def _set_from_dict(self, name):
# self.value = self.color_dict[name] # Triplet from color ref
# self.name = name
# self.red = self.value[0]
# self.green = self.value[1]
# self.blue = self.value[2]
#
# def _is_equal(self, test_color):
# """Equality test"""
# if test_color is None:
# ans = False
# elif test_color.color_type != self.color_type:
# ans = False
# elif self.name is not None and self.name == test_color.name:
# ans = True
# elif (self.red == test_color.red and
# self.blue == test_color.blue and
# self.green == test_color.green):
# ans = True
# else:
# ans = False
# return ans
#
# def _get_color_string(self):
# """Adobe output string for defining colors"""
# s = ''
# if self.color_type == 'd':
# if self.name is "black":
# s = '%.3f G' % 0
# else:
# s = '%.3f %.3f %.3f RG' % (
# self.red / 255.0, self.green / 255.0, self.blue / 255.0)
# elif self.color_type == 'f' or self.color_type == 't':
# if self.name is "black":
# s = '%.3f g' % 0
# else:
# s = '%.3f %.3f %.3f rg' % (
# self.red / 255.0, self.green / 255.0, self.blue / 255.0)
# return s
which might include code, classes, or functions. Output only the next line. | self.padding = padding |
Predict the next line for this snippet: <|code_start|>
CORE_FONTS = {
'courier': 'Courier',
'courier_bold': 'Courier-Bold',
'courier_italic': 'Courier-Oblique',
'courier_bold_italic': 'Courier-BoldOblique',
'helvetica': 'Helvetica',
'helvetica_bold': 'Helvetica-Bold',
'helvetica_italic': 'Helvetica-Oblique',
'helvetica_bold_italic': 'Helvetica-BoldOblique',
'times': 'Times-Roman',
'times_bold': 'Times-Bold',
'times_italic': 'Times-Italic',
'times_bold_italic': 'Times-BoldItalic',
'symbol': 'Symbol', 'zapfdingbats': 'ZapfDingbats'}
class PDFFont(object):
def __init__(self, session, family='helvetica', style='', size=12):
self.session = session
self.is_set = False
self.font_size = None
self._set_font(family, style, size)
self.type = 'Core'
def __repr__(self):
return self.font_key
<|code_end|>
with the help of current file imports:
from .fontref import pdf_character_widths
import copy
and context from other files:
# Path: pypdflite/pdfobjects/fontref.py
, which may contain function names, class names, or code. Output only the next line. | def _copy(self):
|
Given snippet: <|code_start|>
class PDFRectangle(PDFDraw):
def __init__(self, session, page, cursor_start, cursor_end, border_color=None, fill_color=None, style=None, stroke=None, size=1):
super(PDFRectangle, self).__init__(session, page, border_color, style, stroke, size)
self.fill_color = fill_color
self._set_dimensions(cursor_start, cursor_end)
def _set_dimensions(self, cursor_start, cursor_end):
self.corner = cursor_start
difference = cursor_end - cursor_start
self.width = difference.x
self.height = difference.y
def _draw(self):
self._draw_colors()
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .pdfdraw import PDFDraw
and context:
# Path: pypdflite/pdfobjects/pdfdraw.py
# class PDFDraw(object):
# """
# Base class for the drawing classes: PDFLine, PDFRectangle, PDFEllipse
# """
# def __init__(self, session, page, color=None, style=None, stroke=None, size=1):
# # S is plain, B is filled with border, F is filled no border.
# self.style_list = ['S', 'B', 'F']
# self.stroke_list = ['solid', 'dashed', 'dots']
#
# self.session = session
# self.page = page
# self.color = color
# self._set_size(size)
# self._set_style(style)
# self._set_stroke(stroke)
# self.fill_color = None
#
# def _set_size(self, line_size=1):
# self.line_size = line_size
#
# def _set_style(self, style=None):
# if style in self.stroke_list:
# raise Exception("Style in stroke list : %s" % style)
# style = style.upper() if style is not None else 'S'
# self._style = style if style in self.style_list else 'S'
#
# def _set_stroke(self, stroke='solid'):
# if stroke in self.style_list:
# raise Exception("Stroke in style list : %s" % stroke)
# if stroke == "dashed" or stroke == 1:
# self._stroke = "dashed"
# elif stroke == 'dots' or stroke == 2:
# self._stroke = 'dots'
# else:
# self._stroke = "solid"
#
# def _draw_color(self):
# if isinstance(self.color, PDFColor):
# self.color._set_type('d')
# if not self.session._compare_color(self.color):
# self.session._out(self.color._get_color_string(), self.page)
# self.session._save_color(self.color.copy())
#
# def _draw_colors(self):
# self._draw_color()
# if isinstance(self.fill_color, PDFColor):
# self.fill_color._set_type('f')
# if not self.session._compare_color(self.fill_color):
# self.session._out(self.fill_color._get_color_string(), self.page)
# self.session._save_color(self.fill_color.copy())
#
# def _draw_stroke(self):
# if self._stroke == "dashed":
# self.session._out('[%s] %s d' % (3, 0), self.page)
# elif self._stroke == "solid":
# self.session._out('[] 0 d', self.page)
# elif self._stroke == 'dots':
# self.session._out('[%s] %s d' % (1, 1), self.page)
#
# def _draw_line_size(self):
# self.session._out('%.2f w' % self.line_size, self.page)
#
# def _draw(self):
# raise NotImplementedError
which might include code, classes, or functions. Output only the next line. | self._draw_line_size()
|
Continue the code snippet: <|code_start|>
class PDFTable(object):
def __init__(self, session, page, rows, cols, cursor, def_font):
self.session = session
self.page = page
self.font = def_font
self.number_of_rows = rows
self.number_of_columns = cols
self.cursor = cursor
self.text_cursor = self.cursor.copy()
self.border_cursor = self.cursor.copy()
self._initiate_cells()
def _initiate_cells(self):
self.rows = []
self.columns = []
for x in range(self.number_of_columns):
self.columns.append(PDFColumn(parent=self))
for x in range(self.number_of_rows):
self.rows.append(PDFRow(self, x, self.number_of_columns,
self.text_cursor, self.border_cursor))
<|code_end|>
. Use current file imports:
from .pdfrow import PDFRow
from .pdfcolumn import PDFColumn
and context (classes, functions, or code) from other files:
# Path: pypdflite/pdfobjects/pdfrow.py
# class PDFRow(object):
# def __init__(self, parent, row_index, num_cols, textcursor, bordercursor):
# self.parent = parent
# self.row_index = row_index
# self.num_cols = num_cols
# self.text_cursor = textcursor
# self.border_cursor = bordercursor
# self.cells = []
# self._make_cells()
# self.max_height = 0
#
# def __getitem__(self, key):
# return self.cells[key]
#
# def _make_cells(self):
# for x in range(0, self.num_cols):
# cell = PDFCell(self.parent, self.row_index, x, self.text_cursor, self.border_cursor)
# self.cells.append(cell)
#
# def _draw_text(self):
# for cell in self.cells:
# cell._draw_text()
#
# def _draw_borders(self):
# for cell in self.cells:
# cell._draw_borders()
#
# def _set_borders(self):
# for cell in self.cells:
# cell._set_borders()
# self.border_cursor.x_plus(cell.max_width)
#
# def _draw_fill(self):
# for cell in self.cells:
# cell._draw_fill()
#
# def _finish(self):
# for cell in self.cells:
# if cell.height > self.max_height:
# self.max_height = cell.height
# for cell in self.cells:
# cell._set_max_height(self.max_height)
#
# def _advance_first_row(self):
# self.cells[0]._advance_initial()
#
# def _set_max_height(self, value):
# self.max_height = value
#
# Path: pypdflite/pdfobjects/pdfcolumn.py
# class PDFColumn(object):
# def __init__(self, parent):
# self.parent = parent
# self.cells = []
# self.max_width = 0
#
# def _add_cell(self, cell):
# self.cells.append(cell)
#
# def _set_max_width(self, value):
# self.max_width = value
#
# def _get_max_width(self):
# for cell in self.cells:
# if cell.width > self.max_width and cell.text_wrap is False:
# self.max_width = cell.width
#
# for cell in self.cells:
# cell._set_max_width(self.max_width)
#
# def _finish(self):
# self._get_max_width()
. Output only the next line. | for x in range(self.number_of_rows): |
Continue the code snippet: <|code_start|> def parse_proxy_file(self, fname):
"""Parses a proxy file
The format should be like the following:
socks5 XX.XXX.XX.XX:1080 username:password
socks4 XX.XXX.XX.XX:80 username:password
http XX.XXX.XX.XX:80
If username and password aren't provided, we assumes
that the proxy doesn't need auth credentials.
Args:
fname: The file name where to look for proxies.
Returns:
The parsed proxies.
Raises:
ValueError if no file with the path fname could be found.
"""
proxies = []
path = os.path.join(os.getcwd(), fname)
if os.path.exists(path):
with open(path, 'r') as pf:
for line in pf.readlines():
if not (line.strip().startswith('#') or
line.strip().startswith('//')):
tokens = line.replace('\n', '').split(' ')
try:
proto = tokens[0]
host, port = tokens[1].split(':')
except Exception:
raise Exception('''
<|code_end|>
. Use current file imports:
from collections import namedtuple
from scrapcore import database
import csv
import json
import os
import threading
and context (classes, functions, or code) from other files:
# Path: scrapcore/database.py
# class ScraperSearch(Base):
# class SearchEngineResultsPage(Base):
# class Link(Base):
# class RelatedKeyword(Base):
# class Proxy(Base):
# class SearchEngine(Base):
# class SearchEngineProxyStatus(Base):
# def __str__(self):
# def __repr__(self):
# def __str__(self):
# def __repr__(self):
# def has_no_results_for_query(self):
# def set_values_from_parser(self, parser):
# def set_values_from_scraper(self, scraper):
# def was_correctly_requested(self):
# def __str__(self):
# def __repr__(self):
# def __str__(self):
# def __repr__(self):
# def __str__(self):
# def __repr__(self):
# def get_engine(config, path=None):
# def get_session(config, scoped=False, engine=None, path=None):
# def fixtures(config, session):
# SERP = SearchEngineResultsPage
. Output only the next line. | Invalid proxy file. |
Continue the code snippet: <|code_start|>
logger = Logger()
logger.setup_logger()
logger = logger.get_logger()
class PhantomInstall():
home_dir = os.path.expanduser('phantomjs/')
binary_win = 'phantomjs-2.1.1-windows/bin/phantomjs.exe'
<|code_end|>
. Use current file imports:
import os
import platform
import sys
import tarfile
import urllib.request
import zipfile
import tempfile
from scrapcore.logger import Logger
and context (classes, functions, or code) from other files:
# Path: scrapcore/logger.py
# class Logger():
#
# level = logging.INFO
# logger = None
#
# def setup_logger(self, level=logging.INFO):
# """Configure global log settings"""
# if isinstance(level, int):
# self.level = logging.getLevelName(level)
#
# self.logger = logging.getLogger()
# self.logger.setLevel(self.level)
#
# if not len(self.logger.handlers):
# ch = logging.StreamHandler(stream=sys.stderr)
# logformat = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
# formatter = logging.Formatter(logformat)
# ch.setFormatter(formatter)
# self.logger.addHandler(ch)
#
# def get_logger(self):
# return self.logger
. Output only the next line. | binary_linux64 = 'phantomjs-2.1.1-linux-x86_64/bin/phantomjs' |
Predict the next line after this snippet: <|code_start|>logger = Logger()
logger.setup_logger()
logger = logger.get_logger()
class ChromeInstall():
home_dir = os.path.expanduser('chromedriver/')
binary_win = 'chromedriver.exe'
binary_linux = 'chromedriver'
binary_mac64 = 'chromedriver'
def get_os(self):
return platform.system()
def detect_chromedriver(self):
logger.info('detecting chromedriver')
this_os = self.get_os().lower()
if 'windows' in this_os:
if os.path.isfile(self.home_dir + self.binary_win):
os.chmod(self.home_dir + self.binary_win, 755)
return self.home_dir + self.binary_win
elif 'linux' in this_os:
if os.path.isfile(self.home_dir + self.binary_linux):
os.chmod(self.home_dir + self.binary_linux, 755)
return self.home_dir + self.binary_linux
elif 'darwin' in this_os:
if os.path.isfile(self.home_dir + self.binary_mac64):
os.chmod(self.home_dir + self.binary_mac64, 755)
return self.home_dir + self.binary_mac64
<|code_end|>
using the current file's imports:
from scrapcore.logger import Logger
import os
import platform
import stat
import subprocess
import tempfile
import urllib.request
import zipfile
and any relevant context from other files:
# Path: scrapcore/logger.py
# class Logger():
#
# level = logging.INFO
# logger = None
#
# def setup_logger(self, level=logging.INFO):
# """Configure global log settings"""
# if isinstance(level, int):
# self.level = logging.getLevelName(level)
#
# self.logger = logging.getLogger()
# self.logger.setLevel(self.level)
#
# if not len(self.logger.handlers):
# ch = logging.StreamHandler(stream=sys.stderr)
# logformat = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
# formatter = logging.Formatter(logformat)
# ch.setFormatter(formatter)
# self.logger.addHandler(ch)
#
# def get_logger(self):
# return self.logger
. Output only the next line. | else: |
Based on the snippet: <|code_start|> self, *fields: Union[str, Combinable], **expressions: Any
) -> "_QuerySet[_MT_co, Dict[str, Any]]":
...
class ModelDictQuerySetMixin:
def dicts(
self: IsQuerySet[_MT_co], *fields: str, **named_fields: str
) -> "_QuerySet[_MT_co, Dict[str, Any]]":
if named_fields:
fields += tuple(named_fields.values())
clone = self.values(*fields)
clone._iterable_class = ModelDictIterable # type: ignore[attr-defined]
# QuerySet._hints is a dict object used by db router
# to aid deciding which db should get a request. Currently
# django only supports `instance`, so it's probably
# fine to set a custom key on this dict as it's a guaranteed
# way that it'll be returned with the QuerySet instance
# while leaving the queryset intact
clone._add_hints(**{"_named_fields": named_fields}) # type: ignore[attr-defined]
return clone
class ModelDictQuerySet(ModelDictQuerySetMixin, QuerySet):
pass
<|code_end|>
, predict the immediate next line with the help of imports:
import logging
from typing import (
TYPE_CHECKING,
Any,
Dict,
Iterable,
Iterator,
List,
Mapping,
Optional,
Type,
TypeVar,
Union,
)
from django.db.models import Model
from django.db.models.expressions import Combinable
from django.db.models.query import QuerySet
from typing_extensions import Protocol
from .models import ModelDict
from django.db.models.query import _QuerySet
and context (classes, functions, sometimes code) from other files:
# Path: src/bananas/models.py
# class ModelDict(Dict[str, Any]):
#
# _nested: Optional[Dict[str, "ModelDict"]] = None
#
# def __getattr__(self, item: str) -> Any:
# """
# Try to to get attribute as key item.
# Fallback on prefixed nested keys.
# Finally fallback on real attribute lookup.
# """
# try:
# return self.__getitem__(item)
# except KeyError:
# try:
# return self.__getnested__(item)
# except KeyError:
# return self.__getattribute__(item)
#
# def __getnested__(self, item: str) -> "ModelDict":
# """
# Find existing items prefixed with given item
# and return a new ModelDict containing matched keys,
# stripped from prefix.
#
# :param str item: Item prefix key to find
# :return ModelDict:
# """
# # Ensure _nested cache
# if self._nested is None:
# self._nested: Dict[str, ModelDict] = {}
#
# # Try to get previously accessed/cached nested item
# value = self._nested.get(item, MISSING)
#
# if not isinstance(value, Missing):
# # Return previously accessed nested item
# return value
#
# else:
# # Find any keys matching nested prefix
# prefix = item + "__"
# keys = [key for key in self.keys() if key.startswith(prefix)]
#
# if keys:
# # Construct nested dict of matched keys, stripped from prefix
# n = ModelDict({key[len(item) + 2 :]: self[key] for key in keys})
#
# # Cache and return
# self._nested[item] = n
# return n
#
# # Item not a nested key, raise
# raise KeyError(item)
#
# def expand(self) -> "ModelDict":
# keys = list(self)
# for key in keys:
# field, __, nested_key = key.partition("__")
# if nested_key:
# if field not in keys:
# nested = self.__getnested__(field)
# if isinstance(nested, self.__class__):
# nested = nested.expand()
# self[field] = nested
# del self[key]
# return ModelDict(self)
#
# @classmethod
# # Ignore types until no longer work-in-progress.
# def from_model(cls, model, *fields, **named_fields): # type: ignore[no-untyped-def]
# """
# Work-in-progress constructor,
# consuming fields and values from django model instance.
# """
# d = ModelDict()
#
# if not (fields or named_fields):
# # Default to all fields
# fields = [ # type: ignore[assignment]
# f.attname for f in model._meta.concrete_fields
# ]
#
# not_found = object()
#
# for name, field in chain(zip(fields, fields), named_fields.items()):
# _fields = field.split("__")
# value = model
# for i, _field in enumerate(_fields, start=1):
# # NOTE: we don't want to rely on hasattr here
# previous_value = value
# value = getattr(previous_value, _field, not_found)
#
# if value is not_found:
# if _field in dir(previous_value):
# raise ValueError(
# "{!r}.{} had an AttributeError exception".format(
# previous_value, _field
# )
# )
# else:
# raise AttributeError(
# "{!r} does not have {!r} attribute".format(
# previous_value, _field
# )
# )
#
# elif value is None:
# if name not in named_fields:
# name = "__".join(_fields[:i])
# break
#
# d[name] = value
#
# return d
. Output only the next line. | _MT = TypeVar("_MT", bound=Model) |
Here is a snippet: <|code_start|>
urlpatterns = [re_path(r"^admin/", admin.site.urls)]
api.register(FooAPI)
api.register(HamAPI)
urlpatterns += [
re_path(r"^api/bananas", include("bananas.admin.api.urls")),
re_path(r"^api/separate", include(separate_api)),
re_path(r"^api/", include(fenced_api)),
<|code_end|>
. Write the next line using the current file imports:
from django.urls import include, re_path
from bananas import admin
from bananas.admin import api
from . import separate_api
from .admin_api import FooAPI, HamAPI
from .drf import fenced_api
and context from other files:
# Path: tests/project/admin_api.py
# class FooAPI(BananasAdminAPI):
#
# name = lazy_title(_("foo"))
# serializer_class = HamSerializer
#
# def list(self, request: Request) -> Response:
# serializer = self.serializer_class({"spam": "Skinka"})
# return Response(serializer.data)
#
# @action(detail=False)
# def bar(self, request: Request) -> Response:
# return Response({"bar": True})
#
# @tags(include=["navigation"])
# @action(detail=False, methods=["get", "post"])
# def baz(self, request: Request) -> Response:
# return Response({"baz": True})
#
# class HamAPI(BananasAPI, viewsets.ModelViewSet):
#
# name = lazy_capitalize(_("ham"))
# serializer_class = HamSerializer
#
# def get_queryset(self) -> QuerySet:
# return None # type: ignore
#
# @tags(exclude=["navigation"])
# def list(self, request: Request, *args: Any, **kwargs: Any) -> Response:
# return Response()
#
# Path: tests/project/drf/fenced_api.py
# class SimpleSerializer(ModelSerializer):
# class Meta:
# class AllowIfUnmodifiedSinceAPI(FencedUpdateModelMixin, GenericViewSet):
# class AllowIfMatchAPI(FencedUpdateModelMixin, GenericViewSet):
# def get_queryset(self) -> "QuerySet[Parent]":
, which may include functions, classes, or code. Output only the next line. | ] |
Next line prediction: <|code_start|>
urlpatterns = [re_path(r"^admin/", admin.site.urls)]
api.register(FooAPI)
api.register(HamAPI)
urlpatterns += [
<|code_end|>
. Use current file imports:
(from django.urls import include, re_path
from bananas import admin
from bananas.admin import api
from . import separate_api
from .admin_api import FooAPI, HamAPI
from .drf import fenced_api)
and context including class names, function names, or small code snippets from other files:
# Path: tests/project/admin_api.py
# class FooAPI(BananasAdminAPI):
#
# name = lazy_title(_("foo"))
# serializer_class = HamSerializer
#
# def list(self, request: Request) -> Response:
# serializer = self.serializer_class({"spam": "Skinka"})
# return Response(serializer.data)
#
# @action(detail=False)
# def bar(self, request: Request) -> Response:
# return Response({"bar": True})
#
# @tags(include=["navigation"])
# @action(detail=False, methods=["get", "post"])
# def baz(self, request: Request) -> Response:
# return Response({"baz": True})
#
# class HamAPI(BananasAPI, viewsets.ModelViewSet):
#
# name = lazy_capitalize(_("ham"))
# serializer_class = HamSerializer
#
# def get_queryset(self) -> QuerySet:
# return None # type: ignore
#
# @tags(exclude=["navigation"])
# def list(self, request: Request, *args: Any, **kwargs: Any) -> Response:
# return Response()
#
# Path: tests/project/drf/fenced_api.py
# class SimpleSerializer(ModelSerializer):
# class Meta:
# class AllowIfUnmodifiedSinceAPI(FencedUpdateModelMixin, GenericViewSet):
# class AllowIfMatchAPI(FencedUpdateModelMixin, GenericViewSet):
# def get_queryset(self) -> "QuerySet[Parent]":
. Output only the next line. | re_path(r"^api/bananas", include("bananas.admin.api.urls")), |
Using the snippet: <|code_start|>
urlpatterns = [re_path(r"^admin/", admin.site.urls)]
api.register(FooAPI)
api.register(HamAPI)
urlpatterns += [
<|code_end|>
, determine the next line of code. You have imports:
from django.urls import include, re_path
from bananas import admin
from bananas.admin import api
from . import separate_api
from .admin_api import FooAPI, HamAPI
from .drf import fenced_api
and context (class names, function names, or code) available:
# Path: tests/project/admin_api.py
# class FooAPI(BananasAdminAPI):
#
# name = lazy_title(_("foo"))
# serializer_class = HamSerializer
#
# def list(self, request: Request) -> Response:
# serializer = self.serializer_class({"spam": "Skinka"})
# return Response(serializer.data)
#
# @action(detail=False)
# def bar(self, request: Request) -> Response:
# return Response({"bar": True})
#
# @tags(include=["navigation"])
# @action(detail=False, methods=["get", "post"])
# def baz(self, request: Request) -> Response:
# return Response({"baz": True})
#
# class HamAPI(BananasAPI, viewsets.ModelViewSet):
#
# name = lazy_capitalize(_("ham"))
# serializer_class = HamSerializer
#
# def get_queryset(self) -> QuerySet:
# return None # type: ignore
#
# @tags(exclude=["navigation"])
# def list(self, request: Request, *args: Any, **kwargs: Any) -> Response:
# return Response()
#
# Path: tests/project/drf/fenced_api.py
# class SimpleSerializer(ModelSerializer):
# class Meta:
# class AllowIfUnmodifiedSinceAPI(FencedUpdateModelMixin, GenericViewSet):
# class AllowIfMatchAPI(FencedUpdateModelMixin, GenericViewSet):
# def get_queryset(self) -> "QuerySet[Parent]":
. Output only the next line. | re_path(r"^api/bananas", include("bananas.admin.api.urls")), |
Given the following code snippet before the placeholder: <|code_start|>
class TestParseHeaderDatetime(TestCase):
def test_raises_missing_header(self):
request = FakeRequest.fake()
with self.assertRaises(MissingHeader):
<|code_end|>
, predict the next line using imports from the current file:
import datetime
from unittest import TestCase
from django.utils.http import http_date
from bananas.drf.utils import (
InvalidHeader,
MissingHeader,
parse_header_datetime,
parse_header_etags,
)
from tests.project.drf.request import FakeRequest
and context including class names, function names, and sometimes code from other files:
# Path: tests/project/drf/request.py
# class FakeRequest:
# def __init__(self, headers: Optional[Mapping[str, str]] = None) -> None:
# self.headers = headers or {}
#
# @classmethod
# def fake(cls, *args: Any, **kwargs: Any) -> Request:
# return cast(Request, cls(*args, **kwargs))
. Output only the next line. | parse_header_datetime(request, "missing") |
Based on the snippet: <|code_start|>
apipatterns = [
re_path(
rf"^{version.__version__}/",
include(
<|code_end|>
, predict the immediate next line with the help of imports:
from django.urls import include, re_path
from .versioning import __versions__
and context (classes, functions, sometimes code) from other files:
# Path: src/bananas/admin/api/versioning.py
# class BananasVersioning(NamespaceVersioning):
# def get_versioned_viewname(self, viewname: str, request: Request) -> str:
. Output only the next line. | (f"{version.__name__}.urls", "bananas"), |
Continue the code snippet: <|code_start|> self.assertEqual(parsed, dt)
@isolate_apps("tests.project.drf")
class TestParseDateModified(TestCase):
def test_replaces_microsecond(self):
class A(TimeStampedModel):
date_modified = datetime.datetime( # type: ignore[assignment]
2021, 1, 14, 17, 30, 1, 1, tzinfo=datetime.timezone.utc
)
class Meta:
app_label = "project"
self.assertEqual(
parse_date_modified(A()),
datetime.datetime(2021, 1, 14, 17, 30, 1, tzinfo=datetime.timezone.utc),
)
def test_can_get_none(self):
class A(TimeStampedModel):
date_modified = None # type: ignore[assignment]
class Meta:
app_label = "project"
self.assertIsNone(parse_date_modified(A()))
class TestAllowIfUnmodifiedSince(TestCase):
<|code_end|>
. Use current file imports:
import datetime
import operator
from unittest import TestCase
from django.core.exceptions import ImproperlyConfigured
from django.test.utils import isolate_apps, override_settings
from django.utils.http import http_date
from drf_yasg import openapi
from rest_framework.exceptions import ErrorDetail
from bananas.drf.errors import BadRequest
from bananas.drf.fencing import (
Fence,
allow_if_unmodified_since,
as_set,
header_date_parser,
header_etag_parser,
parse_date_modified,
)
from bananas.models import TimeStampedModel
from tests.project.drf.request import FakeRequest
and context (classes, functions, or code) from other files:
# Path: tests/project/drf/request.py
# class FakeRequest:
# def __init__(self, headers: Optional[Mapping[str, str]] = None) -> None:
# self.headers = headers or {}
#
# @classmethod
# def fake(cls, *args: Any, **kwargs: Any) -> Request:
# return cast(Request, cls(*args, **kwargs))
. Output only the next line. | @override_settings(USE_TZ=False) |
Given snippet: <|code_start|>
class BananasEndpointEnumerator(EndpointEnumerator):
def should_include_endpoint(
self,
path: str,
callback: Callable,
app_name: str = "",
namespace: str = "",
url_name: Optional[str] = None,
) -> bool:
# Fall back to check namespace on the resolver match
request = self.request
if (
not namespace
and getattr(request, "version", None)
and getattr(request, "resolver_match", None)
):
namespace = request.resolver_match.namespace or ""
return cast(
bool,
super().should_include_endpoint(
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, cast
from django.conf import settings
from django.urls.exceptions import NoReverseMatch
from django.utils.translation import gettext as _
from drf_yasg import openapi
from drf_yasg.generators import EndpointEnumerator, OpenAPISchemaGenerator
from drf_yasg.inspectors.view import SwaggerAutoSchema
from drf_yasg.views import get_schema_view
from rest_framework import permissions, viewsets
from rest_framework.authentication import SessionAuthentication
from rest_framework.request import Request
from rest_framework.routers import SimpleRouter
from rest_framework.schemas.coreapi import is_custom_action
from ..versioning import BananasVersioning
from .base import BananasBaseRouter
and context:
# Path: src/bananas/admin/api/versioning.py
# class BananasVersioning(NamespaceVersioning):
#
# default_version: str = v1_0.__version__
# allowed_versions: Sequence[str] = tuple(
# version.__version__ for version in __versions__
# )
# version_map: Dict[str, ModuleType] = {
# version.__version__: version for version in __versions__
# }
#
# def get_versioned_viewname(self, viewname: str, request: Request) -> str:
# """
# Prefix viewname with full namespace bananas:vX.Y:
# """
# namespace = request.resolver_match.namespace
# if namespace:
# viewname = f"{namespace}:{viewname}"
#
# return viewname
#
# Path: src/bananas/admin/api/schemas/base.py
# class BananasBaseRouter:
# def get_default_basename(self, viewset: Type[ViewSetMixin]) -> str:
# return cast(Type["BananasAPI"], viewset).get_admin_meta().basename # type: ignore[no-any-return]
#
# def get_schema_view(self) -> Any:
# raise NotImplementedError
which might include code, classes, or functions. Output only the next line. | path, callback, app_name, namespace, url_name |
Next line prediction: <|code_start|>
class BananasEndpointEnumerator(EndpointEnumerator):
def should_include_endpoint(
self,
path: str,
callback: Callable,
app_name: str = "",
namespace: str = "",
url_name: Optional[str] = None,
) -> bool:
# Fall back to check namespace on the resolver match
request = self.request
if (
not namespace
and getattr(request, "version", None)
and getattr(request, "resolver_match", None)
):
namespace = request.resolver_match.namespace or ""
return cast(
bool,
<|code_end|>
. Use current file imports:
(from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple, cast
from django.conf import settings
from django.urls.exceptions import NoReverseMatch
from django.utils.translation import gettext as _
from drf_yasg import openapi
from drf_yasg.generators import EndpointEnumerator, OpenAPISchemaGenerator
from drf_yasg.inspectors.view import SwaggerAutoSchema
from drf_yasg.views import get_schema_view
from rest_framework import permissions, viewsets
from rest_framework.authentication import SessionAuthentication
from rest_framework.request import Request
from rest_framework.routers import SimpleRouter
from rest_framework.schemas.coreapi import is_custom_action
from ..versioning import BananasVersioning
from .base import BananasBaseRouter)
and context including class names, function names, or small code snippets from other files:
# Path: src/bananas/admin/api/versioning.py
# class BananasVersioning(NamespaceVersioning):
#
# default_version: str = v1_0.__version__
# allowed_versions: Sequence[str] = tuple(
# version.__version__ for version in __versions__
# )
# version_map: Dict[str, ModuleType] = {
# version.__version__: version for version in __versions__
# }
#
# def get_versioned_viewname(self, viewname: str, request: Request) -> str:
# """
# Prefix viewname with full namespace bananas:vX.Y:
# """
# namespace = request.resolver_match.namespace
# if namespace:
# viewname = f"{namespace}:{viewname}"
#
# return viewname
#
# Path: src/bananas/admin/api/schemas/base.py
# class BananasBaseRouter:
# def get_default_basename(self, viewset: Type[ViewSetMixin]) -> str:
# return cast(Type["BananasAPI"], viewset).get_admin_meta().basename # type: ignore[no-any-return]
#
# def get_schema_view(self) -> Any:
# raise NotImplementedError
. Output only the next line. | super().should_include_endpoint( |
Based on the snippet: <|code_start|>
class SimpleSerializer(ModelSerializer):
class Meta:
model = Parent
fields = ("name",)
class AllowIfUnmodifiedSinceAPI(FencedUpdateModelMixin, GenericViewSet):
fence = allow_if_unmodified_since()
serializer_class = SimpleSerializer
queryset = Parent.objects.all()
<|code_end|>
, predict the immediate next line with the help of imports:
import operator
from django.db.models import QuerySet
from django.urls import include, re_path
from rest_framework.routers import DefaultRouter
from rest_framework.serializers import ModelSerializer
from rest_framework.viewsets import GenericViewSet
from bananas.drf.fencing import (
FencedUpdateModelMixin,
allow_if_match,
allow_if_unmodified_since,
)
from tests.project.models import Parent
and context (classes, functions, sometimes code) from other files:
# Path: tests/project/models.py
# class Parent(TimeStampedModel):
# name = models.CharField(max_length=255)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# @property
# def attribute_error(self) -> NoReturn:
# raise AttributeError()
#
# @property
# def version(self) -> str:
# return str(self.pk) + ":" + str(self.date_modified)
. Output only the next line. | class AllowIfMatchAPI(FencedUpdateModelMixin, GenericViewSet): |
Predict the next line after this snippet: <|code_start|>
BANANAS_SECRETS_DIR_ENV_KEY: Final = "BANANAS_SECRETS_DIR"
@overload
def get_secret(secret_name: str, default: str) -> str:
...
<|code_end|>
using the current file's imports:
import os
from typing import Optional
from typing_extensions import Final, overload
from .environment import env
and any relevant context from other files:
# Path: src/bananas/environment.py
# class Undefined:
# class _Instantiable(Protocol[Q]):
# class _InstantiableIterable(Iterable[Q], _Instantiable[Q], Generic[Q]):
# class EnvironWrapper:
# UNDEFINED: Final = Undefined()
# UNSUPPORTED_ENV_SETTINGS = (
# "ADMINS",
# "MANAGERS",
# "LANGUAGES",
# "DISALLOWED_USER_AGENTS",
# "IGNORABLE_404_URLS",
# "TEMPLATES",
# )
# SETTINGS_TYPES: Dict[str, type] = {
# "LANGUAGE_COOKIE_AGE": int,
# "EMAIL_TIMEOUT": int,
# "FILE_UPLOAD_PERMISSIONS": int,
# "FILE_UPLOAD_DIRECTORY_PERMISSIONS": int,
# }
# Q = TypeVar("Q", covariant=True)
# T = TypeVar("T", bound=_InstantiableIterable)
# B = TypeVar("B", bound=Builtin)
# P = TypeVar("P", bound=Union[Builtin, tuple, list, set])
# S = TypeVar("S")
# U = TypeVar("U")
# def parse_str(value: str) -> str:
# def parse_bool(value: str) -> bool:
# def parse_int(value: str) -> int:
# def __init__(self, value: Iterable[Q]) -> None:
# def parse_iterable(typ: Type[T], value: str) -> T:
# def get_parser(typ: Type[B]) -> Callable[[str], B]:
# def get_parser(typ: Type[tuple]) -> Callable[[str], Tuple[str, ...]]:
# def get_parser(typ: Type[list]) -> Callable[[str], List[str]]:
# def get_parser(typ: Type[set]) -> Callable[[str], Set[str]]:
# def get_parser(typ: Type[P]) -> Callable[[str], P]:
# def get_settings() -> Dict[str, Any]:
# def __delitem__(self, key: str) -> None:
# def __getitem__(self, key: str) -> str:
# def __setitem__(self, key: str, value: str) -> None:
# def __contains__(self, key: object) -> bool:
# def __getattr__(self, item: str) -> object:
# def parse(self, parser: Callable[[str], S], key: str, default: None) -> Optional[S]:
# def parse(self, parser: Callable[[str], S], key: str, default: S) -> S:
# def parse(
# self, parser: Callable[[str], S], key: str, default: Optional[S] = None
# ) -> Optional[S]:
# def get_bool(self, key: str, default: U) -> Union[bool, U]:
# def get_bool(self, key: str, default: None = None) -> Optional[bool]:
# def get_bool(self, key: str, default: object = None) -> object:
# def get_int(self, key: str, default: U) -> Union[int, U]:
# def get_int(self, key: str, default: None = None) -> Optional[int]:
# def get_int(self, key: str, default: object = None) -> object:
# def get_tuple(self, key: str, default: U) -> Union[Tuple[str, ...], U]:
# def get_tuple(self, key: str, default: None = None) -> Optional[Tuple[str, ...]]:
# def get_tuple(self, key: str, default: object = None) -> object:
# def get_list(self, key: str, default: U) -> Union[List[str], U]:
# def get_list(self, key: str, default: None = None) -> Optional[List[str]]:
# def get_list(self, key: str, default: object = None) -> object:
# def get_set(self, key: str, default: U) -> Union[Set[str], U]:
# def get_set(self, key: str, default: None = None) -> Optional[Set[str]]:
# def get_set(self, key: str, default: object = None) -> object:
. Output only the next line. | @overload |
Predict the next line after this snippet: <|code_start|>
return parse
T = TypeVar("T")
def as_set(
fn: Callable[[InstanceType], Optional[T]]
) -> Callable[[InstanceType], Optional[FrozenSet[T]]]:
@wraps(fn)
def wrapper(instance: InstanceType) -> Optional[FrozenSet[T]]:
version = fn(instance)
return None if version is None else frozenset({version})
return wrapper
def allow_if_match(
version_getter: Callable[[InstanceType], Optional[str]]
) -> Fence[InstanceType, FrozenSet[str]]:
return Fence(
get_token=header_etag_parser("If-Match"),
compare=operator.le,
get_version=as_set(version_getter),
openapi_parameter=openapi.Parameter(
in_=openapi.IN_HEADER,
name="If-Match",
type=openapi.TYPE_STRING,
required=True,
<|code_end|>
using the current file's imports:
import abc
import datetime
import operator
from functools import wraps
from typing import (
Any,
Callable,
FrozenSet,
Generic,
List,
NoReturn,
Optional,
TypeVar,
cast,
)
from django.conf import settings
from django.core.exceptions import ImproperlyConfigured
from django.db.models import Model, QuerySet
from drf_yasg import openapi
from drf_yasg.utils import swagger_auto_schema
from rest_framework.mixins import UpdateModelMixin
from rest_framework.request import Request
from rest_framework.response import Response
from rest_framework.serializers import BaseSerializer, ModelSerializer
from rest_framework.viewsets import GenericViewSet
from typing_extensions import Final, Protocol, final
from bananas.admin.api.schemas.yasg import BananasSwaggerSchema
from bananas.models import TimeStampedModel
from . import errors
from .utils import HeaderError, parse_header_datetime, parse_header_etags
and any relevant context from other files:
# Path: src/bananas/drf/utils.py
# class HeaderError(ValueError):
# code = "invalid_header"
#
# def as_api_error(self) -> BadRequest:
# return BadRequest(detail=str(self), code=self.code)
#
# def parse_header_datetime(request: Request, header: str) -> datetime.datetime:
# try:
# value = request.headers[header]
# except KeyError:
# raise MissingHeader(header)
# try:
# return datetime.datetime.fromtimestamp(
# parse_http_date(value), tz=datetime.timezone.utc
# )
# except ValueError as e:
# raise InvalidHeader(header) from e
#
# def parse_header_etags(request: Request, header: str) -> FrozenSet[str]:
# try:
# parts = request.headers[header].split(",")
# except KeyError:
# raise MissingHeader(header)
# tags = frozenset(clean_tags(parts))
# if not tags:
# raise InvalidHeader(header)
# return tags
. Output only the next line. | description=( |
Using the snippet: <|code_start|>
__all__ = (
"Fence",
"FencedUpdateModelMixin",
"header_date_parser",
"parse_date_modified",
"allow_if_unmodified_since",
"header_etag_parser",
"allow_if_match",
<|code_end|>
, determine the next line of code. You have imports:
import abc
import datetime
import operator
from functools import wraps
from typing import (
Any,
Callable,
FrozenSet,
Generic,
List,
NoReturn,
Optional,
TypeVar,
cast,
)
from django.conf import settings
from django.core.exceptions import ImproperlyConfigured
from django.db.models import Model, QuerySet
from drf_yasg import openapi
from drf_yasg.utils import swagger_auto_schema
from rest_framework.mixins import UpdateModelMixin
from rest_framework.request import Request
from rest_framework.response import Response
from rest_framework.serializers import BaseSerializer, ModelSerializer
from rest_framework.viewsets import GenericViewSet
from typing_extensions import Final, Protocol, final
from bananas.admin.api.schemas.yasg import BananasSwaggerSchema
from bananas.models import TimeStampedModel
from . import errors
from .utils import HeaderError, parse_header_datetime, parse_header_etags
and context (class names, function names, or code) available:
# Path: src/bananas/drf/utils.py
# class HeaderError(ValueError):
# code = "invalid_header"
#
# def as_api_error(self) -> BadRequest:
# return BadRequest(detail=str(self), code=self.code)
#
# def parse_header_datetime(request: Request, header: str) -> datetime.datetime:
# try:
# value = request.headers[header]
# except KeyError:
# raise MissingHeader(header)
# try:
# return datetime.datetime.fromtimestamp(
# parse_http_date(value), tz=datetime.timezone.utc
# )
# except ValueError as e:
# raise InvalidHeader(header) from e
#
# def parse_header_etags(request: Request, header: str) -> FrozenSet[str]:
# try:
# parts = request.headers[header].split(",")
# except KeyError:
# raise MissingHeader(header)
# tags = frozenset(clean_tags(parts))
# if not tags:
# raise InvalidHeader(header)
# return tags
. Output only the next line. | ) |
Based on the snippet: <|code_start|>
__all__ = (
"Fence",
"FencedUpdateModelMixin",
"header_date_parser",
"parse_date_modified",
"allow_if_unmodified_since",
"header_etag_parser",
"allow_if_match",
)
TokenType = TypeVar("TokenType")
InstanceType = TypeVar("InstanceType")
<|code_end|>
, predict the immediate next line with the help of imports:
import abc
import datetime
import operator
from functools import wraps
from typing import (
Any,
Callable,
FrozenSet,
Generic,
List,
NoReturn,
Optional,
TypeVar,
cast,
)
from django.conf import settings
from django.core.exceptions import ImproperlyConfigured
from django.db.models import Model, QuerySet
from drf_yasg import openapi
from drf_yasg.utils import swagger_auto_schema
from rest_framework.mixins import UpdateModelMixin
from rest_framework.request import Request
from rest_framework.response import Response
from rest_framework.serializers import BaseSerializer, ModelSerializer
from rest_framework.viewsets import GenericViewSet
from typing_extensions import Final, Protocol, final
from bananas.admin.api.schemas.yasg import BananasSwaggerSchema
from bananas.models import TimeStampedModel
from . import errors
from .utils import HeaderError, parse_header_datetime, parse_header_etags
and context (classes, functions, sometimes code) from other files:
# Path: src/bananas/drf/utils.py
# class HeaderError(ValueError):
# code = "invalid_header"
#
# def as_api_error(self) -> BadRequest:
# return BadRequest(detail=str(self), code=self.code)
#
# def parse_header_datetime(request: Request, header: str) -> datetime.datetime:
# try:
# value = request.headers[header]
# except KeyError:
# raise MissingHeader(header)
# try:
# return datetime.datetime.fromtimestamp(
# parse_http_date(value), tz=datetime.timezone.utc
# )
# except ValueError as e:
# raise InvalidHeader(header) from e
#
# def parse_header_etags(request: Request, header: str) -> FrozenSet[str]:
# try:
# parts = request.headers[header].split(",")
# except KeyError:
# raise MissingHeader(header)
# tags = frozenset(clean_tags(parts))
# if not tags:
# raise InvalidHeader(header)
# return tags
. Output only the next line. | @final |
Next line prediction: <|code_start|>
__all__ = (
"HeaderError",
"MissingHeader",
"InvalidHeader",
"parse_header_datetime",
"parse_header_etags",
)
<|code_end|>
. Use current file imports:
(import datetime
from typing import FrozenSet, Iterable
from django.utils.http import parse_http_date
from rest_framework.request import Request
from .errors import BadRequest)
and context including class names, function names, or small code snippets from other files:
# Path: src/bananas/drf/errors.py
# class BadRequest(APIException):
# status_code = status.HTTP_400_BAD_REQUEST
# default_detail = "Validation failed"
# default_code = "bad_request"
. Output only the next line. | class HeaderError(ValueError): |
Based on the snippet: <|code_start|> self.assertEqual(
response.json()["detail"], "Header missing in request: If-Unmodified-Since"
)
def test_returns_bad_request_for_invalid_header(self):
item = Parent.objects.create()
response = self.client.put(
self.url(args=(item.pk,)),
data={"name": "Great!"},
HTTP_IF_UNMODIFIED_SINCE="",
)
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEqual(
response.json()["detail"],
"Malformed header in request: If-Unmodified-Since",
)
def test_returns_precondition_failed_for_expired_token(self):
item = Parent.objects.create()
response = self.client.put(
self.url(args=(item.pk,)),
data={"name": "Great!"},
HTTP_IF_UNMODIFIED_SINCE=http_date(item.date_modified.timestamp() - 1),
)
self.assertEqual(response.status_code, status.HTTP_412_PRECONDITION_FAILED)
self.assertEqual(
response.json()["detail"],
"The resource does not fulfill the given preconditions",
)
<|code_end|>
, predict the immediate next line with the help of imports:
from functools import partial
from django.urls import reverse
from django.utils.http import http_date
from rest_framework import status
from rest_framework.test import APITestCase
from tests.project.models import Parent
and context (classes, functions, sometimes code) from other files:
# Path: tests/project/models.py
# class Parent(TimeStampedModel):
# name = models.CharField(max_length=255)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# @property
# def attribute_error(self) -> NoReturn:
# raise AttributeError()
#
# @property
# def version(self) -> str:
# return str(self.pk) + ":" + str(self.date_modified)
. Output only the next line. | def test_allows_request_for_valid_token(self): |
Given the code snippet: <|code_start|> self.settings.update(getattr(django_settings, "ADMIN", {}))
self.site_title = self.settings["SITE_TITLE"]
self.site_header = self.settings["SITE_HEADER"]
self.index_title = self.settings["INDEX_TITLE"]
def each_context(self, request: WSGIRequest) -> Dict[str, Any]:
context = super().each_context(request)
context.update(settings=self.settings)
return context
@property
def urls(self) -> Tuple[List[Union[URLResolver, URLPattern]], str, str]:
if self.settings["INHERIT_REGISTERED_MODELS"]:
for model, admin in list(django_admin_site._registry.items()):
# django_admin_site.unregister(model)
self._registry[model] = admin.__class__(model, self)
return self.get_urls(), "admin", self.name # type: ignore[return-value]
class ModelAdminView(ModelAdmin):
@cached_property
def access_permission(self) -> str:
meta = self.model._meta
return "{app_label}.{codename}".format(
app_label=meta.app_label,
codename=meta.permissions[0][0], # First perm codename
)
def get_urls(self) -> List[URLPattern]:
<|code_end|>
, generate the next line using the imports in this file:
import re
import django
from typing import (
Any,
Callable,
Dict,
List,
Optional,
Tuple,
Type,
TypeVar,
Union,
cast,
overload,
)
from django.apps import apps
from django.conf import settings as django_settings
from django.contrib.admin import AdminSite, ModelAdmin
from django.contrib.admin.sites import site as django_admin_site
from django.contrib.auth.decorators import permission_required, user_passes_test
from django.core.handlers.wsgi import WSGIRequest
from django.db.models import Model
from django.http import HttpRequest
from django.http.response import HttpResponse, HttpResponseBase
from django.shortcuts import render
from django.urls import URLPattern, URLResolver, re_path, reverse, reverse_lazy
from django.utils.encoding import force_str
from django.utils.functional import cached_property
from django.utils.safestring import SafeText, mark_safe
from django.utils.translation import gettext_lazy as _
from django.views.generic import View
from ..environment import env
and context (functions, classes, or occasionally code) from other files:
# Path: src/bananas/environment.py
# class Undefined:
# class _Instantiable(Protocol[Q]):
# class _InstantiableIterable(Iterable[Q], _Instantiable[Q], Generic[Q]):
# class EnvironWrapper:
# UNDEFINED: Final = Undefined()
# UNSUPPORTED_ENV_SETTINGS = (
# "ADMINS",
# "MANAGERS",
# "LANGUAGES",
# "DISALLOWED_USER_AGENTS",
# "IGNORABLE_404_URLS",
# "TEMPLATES",
# )
# SETTINGS_TYPES: Dict[str, type] = {
# "LANGUAGE_COOKIE_AGE": int,
# "EMAIL_TIMEOUT": int,
# "FILE_UPLOAD_PERMISSIONS": int,
# "FILE_UPLOAD_DIRECTORY_PERMISSIONS": int,
# }
# Q = TypeVar("Q", covariant=True)
# T = TypeVar("T", bound=_InstantiableIterable)
# B = TypeVar("B", bound=Builtin)
# P = TypeVar("P", bound=Union[Builtin, tuple, list, set])
# S = TypeVar("S")
# U = TypeVar("U")
# def parse_str(value: str) -> str:
# def parse_bool(value: str) -> bool:
# def parse_int(value: str) -> int:
# def __init__(self, value: Iterable[Q]) -> None:
# def parse_iterable(typ: Type[T], value: str) -> T:
# def get_parser(typ: Type[B]) -> Callable[[str], B]:
# def get_parser(typ: Type[tuple]) -> Callable[[str], Tuple[str, ...]]:
# def get_parser(typ: Type[list]) -> Callable[[str], List[str]]:
# def get_parser(typ: Type[set]) -> Callable[[str], Set[str]]:
# def get_parser(typ: Type[P]) -> Callable[[str], P]:
# def get_settings() -> Dict[str, Any]:
# def __delitem__(self, key: str) -> None:
# def __getitem__(self, key: str) -> str:
# def __setitem__(self, key: str, value: str) -> None:
# def __contains__(self, key: object) -> bool:
# def __getattr__(self, item: str) -> object:
# def parse(self, parser: Callable[[str], S], key: str, default: None) -> Optional[S]:
# def parse(self, parser: Callable[[str], S], key: str, default: S) -> S:
# def parse(
# self, parser: Callable[[str], S], key: str, default: Optional[S] = None
# ) -> Optional[S]:
# def get_bool(self, key: str, default: U) -> Union[bool, U]:
# def get_bool(self, key: str, default: None = None) -> Optional[bool]:
# def get_bool(self, key: str, default: object = None) -> object:
# def get_int(self, key: str, default: U) -> Union[int, U]:
# def get_int(self, key: str, default: None = None) -> Optional[int]:
# def get_int(self, key: str, default: object = None) -> object:
# def get_tuple(self, key: str, default: U) -> Union[Tuple[str, ...], U]:
# def get_tuple(self, key: str, default: None = None) -> Optional[Tuple[str, ...]]:
# def get_tuple(self, key: str, default: object = None) -> object:
# def get_list(self, key: str, default: U) -> Union[List[str], U]:
# def get_list(self, key: str, default: None = None) -> Optional[List[str]]:
# def get_list(self, key: str, default: object = None) -> object:
# def get_set(self, key: str, default: U) -> Union[Set[str], U]:
# def get_set(self, key: str, default: None = None) -> Optional[Set[str]]:
# def get_set(self, key: str, default: object = None) -> object:
. Output only the next line. | app_label = self.model._meta.app_label |
Based on the snippet: <|code_start|> self.assertEqual(global_settings.DEBUG, False)
self.assertEqual(settings.DEBUG, True)
self.assertListEqual(settings.INTERNAL_IPS, ["127.0.0.1", "10.0.0.1"]) # type: ignore[attr-defined]
self.assertIsNone(global_settings.FILE_UPLOAD_DIRECTORY_PERMISSIONS)
self.assertEqual(settings.FILE_UPLOAD_DIRECTORY_PERMISSIONS, 420) # type: ignore[attr-defined]
def test_get_settings(self):
environ["DJANGO_ADMINS"] = "foobar"
self.assertRaises(ValueError, environment.get_settings)
del environ["DJANGO_ADMINS"]
def test_unsupported_settings_type(self):
environ["DJANGO_DATABASES"] = "foobar"
self.assertRaises(NotImplementedError, environment.get_settings)
del environ["DJANGO_DATABASES"]
class TimeStampedModelTest(TestCase):
def test_date_modified(self):
parent = Parent.objects.create(name="foo")
self.assertIsNotNone(parent.date_created)
self.assertIsNotNone(parent.date_modified)
pre_date_modified = parent.date_modified
parent.name = "bar"
parent.save()
parent.refresh_from_db()
self.assertNotEqual(parent.date_modified, pre_date_modified)
self.assertEqual(parent.name, "bar")
<|code_end|>
, predict the immediate next line with the help of imports:
from os import environ
from django.conf import global_settings
from django.core.exceptions import ValidationError
from django.test import TestCase
from bananas import environment
from bananas.environment import env
from bananas.models import ModelDict
from tests.project.models import (
Child,
Node,
Parent,
SecretModel,
Simple,
TestUUIDModel,
URLSecretModel,
)
from tests.project import settings_example as settings
and context (classes, functions, sometimes code) from other files:
# Path: tests/project/models.py
# class Child(TimeStampedModel):
# name = models.CharField(max_length=255)
# parent = models.ForeignKey(Parent, null=True, on_delete=models.CASCADE)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# class Node(TimeStampedModel):
# name = models.CharField(max_length=255)
# parent = models.ForeignKey("self", null=True, on_delete=models.CASCADE)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# class Parent(TimeStampedModel):
# name = models.CharField(max_length=255)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# @property
# def attribute_error(self) -> NoReturn:
# raise AttributeError()
#
# @property
# def version(self) -> str:
# return str(self.pk) + ":" + str(self.date_modified)
#
# class SecretModel(models.Model):
# secret = SecretField()
#
# class Simple(Model):
# name = models.CharField(max_length=255)
# objects = SimpleManager()
#
# class TestUUIDModel(UUIDModel):
# text = models.CharField(max_length=255)
# parent = models.ForeignKey("TestUUIDModel", null=True, on_delete=models.CASCADE)
#
# class URLSecretModel(models.Model):
# # num_bytes=25 forces the base64 algorithm to pad
# secret = URLSecretField(num_bytes=25, min_bytes=25)
. Output only the next line. | pre_date_modified = parent.date_modified |
Given snippet: <|code_start|>
def test_parse_list(self):
self.assertListEqual(environment.parse_list("a, b, c"), ["a", "b", "c"])
def test_parse_set(self):
self.assertSetEqual(environment.parse_set("b, a, c"), {"a", "b", "c"})
def test_env_wrapper(self):
self.assertEqual(env.get("foo", "bar"), "bar")
self.assertEqual(env.get("foo", "bar"), "bar")
self.assertIsNone(env.get_bool("foobar"))
self.assertFalse(env.get_bool("foobar", False))
environ["foobar"] = "True"
self.assertTrue(env.get_bool("foobar", False))
environ["foobar"] = "Ture"
self.assertIsNone(env.get_bool("foobar"))
self.assertFalse(env.get_bool("foobar", False))
environ["foobar"] = "123"
self.assertEqual(env.get_int("foobar"), 123)
environ["foobar"] = "a, b, c"
tuple_result = env.get_tuple("foobar")
assert tuple_result is not None
self.assertTupleEqual(tuple_result, ("a", "b", "c"))
environ["foobar"] = "a, b, c"
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from os import environ
from django.conf import global_settings
from django.core.exceptions import ValidationError
from django.test import TestCase
from bananas import environment
from bananas.environment import env
from bananas.models import ModelDict
from tests.project.models import (
Child,
Node,
Parent,
SecretModel,
Simple,
TestUUIDModel,
URLSecretModel,
)
from tests.project import settings_example as settings
and context:
# Path: tests/project/models.py
# class Child(TimeStampedModel):
# name = models.CharField(max_length=255)
# parent = models.ForeignKey(Parent, null=True, on_delete=models.CASCADE)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# class Node(TimeStampedModel):
# name = models.CharField(max_length=255)
# parent = models.ForeignKey("self", null=True, on_delete=models.CASCADE)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# class Parent(TimeStampedModel):
# name = models.CharField(max_length=255)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# @property
# def attribute_error(self) -> NoReturn:
# raise AttributeError()
#
# @property
# def version(self) -> str:
# return str(self.pk) + ":" + str(self.date_modified)
#
# class SecretModel(models.Model):
# secret = SecretField()
#
# class Simple(Model):
# name = models.CharField(max_length=255)
# objects = SimpleManager()
#
# class TestUUIDModel(UUIDModel):
# text = models.CharField(max_length=255)
# parent = models.ForeignKey("TestUUIDModel", null=True, on_delete=models.CASCADE)
#
# class URLSecretModel(models.Model):
# # num_bytes=25 forces the base64 algorithm to pad
# secret = URLSecretField(num_bytes=25, min_bytes=25)
which might include code, classes, or functions. Output only the next line. | list_result = env.get_list("foobar") |
Here is a snippet: <|code_start|> self.assertEqual(child.parent.name, self.parent.name)
def test_dicts_rename(self):
child = Child.objects.dicts("parent__name", alias="name").first()
self.assertEqual(child.alias, self.child.name)
self.assertEqual(child.parent.name, self.parent.name)
# Test that renamed fields on reverse relation fields
# will actually return all possible results
expected_dicts = [
{"child_name": self.child.name},
{"child_name": self.other_child.name},
]
self.assertListEqual(
list(Parent.objects.filter(name="A").dicts(child_name="child__name")),
expected_dicts,
)
# Test renaming a field with another that's not renamed
expected_dicts = [
{"id": self.parent.pk, "child_name": self.child.name},
{"id": self.parent.pk, "child_name": self.other_child.name},
]
self.assertListEqual(
list(Parent.objects.filter(name="A").dicts("id", child_name="child__name")),
expected_dicts,
)
# Test multiple renamed fileds together
<|code_end|>
. Write the next line using the current file imports:
from os import environ
from django.conf import global_settings
from django.core.exceptions import ValidationError
from django.test import TestCase
from bananas import environment
from bananas.environment import env
from bananas.models import ModelDict
from tests.project.models import (
Child,
Node,
Parent,
SecretModel,
Simple,
TestUUIDModel,
URLSecretModel,
)
from tests.project import settings_example as settings
and context from other files:
# Path: tests/project/models.py
# class Child(TimeStampedModel):
# name = models.CharField(max_length=255)
# parent = models.ForeignKey(Parent, null=True, on_delete=models.CASCADE)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# class Node(TimeStampedModel):
# name = models.CharField(max_length=255)
# parent = models.ForeignKey("self", null=True, on_delete=models.CASCADE)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# class Parent(TimeStampedModel):
# name = models.CharField(max_length=255)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# @property
# def attribute_error(self) -> NoReturn:
# raise AttributeError()
#
# @property
# def version(self) -> str:
# return str(self.pk) + ":" + str(self.date_modified)
#
# class SecretModel(models.Model):
# secret = SecretField()
#
# class Simple(Model):
# name = models.CharField(max_length=255)
# objects = SimpleManager()
#
# class TestUUIDModel(UUIDModel):
# text = models.CharField(max_length=255)
# parent = models.ForeignKey("TestUUIDModel", null=True, on_delete=models.CASCADE)
#
# class URLSecretModel(models.Model):
# # num_bytes=25 forces the base64 algorithm to pad
# secret = URLSecretField(num_bytes=25, min_bytes=25)
, which may include functions, classes, or code. Output only the next line. | expected_dicts = [ |
Predict the next line for this snippet: <|code_start|> {"id": self.parent.pk, "child_name": self.child.name},
{"id": self.parent.pk, "child_name": self.other_child.name},
]
self.assertListEqual(
list(Parent.objects.filter(name="A").dicts("id", child_name="child__name")),
expected_dicts,
)
# Test multiple renamed fileds together
expected_dicts = [
{"id": self.child.pk, "child_name": self.child.name},
{"id": self.other_child.pk, "child_name": self.other_child.name},
]
self.assertListEqual(
list(
Parent.objects.filter(name="A").dicts(
id="child__id", child_name="child__name"
)
),
expected_dicts,
)
# Test multiple renamed fileds together with another that's not
expected_dicts = [
{
"id": self.parent.pk,
"child_id": self.child.pk,
"child_name": self.child.name,
<|code_end|>
with the help of current file imports:
from os import environ
from django.conf import global_settings
from django.core.exceptions import ValidationError
from django.test import TestCase
from bananas import environment
from bananas.environment import env
from bananas.models import ModelDict
from tests.project.models import (
Child,
Node,
Parent,
SecretModel,
Simple,
TestUUIDModel,
URLSecretModel,
)
from tests.project import settings_example as settings
and context from other files:
# Path: tests/project/models.py
# class Child(TimeStampedModel):
# name = models.CharField(max_length=255)
# parent = models.ForeignKey(Parent, null=True, on_delete=models.CASCADE)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# class Node(TimeStampedModel):
# name = models.CharField(max_length=255)
# parent = models.ForeignKey("self", null=True, on_delete=models.CASCADE)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# class Parent(TimeStampedModel):
# name = models.CharField(max_length=255)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# @property
# def attribute_error(self) -> NoReturn:
# raise AttributeError()
#
# @property
# def version(self) -> str:
# return str(self.pk) + ":" + str(self.date_modified)
#
# class SecretModel(models.Model):
# secret = SecretField()
#
# class Simple(Model):
# name = models.CharField(max_length=255)
# objects = SimpleManager()
#
# class TestUUIDModel(UUIDModel):
# text = models.CharField(max_length=255)
# parent = models.ForeignKey("TestUUIDModel", null=True, on_delete=models.CASCADE)
#
# class URLSecretModel(models.Model):
# # num_bytes=25 forces the base64 algorithm to pad
# secret = URLSecretField(num_bytes=25, min_bytes=25)
, which may contain function names, class names, or code. Output only the next line. | }, |
Predict the next line after this snippet: <|code_start|> self.assertSetEqual(environment.parse_set("b, a, c"), {"a", "b", "c"})
def test_env_wrapper(self):
self.assertEqual(env.get("foo", "bar"), "bar")
self.assertEqual(env.get("foo", "bar"), "bar")
self.assertIsNone(env.get_bool("foobar"))
self.assertFalse(env.get_bool("foobar", False))
environ["foobar"] = "True"
self.assertTrue(env.get_bool("foobar", False))
environ["foobar"] = "Ture"
self.assertIsNone(env.get_bool("foobar"))
self.assertFalse(env.get_bool("foobar", False))
environ["foobar"] = "123"
self.assertEqual(env.get_int("foobar"), 123)
environ["foobar"] = "a, b, c"
tuple_result = env.get_tuple("foobar")
assert tuple_result is not None
self.assertTupleEqual(tuple_result, ("a", "b", "c"))
environ["foobar"] = "a, b, c"
list_result = env.get_list("foobar")
assert list_result is not None
self.assertListEqual(list_result, ["a", "b", "c"])
environ["foobar"] = "a, b, c"
<|code_end|>
using the current file's imports:
from os import environ
from django.conf import global_settings
from django.core.exceptions import ValidationError
from django.test import TestCase
from bananas import environment
from bananas.environment import env
from bananas.models import ModelDict
from tests.project.models import (
Child,
Node,
Parent,
SecretModel,
Simple,
TestUUIDModel,
URLSecretModel,
)
from tests.project import settings_example as settings
and any relevant context from other files:
# Path: tests/project/models.py
# class Child(TimeStampedModel):
# name = models.CharField(max_length=255)
# parent = models.ForeignKey(Parent, null=True, on_delete=models.CASCADE)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# class Node(TimeStampedModel):
# name = models.CharField(max_length=255)
# parent = models.ForeignKey("self", null=True, on_delete=models.CASCADE)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# class Parent(TimeStampedModel):
# name = models.CharField(max_length=255)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# @property
# def attribute_error(self) -> NoReturn:
# raise AttributeError()
#
# @property
# def version(self) -> str:
# return str(self.pk) + ":" + str(self.date_modified)
#
# class SecretModel(models.Model):
# secret = SecretField()
#
# class Simple(Model):
# name = models.CharField(max_length=255)
# objects = SimpleManager()
#
# class TestUUIDModel(UUIDModel):
# text = models.CharField(max_length=255)
# parent = models.ForeignKey("TestUUIDModel", null=True, on_delete=models.CASCADE)
#
# class URLSecretModel(models.Model):
# # num_bytes=25 forces the base64 algorithm to pad
# secret = URLSecretField(num_bytes=25, min_bytes=25)
. Output only the next line. | set_result = env.get_set("foobar") |
Based on the snippet: <|code_start|> environ["DJANGO_ADMINS"] = "foobar"
self.assertRaises(ValueError, environment.get_settings)
del environ["DJANGO_ADMINS"]
def test_unsupported_settings_type(self):
environ["DJANGO_DATABASES"] = "foobar"
self.assertRaises(NotImplementedError, environment.get_settings)
del environ["DJANGO_DATABASES"]
class TimeStampedModelTest(TestCase):
def test_date_modified(self):
parent = Parent.objects.create(name="foo")
self.assertIsNotNone(parent.date_created)
self.assertIsNotNone(parent.date_modified)
pre_date_modified = parent.date_modified
parent.name = "bar"
parent.save()
parent.refresh_from_db()
self.assertNotEqual(parent.date_modified, pre_date_modified)
self.assertEqual(parent.name, "bar")
pre_date_modified = parent.date_modified
parent.name = "baz"
parent.save(update_fields=["name"])
parent.refresh_from_db()
self.assertNotEqual(parent.date_modified, pre_date_modified)
self.assertEqual(parent.name, "baz")
<|code_end|>
, predict the immediate next line with the help of imports:
from os import environ
from django.conf import global_settings
from django.core.exceptions import ValidationError
from django.test import TestCase
from bananas import environment
from bananas.environment import env
from bananas.models import ModelDict
from tests.project.models import (
Child,
Node,
Parent,
SecretModel,
Simple,
TestUUIDModel,
URLSecretModel,
)
from tests.project import settings_example as settings
and context (classes, functions, sometimes code) from other files:
# Path: tests/project/models.py
# class Child(TimeStampedModel):
# name = models.CharField(max_length=255)
# parent = models.ForeignKey(Parent, null=True, on_delete=models.CASCADE)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# class Node(TimeStampedModel):
# name = models.CharField(max_length=255)
# parent = models.ForeignKey("self", null=True, on_delete=models.CASCADE)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# class Parent(TimeStampedModel):
# name = models.CharField(max_length=255)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# @property
# def attribute_error(self) -> NoReturn:
# raise AttributeError()
#
# @property
# def version(self) -> str:
# return str(self.pk) + ":" + str(self.date_modified)
#
# class SecretModel(models.Model):
# secret = SecretField()
#
# class Simple(Model):
# name = models.CharField(max_length=255)
# objects = SimpleManager()
#
# class TestUUIDModel(UUIDModel):
# text = models.CharField(max_length=255)
# parent = models.ForeignKey("TestUUIDModel", null=True, on_delete=models.CASCADE)
#
# class URLSecretModel(models.Model):
# # num_bytes=25 forces the base64 algorithm to pad
# secret = URLSecretField(num_bytes=25, min_bytes=25)
. Output only the next line. | parent.save(update_fields={"name"}) |
Here is a snippet: <|code_start|> d = ModelDict(foo="bar", baz__ham="spam")
self.assertIn("foo", d, 'should have key "foo"')
self.assertNotIn("baz", d, 'should not have key "baz"')
self.assertRaises(AttributeError, d.__getattr__, "x")
self.assertTrue(hasattr(d, "foo"), 'should not have real attr "foo"')
self.assertEqual(d.foo, "bar")
self.assertEqual(d.baz__ham, "spam")
self.assertIsInstance(d.baz, ModelDict, "should lazy resolve sub dict")
def test_modeldict_from_model(self):
d = ModelDict.from_model(self.child, "id", "parent__id", "parent__name")
self.assertDictEqual(
d, {"id": self.child.id, "parent__id": self.parent.id, "parent__name": "A"}
)
self.assertTrue(d.parent)
_child = Child.objects.create(name="B")
d = ModelDict.from_model(_child, "id", "parent__id", "parent__name")
self.assertDictEqual(
d,
{
"id": _child.id,
"parent": None,
},
)
_parent = Node.objects.create(name="A", parent=None)
_child = Node.objects.create(name="B", parent=_parent)
_grandchild = Node.objects.create(name="C", parent=_child)
<|code_end|>
. Write the next line using the current file imports:
from os import environ
from django.conf import global_settings
from django.core.exceptions import ValidationError
from django.test import TestCase
from bananas import environment
from bananas.environment import env
from bananas.models import ModelDict
from tests.project.models import (
Child,
Node,
Parent,
SecretModel,
Simple,
TestUUIDModel,
URLSecretModel,
)
from tests.project import settings_example as settings
and context from other files:
# Path: tests/project/models.py
# class Child(TimeStampedModel):
# name = models.CharField(max_length=255)
# parent = models.ForeignKey(Parent, null=True, on_delete=models.CASCADE)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# class Node(TimeStampedModel):
# name = models.CharField(max_length=255)
# parent = models.ForeignKey("self", null=True, on_delete=models.CASCADE)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# class Parent(TimeStampedModel):
# name = models.CharField(max_length=255)
# objects = Manager.from_queryset(ExtendedQuerySet)()
#
# @property
# def attribute_error(self) -> NoReturn:
# raise AttributeError()
#
# @property
# def version(self) -> str:
# return str(self.pk) + ":" + str(self.date_modified)
#
# class SecretModel(models.Model):
# secret = SecretField()
#
# class Simple(Model):
# name = models.CharField(max_length=255)
# objects = SimpleManager()
#
# class TestUUIDModel(UUIDModel):
# text = models.CharField(max_length=255)
# parent = models.ForeignKey("TestUUIDModel", null=True, on_delete=models.CASCADE)
#
# class URLSecretModel(models.Model):
# # num_bytes=25 forces the base64 algorithm to pad
# secret = URLSecretField(num_bytes=25, min_bytes=25)
, which may include functions, classes, or code. Output only the next line. | d = ModelDict.from_model( |
Predict the next line for this snippet: <|code_start|> p = int(nls[1])
else:
p = 80
#conn = HTTPConnection(h, p)
return h, p, res.path
def get(conn, dst):
#conn = HTTPConnection("10.0.0.7", 8080)
echo(repr(dst))
conn.request("GET", dst)
resp = conn.getresponse()
echo(resp.read().decode('utf8'))
def post(h, p, dst, fns):
for fn in fns:
conn = HTTPConnection(h, p)
post_one(fn, conn, dst)
def post_one(fn, conn, dst, upd=""):
echo(fn, dst)
#conn = HTTPConnection(ip, port)
bun = "-----------------12123135---61b3e9bf8df4ee45---------------"
fo = UpFile(fn, 'attachment', bun, upd)
headers = {"Content-Type": "multipart/form-data; boundary=%s" % bun,
"Content-Length": str(fo.size()),
}
conn.request("POST", dst, fo, headers)
<|code_end|>
with the help of current file imports:
import os
import re
import sys
from httplib import HTTPConnection
from urllib import quote, unquote
from urlparse import urlparse
from http.client import HTTPConnection
from urllib.parse import quote, unquote, urlparse
from comm import echo, U
and context from other files:
# Path: comm.py
# def echo(*args):
# sys.stdout.write(" ".join(map(str, args)) + "\n")
# sys.stdout.flush()
#
# def U(dat):
# return dat
, which may contain function names, class names, or code. Output only the next line. | resp = conn.getresponse() |
Next line prediction: <|code_start|> p.wait()
if p.returncode == 0:
return "ffmpeg"
p = Popen(['which', 'avconv'])
p.wait()
if p.returncode == 0:
return "avconv"
return ""
def merge(name, ext, cnt, clean=False, ists=False):
# ext = 'x-mpeg-ts'
# avconv -i 12.mp4 -c copy -f mpegts -bsf h264_mp4toannexb - > aa.ts
oex = ext
if ext in tss:
ists = True
oex = "mp4"
outfn = "%s.%s" % (name, oex)
mrgfn = "%s.mrg.%s" % (name, oex)
if os.path.exists(outfn):
echo(outfn, "exists")
return
fs = []
for i in range(cnt):
fs.append("%s[%02d].%s" % (name, i, ext))
#fs.append("%s%03d.%s" % (name, i + 1, ext))
cmd = ["avconv",
"-v", "error",
<|code_end|>
. Use current file imports:
(import os
import sys
import shutil
from time import sleep
from subprocess import Popen, PIPE, CalledProcessError
from comm import echo)
and context including class names, function names, or small code snippets from other files:
# Path: comm.py
# def echo(*args):
# sys.stdout.write(" ".join(map(str, args)) + "\n")
# sys.stdout.flush()
. Output only the next line. | "-i", "-", |
Given the code snippet: <|code_start|> def U(dat):
if not isinstance(dat, unicode):
return dat.decode('utf8')
return dat
#USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.10; rv:33.0) '
#USER_AGENT += 'Gecko/20100101 Firefox/33.0'
USER_AGENT = 'Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.109 Safari/537.36'
USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.146 Safari/537.36'
DEBUG = False
UTITLE = "UnknownTitle"
def debug(*args):
global DEBUG
if DEBUG:
echo(*args)
return DEBUG
def norm_url(url):
if isinstance(url, unicode):
url = url.encode('utf8')
return quote(unquote(url), ":=?/&#;,@")
class UO(object):
def __init__(self, url, referer):
<|code_end|>
, generate the next line using the imports in this file:
import os
import re
import ssl
import sys
import zlib
import argparse
import subprocess
import http.client as httplib
import urllib.parse as urlparse
import httplib
import urlparse
import ssl
from time import sleep
from queue import Queue
from urllib.parse import quote, unquote
from urllib.request import HTTPCookieProcessor, ProxyHandler
from urllib.request import HTTPRedirectHandler, HTTPSHandler
from urllib.request import Request
from urllib.request import build_opener
from urllib import quote, unquote
from Queue import Queue
from urllib2 import HTTPCookieProcessor, ProxyHandler
from urllib2 import HTTPRedirectHandler, HTTPSHandler
from urllib2 import Request
from urllib2 import build_opener
from post import post_file
from merge import merge, tss, m3u8_merge
from you_get.common import download_urls
from threading import Thread
and context (functions, classes, or occasionally code) from other files:
# Path: post.py
# def post_file(filename, dest_uri):
# h, p, dst = make_host_port(dest_uri)
# dst = quote(unquote(dst))
# conn = HTTPConnection(h, p)
# if not py3:
# if isinstance(filename, unicode):
# filename = filename.encode("utf8")
# #post_one(filename, conn, quote(unquote(dst)))
# post_one(filename, conn, dst, "uploaded ")
#
# Path: merge.py
# def run1(name, cnt):
# def merge1(name, ext, cnt):
# def find_tool():
# def merge(name, ext, cnt, clean=False, ists=False):
# def waitp(p, timeout=0):
# def m3u8_merge(url, outfn, slow=False):
# def usage():
# def main():
. Output only the next line. | self.url = url |
Continue the code snippet: <|code_start|> def U(dat):
return dat
except ImportError:
py3 = False
class ConnectionResetError(Exception):
pass
def echo(*args):
# sys.stdout.write(" ".join(map(str, args)) + "\n")
for arg in args:
if isinstance(arg, unicode):
sys.stdout.write(arg.encode("utf8"))
elif isinstance(arg, Exception):
sys.stdout.write(unicode(arg).encode("utf8"))
else:
sys.stdout.write(str(arg))
sys.stdout.write(" ")
sys.stdout.write("\n")
sys.stdout.flush()
def U(dat):
if not isinstance(dat, unicode):
return dat.decode('utf8')
return dat
#USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.10; rv:33.0) '
#USER_AGENT += 'Gecko/20100101 Firefox/33.0'
<|code_end|>
. Use current file imports:
import os
import re
import ssl
import sys
import zlib
import argparse
import subprocess
import http.client as httplib
import urllib.parse as urlparse
import httplib
import urlparse
import ssl
from time import sleep
from queue import Queue
from urllib.parse import quote, unquote
from urllib.request import HTTPCookieProcessor, ProxyHandler
from urllib.request import HTTPRedirectHandler, HTTPSHandler
from urllib.request import Request
from urllib.request import build_opener
from urllib import quote, unquote
from Queue import Queue
from urllib2 import HTTPCookieProcessor, ProxyHandler
from urllib2 import HTTPRedirectHandler, HTTPSHandler
from urllib2 import Request
from urllib2 import build_opener
from post import post_file
from merge import merge, tss, m3u8_merge
from you_get.common import download_urls
from threading import Thread
and context (classes, functions, or code) from other files:
# Path: post.py
# def post_file(filename, dest_uri):
# h, p, dst = make_host_port(dest_uri)
# dst = quote(unquote(dst))
# conn = HTTPConnection(h, p)
# if not py3:
# if isinstance(filename, unicode):
# filename = filename.encode("utf8")
# #post_one(filename, conn, quote(unquote(dst)))
# post_one(filename, conn, dst, "uploaded ")
#
# Path: merge.py
# def run1(name, cnt):
# def merge1(name, ext, cnt):
# def find_tool():
# def merge(name, ext, cnt, clean=False, ists=False):
# def waitp(p, timeout=0):
# def m3u8_merge(url, outfn, slow=False):
# def usage():
# def main():
. Output only the next line. | USER_AGENT = 'Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.109 Safari/537.36' |
Based on the snippet: <|code_start|>DEBUG = False
UTITLE = "UnknownTitle"
def debug(*args):
global DEBUG
if DEBUG:
echo(*args)
return DEBUG
def norm_url(url):
if isinstance(url, unicode):
url = url.encode('utf8')
return quote(unquote(url), ":=?/&#;,@")
class UO(object):
def __init__(self, url, referer):
self.url = url
self.referer = referer
class DWM(object):
out_dir = './'
info_only = False
align_num = 0
is_playlist = False
handle_list = []
get_html_url = ''
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import re
import ssl
import sys
import zlib
import argparse
import subprocess
import http.client as httplib
import urllib.parse as urlparse
import httplib
import urlparse
import ssl
from time import sleep
from queue import Queue
from urllib.parse import quote, unquote
from urllib.request import HTTPCookieProcessor, ProxyHandler
from urllib.request import HTTPRedirectHandler, HTTPSHandler
from urllib.request import Request
from urllib.request import build_opener
from urllib import quote, unquote
from Queue import Queue
from urllib2 import HTTPCookieProcessor, ProxyHandler
from urllib2 import HTTPRedirectHandler, HTTPSHandler
from urllib2 import Request
from urllib2 import build_opener
from post import post_file
from merge import merge, tss, m3u8_merge
from you_get.common import download_urls
from threading import Thread
and context (classes, functions, sometimes code) from other files:
# Path: post.py
# def post_file(filename, dest_uri):
# h, p, dst = make_host_port(dest_uri)
# dst = quote(unquote(dst))
# conn = HTTPConnection(h, p)
# if not py3:
# if isinstance(filename, unicode):
# filename = filename.encode("utf8")
# #post_one(filename, conn, quote(unquote(dst)))
# post_one(filename, conn, dst, "uploaded ")
#
# Path: merge.py
# def run1(name, cnt):
# def merge1(name, ext, cnt):
# def find_tool():
# def merge(name, ext, cnt, clean=False, ists=False):
# def waitp(p, timeout=0):
# def m3u8_merge(url, outfn, slow=False):
# def usage():
# def main():
. Output only the next line. | no_proxy = False |
Using the snippet: <|code_start|># -*- coding: utf8 -*-
try:
py3 = True
def echo(*args):
sys.stdout.write(" ".join(map(str, args)) + "\n")
sys.stdout.flush()
def U(dat):
return dat
except ImportError:
<|code_end|>
, determine the next line of code. You have imports:
import os
import re
import ssl
import sys
import zlib
import argparse
import subprocess
import http.client as httplib
import urllib.parse as urlparse
import httplib
import urlparse
import ssl
from time import sleep
from queue import Queue
from urllib.parse import quote, unquote
from urllib.request import HTTPCookieProcessor, ProxyHandler
from urllib.request import HTTPRedirectHandler, HTTPSHandler
from urllib.request import Request
from urllib.request import build_opener
from urllib import quote, unquote
from Queue import Queue
from urllib2 import HTTPCookieProcessor, ProxyHandler
from urllib2 import HTTPRedirectHandler, HTTPSHandler
from urllib2 import Request
from urllib2 import build_opener
from post import post_file
from merge import merge, tss, m3u8_merge
from you_get.common import download_urls
from threading import Thread
and context (class names, function names, or code) available:
# Path: post.py
# def post_file(filename, dest_uri):
# h, p, dst = make_host_port(dest_uri)
# dst = quote(unquote(dst))
# conn = HTTPConnection(h, p)
# if not py3:
# if isinstance(filename, unicode):
# filename = filename.encode("utf8")
# #post_one(filename, conn, quote(unquote(dst)))
# post_one(filename, conn, dst, "uploaded ")
#
# Path: merge.py
# def run1(name, cnt):
# def merge1(name, ext, cnt):
# def find_tool():
# def merge(name, ext, cnt, clean=False, ists=False):
# def waitp(p, timeout=0):
# def m3u8_merge(url, outfn, slow=False):
# def usage():
# def main():
. Output only the next line. | py3 = False |
Here is a snippet: <|code_start|> hutf = self.get_hutf(src)
dst = match1(hutf, 'var play_url \= "([^"]+)"')
echo(dst)
if not dst:
echo("Can not find var play_url")
sys.exit(1)
if ('youku.com/' in dst and '/m3u8' in dst) \
or 'lecloud.com/' in dst \
or '/letv-uts/' in dst:
return title, None, self.try_m3u8(dst), None
if 'ttwanda.com/ftn_handler/' in dst:
cs = ["%s=%s" % (c.name, c.value)
for c in self.cookie.cookiejar
if c.name != 'PHPSESSID']
echo(cs)
self.wget_cookie = "; ".join(cs)
k, s = get_kind_size(dst, self.wget_cookie)
return title, k, [dst], s
#if 'mgtv.com/' in dst or '189.cn/v5/downloadFile' in dst:
# # http://www.ttwanda.com/films/us/907.html?style=cq
# return title, None, [dst], None
#echo('TTWanda has new source')
#echo(dst)
#sys.exit(1)
return title, None, [dst], None
def get_playlist(self, url):
if '/tv/' not in url:
return []
url = url.split('?')[0]
<|code_end|>
. Write the next line using the current file imports:
import os
import re
import sys
from mybs import SelStr
from comm import DWM, match1, echo, start, debug, py3, get_kind_size
from letv import LETV
and context from other files:
# Path: mybs.py
# def SelStr(sel, data):
# mp = MyHtmlParser(tidy=False)
# mp.feed(data)
# return mp.select(sel)
#
# Path: comm.py
# def echo(*args):
# def U(dat):
# def echo(*args):
# def U(dat):
# def debug(*args):
# def norm_url(url):
# def __init__(self, url, referer):
# def __init__(self, proxy=None):
# def get_html(self, url, raw=False, postdata=None):
# def get_hutf(self, *param, **dd):
# def chrome_hutf(self, url):
# def phantom_hutf(self, url, timeout=300, refer=None, postdata=None):
# def last_m3u8(self, src):
# def try_m3u8(self, src):
# def _get_m3u8_urls(self, src, data):
# def get_outfn(self, title, ext, unum=0):
# def align_title_num(self, t):
# def get_total_size(self, urllist):
# def use_dwm_merge(self, urls, title, ext, clean=True):
# def download_urls_you_get(self, title, ext, urls, totalsize):
# def get_real_url(self, bu, rt, uri):
# def try_key(self, bu, rt, dn, line):
# def wget_m3u8(self, title, url):
# def download_m3u8(self, title, url):
# def avconv_m3u8(self, title, ext, url):
# def wget_urls(self, title, ext, urls, tsize):
# def wget_one_url(self, outfn, url, unum, totalsize=0):
# def get_one(self, url, t=UTITLE, n=False):
# def try_playlist(self, ispl, url):
# def get_playlist(self, page_url):
# def clean_up(self):
# def test(self, args):
# def can_handle_it(cls, url):
# def get_kind_size(u, cookie=""):
# def get_total_size_st(urllist):
# def get_total_size_mt(urllist, tn=10):
# def worker():
# def search_first(text, *patterns):
# def match1(text, *patterns):
# def c2n(cs):
# def norm_title(title):
# def start(kls):
# def run(k, args):
# class ConnectionResetError(Exception):
# class UO(object):
# class DWM(object):
# USER_AGENT = 'Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.109 Safari/537.36'
# USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.146 Safari/537.36'
# DEBUG = False
# UTITLE = "UnknownTitle"
# DEBUG = args.debug
# DEBUG = True
, which may include functions, classes, or code. Output only the next line. | hutf = self.get_hutf(url) |
Given the following code snippet before the placeholder: <|code_start|># -*- coding: utf8 -*-
class TTWanDa(DWM): # http://www.ttwanda.com/
handle_list = ['\.ttwanda\.com/films/', '\.ttwanda\.com/tv/']
def query_info(self, url):
#url = 'http://www.ttwanda.com/films/us/1693.html?xf'
hutf = self.get_hutf(url)
if '?' not in url:
a = SelStr('section.p5 div a', hutf)[0]['href']
url = url + a
hutf = self.get_hutf(url)
title = SelStr("div.video-content article p strong", hutf)[0].text
r = "《(.+)》"
if not py3:
<|code_end|>
, predict the next line using imports from the current file:
import os
import re
import sys
from mybs import SelStr
from comm import DWM, match1, echo, start, debug, py3, get_kind_size
from letv import LETV
and context including class names, function names, and sometimes code from other files:
# Path: mybs.py
# def SelStr(sel, data):
# mp = MyHtmlParser(tidy=False)
# mp.feed(data)
# return mp.select(sel)
#
# Path: comm.py
# def echo(*args):
# def U(dat):
# def echo(*args):
# def U(dat):
# def debug(*args):
# def norm_url(url):
# def __init__(self, url, referer):
# def __init__(self, proxy=None):
# def get_html(self, url, raw=False, postdata=None):
# def get_hutf(self, *param, **dd):
# def chrome_hutf(self, url):
# def phantom_hutf(self, url, timeout=300, refer=None, postdata=None):
# def last_m3u8(self, src):
# def try_m3u8(self, src):
# def _get_m3u8_urls(self, src, data):
# def get_outfn(self, title, ext, unum=0):
# def align_title_num(self, t):
# def get_total_size(self, urllist):
# def use_dwm_merge(self, urls, title, ext, clean=True):
# def download_urls_you_get(self, title, ext, urls, totalsize):
# def get_real_url(self, bu, rt, uri):
# def try_key(self, bu, rt, dn, line):
# def wget_m3u8(self, title, url):
# def download_m3u8(self, title, url):
# def avconv_m3u8(self, title, ext, url):
# def wget_urls(self, title, ext, urls, tsize):
# def wget_one_url(self, outfn, url, unum, totalsize=0):
# def get_one(self, url, t=UTITLE, n=False):
# def try_playlist(self, ispl, url):
# def get_playlist(self, page_url):
# def clean_up(self):
# def test(self, args):
# def can_handle_it(cls, url):
# def get_kind_size(u, cookie=""):
# def get_total_size_st(urllist):
# def get_total_size_mt(urllist, tn=10):
# def worker():
# def search_first(text, *patterns):
# def match1(text, *patterns):
# def c2n(cs):
# def norm_title(title):
# def start(kls):
# def run(k, args):
# class ConnectionResetError(Exception):
# class UO(object):
# class DWM(object):
# USER_AGENT = 'Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.109 Safari/537.36'
# USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.146 Safari/537.36'
# DEBUG = False
# UTITLE = "UnknownTitle"
# DEBUG = args.debug
# DEBUG = True
. Output only the next line. | r = r.decode('utf8') |
Here is a snippet: <|code_start|> echo("Can not find var play_url")
sys.exit(1)
if ('youku.com/' in dst and '/m3u8' in dst) \
or 'lecloud.com/' in dst \
or '/letv-uts/' in dst:
return title, None, self.try_m3u8(dst), None
if 'ttwanda.com/ftn_handler/' in dst:
cs = ["%s=%s" % (c.name, c.value)
for c in self.cookie.cookiejar
if c.name != 'PHPSESSID']
echo(cs)
self.wget_cookie = "; ".join(cs)
k, s = get_kind_size(dst, self.wget_cookie)
return title, k, [dst], s
#if 'mgtv.com/' in dst or '189.cn/v5/downloadFile' in dst:
# # http://www.ttwanda.com/films/us/907.html?style=cq
# return title, None, [dst], None
#echo('TTWanda has new source')
#echo(dst)
#sys.exit(1)
return title, None, [dst], None
def get_playlist(self, url):
if '/tv/' not in url:
return []
url = url.split('?')[0]
hutf = self.get_hutf(url)
ns = SelStr('div.article-paging a', hutf)
# href="?vid=20723618&title=第01集 新局长崛起"
urls = []
<|code_end|>
. Write the next line using the current file imports:
import os
import re
import sys
from mybs import SelStr
from comm import DWM, match1, echo, start, debug, py3, get_kind_size
from letv import LETV
and context from other files:
# Path: mybs.py
# def SelStr(sel, data):
# mp = MyHtmlParser(tidy=False)
# mp.feed(data)
# return mp.select(sel)
#
# Path: comm.py
# def echo(*args):
# def U(dat):
# def echo(*args):
# def U(dat):
# def debug(*args):
# def norm_url(url):
# def __init__(self, url, referer):
# def __init__(self, proxy=None):
# def get_html(self, url, raw=False, postdata=None):
# def get_hutf(self, *param, **dd):
# def chrome_hutf(self, url):
# def phantom_hutf(self, url, timeout=300, refer=None, postdata=None):
# def last_m3u8(self, src):
# def try_m3u8(self, src):
# def _get_m3u8_urls(self, src, data):
# def get_outfn(self, title, ext, unum=0):
# def align_title_num(self, t):
# def get_total_size(self, urllist):
# def use_dwm_merge(self, urls, title, ext, clean=True):
# def download_urls_you_get(self, title, ext, urls, totalsize):
# def get_real_url(self, bu, rt, uri):
# def try_key(self, bu, rt, dn, line):
# def wget_m3u8(self, title, url):
# def download_m3u8(self, title, url):
# def avconv_m3u8(self, title, ext, url):
# def wget_urls(self, title, ext, urls, tsize):
# def wget_one_url(self, outfn, url, unum, totalsize=0):
# def get_one(self, url, t=UTITLE, n=False):
# def try_playlist(self, ispl, url):
# def get_playlist(self, page_url):
# def clean_up(self):
# def test(self, args):
# def can_handle_it(cls, url):
# def get_kind_size(u, cookie=""):
# def get_total_size_st(urllist):
# def get_total_size_mt(urllist, tn=10):
# def worker():
# def search_first(text, *patterns):
# def match1(text, *patterns):
# def c2n(cs):
# def norm_title(title):
# def start(kls):
# def run(k, args):
# class ConnectionResetError(Exception):
# class UO(object):
# class DWM(object):
# USER_AGENT = 'Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.109 Safari/537.36'
# USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.146 Safari/537.36'
# DEBUG = False
# UTITLE = "UnknownTitle"
# DEBUG = args.debug
# DEBUG = True
, which may include functions, classes, or code. Output only the next line. | for a in ns: |
Given snippet: <|code_start|> if 'ttwanda.com/ftn_handler/' in dst:
cs = ["%s=%s" % (c.name, c.value)
for c in self.cookie.cookiejar
if c.name != 'PHPSESSID']
echo(cs)
self.wget_cookie = "; ".join(cs)
k, s = get_kind_size(dst, self.wget_cookie)
return title, k, [dst], s
#if 'mgtv.com/' in dst or '189.cn/v5/downloadFile' in dst:
# # http://www.ttwanda.com/films/us/907.html?style=cq
# return title, None, [dst], None
#echo('TTWanda has new source')
#echo(dst)
#sys.exit(1)
return title, None, [dst], None
def get_playlist(self, url):
if '/tv/' not in url:
return []
url = url.split('?')[0]
hutf = self.get_hutf(url)
ns = SelStr('div.article-paging a', hutf)
# href="?vid=20723618&title=第01集 新局长崛起"
urls = []
for a in ns:
vid = match1(a['href'], 'vid=(\d+)')
if vid:
urls.append((a.text, url + '?vid=' + vid))
else:
urls.append((a.text, url + a['href']))
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import re
import sys
from mybs import SelStr
from comm import DWM, match1, echo, start, debug, py3, get_kind_size
from letv import LETV
and context:
# Path: mybs.py
# def SelStr(sel, data):
# mp = MyHtmlParser(tidy=False)
# mp.feed(data)
# return mp.select(sel)
#
# Path: comm.py
# def echo(*args):
# def U(dat):
# def echo(*args):
# def U(dat):
# def debug(*args):
# def norm_url(url):
# def __init__(self, url, referer):
# def __init__(self, proxy=None):
# def get_html(self, url, raw=False, postdata=None):
# def get_hutf(self, *param, **dd):
# def chrome_hutf(self, url):
# def phantom_hutf(self, url, timeout=300, refer=None, postdata=None):
# def last_m3u8(self, src):
# def try_m3u8(self, src):
# def _get_m3u8_urls(self, src, data):
# def get_outfn(self, title, ext, unum=0):
# def align_title_num(self, t):
# def get_total_size(self, urllist):
# def use_dwm_merge(self, urls, title, ext, clean=True):
# def download_urls_you_get(self, title, ext, urls, totalsize):
# def get_real_url(self, bu, rt, uri):
# def try_key(self, bu, rt, dn, line):
# def wget_m3u8(self, title, url):
# def download_m3u8(self, title, url):
# def avconv_m3u8(self, title, ext, url):
# def wget_urls(self, title, ext, urls, tsize):
# def wget_one_url(self, outfn, url, unum, totalsize=0):
# def get_one(self, url, t=UTITLE, n=False):
# def try_playlist(self, ispl, url):
# def get_playlist(self, page_url):
# def clean_up(self):
# def test(self, args):
# def can_handle_it(cls, url):
# def get_kind_size(u, cookie=""):
# def get_total_size_st(urllist):
# def get_total_size_mt(urllist, tn=10):
# def worker():
# def search_first(text, *patterns):
# def match1(text, *patterns):
# def c2n(cs):
# def norm_title(title):
# def start(kls):
# def run(k, args):
# class ConnectionResetError(Exception):
# class UO(object):
# class DWM(object):
# USER_AGENT = 'Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.109 Safari/537.36'
# USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.146 Safari/537.36'
# DEBUG = False
# UTITLE = "UnknownTitle"
# DEBUG = args.debug
# DEBUG = True
which might include code, classes, or functions. Output only the next line. | return urls |
Next line prediction: <|code_start|> echo(src)
self.extra_headers['Referer'] = url # this is important
hutf = self.get_hutf(src)
dst = match1(hutf, 'var play_url \= "([^"]+)"')
echo(dst)
if not dst:
echo("Can not find var play_url")
sys.exit(1)
if ('youku.com/' in dst and '/m3u8' in dst) \
or 'lecloud.com/' in dst \
or '/letv-uts/' in dst:
return title, None, self.try_m3u8(dst), None
if 'ttwanda.com/ftn_handler/' in dst:
cs = ["%s=%s" % (c.name, c.value)
for c in self.cookie.cookiejar
if c.name != 'PHPSESSID']
echo(cs)
self.wget_cookie = "; ".join(cs)
k, s = get_kind_size(dst, self.wget_cookie)
return title, k, [dst], s
#if 'mgtv.com/' in dst or '189.cn/v5/downloadFile' in dst:
# # http://www.ttwanda.com/films/us/907.html?style=cq
# return title, None, [dst], None
#echo('TTWanda has new source')
#echo(dst)
#sys.exit(1)
return title, None, [dst], None
def get_playlist(self, url):
if '/tv/' not in url:
<|code_end|>
. Use current file imports:
(import os
import re
import sys
from mybs import SelStr
from comm import DWM, match1, echo, start, debug, py3, get_kind_size
from letv import LETV)
and context including class names, function names, or small code snippets from other files:
# Path: mybs.py
# def SelStr(sel, data):
# mp = MyHtmlParser(tidy=False)
# mp.feed(data)
# return mp.select(sel)
#
# Path: comm.py
# def echo(*args):
# def U(dat):
# def echo(*args):
# def U(dat):
# def debug(*args):
# def norm_url(url):
# def __init__(self, url, referer):
# def __init__(self, proxy=None):
# def get_html(self, url, raw=False, postdata=None):
# def get_hutf(self, *param, **dd):
# def chrome_hutf(self, url):
# def phantom_hutf(self, url, timeout=300, refer=None, postdata=None):
# def last_m3u8(self, src):
# def try_m3u8(self, src):
# def _get_m3u8_urls(self, src, data):
# def get_outfn(self, title, ext, unum=0):
# def align_title_num(self, t):
# def get_total_size(self, urllist):
# def use_dwm_merge(self, urls, title, ext, clean=True):
# def download_urls_you_get(self, title, ext, urls, totalsize):
# def get_real_url(self, bu, rt, uri):
# def try_key(self, bu, rt, dn, line):
# def wget_m3u8(self, title, url):
# def download_m3u8(self, title, url):
# def avconv_m3u8(self, title, ext, url):
# def wget_urls(self, title, ext, urls, tsize):
# def wget_one_url(self, outfn, url, unum, totalsize=0):
# def get_one(self, url, t=UTITLE, n=False):
# def try_playlist(self, ispl, url):
# def get_playlist(self, page_url):
# def clean_up(self):
# def test(self, args):
# def can_handle_it(cls, url):
# def get_kind_size(u, cookie=""):
# def get_total_size_st(urllist):
# def get_total_size_mt(urllist, tn=10):
# def worker():
# def search_first(text, *patterns):
# def match1(text, *patterns):
# def c2n(cs):
# def norm_title(title):
# def start(kls):
# def run(k, args):
# class ConnectionResetError(Exception):
# class UO(object):
# class DWM(object):
# USER_AGENT = 'Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.109 Safari/537.36'
# USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.146 Safari/537.36'
# DEBUG = False
# UTITLE = "UnknownTitle"
# DEBUG = args.debug
# DEBUG = True
. Output only the next line. | return [] |
Predict the next line for this snippet: <|code_start|> hutf = self.get_hutf(url)
title = SelStr("div.video-content article p strong", hutf)[0].text
r = "《(.+)》"
if not py3:
r = r.decode('utf8')
t = match1(title, r)
if t and '/films/' in url:
title = t
src = SelStr('iframe.player', hutf)[0]['src']
if '/player/v.php?url=' in src:
# http://www.ttwanda.com/tv/ustv/945.html
# ../../player/v.php?url=www.le.com/ptv/vplay/20723618.html
src = 'http://' + src.split('?url=', 1)[1]
return LETV().query_info(src)
if not src.startswith("http://") and not src.startswith("https://"):
src = 'http://www.ttwanda.com/' + src
echo(src)
self.extra_headers['Referer'] = url # this is important
hutf = self.get_hutf(src)
dst = match1(hutf, 'var play_url \= "([^"]+)"')
echo(dst)
if not dst:
echo("Can not find var play_url")
sys.exit(1)
if ('youku.com/' in dst and '/m3u8' in dst) \
or 'lecloud.com/' in dst \
or '/letv-uts/' in dst:
return title, None, self.try_m3u8(dst), None
<|code_end|>
with the help of current file imports:
import os
import re
import sys
from mybs import SelStr
from comm import DWM, match1, echo, start, debug, py3, get_kind_size
from letv import LETV
and context from other files:
# Path: mybs.py
# def SelStr(sel, data):
# mp = MyHtmlParser(tidy=False)
# mp.feed(data)
# return mp.select(sel)
#
# Path: comm.py
# def echo(*args):
# def U(dat):
# def echo(*args):
# def U(dat):
# def debug(*args):
# def norm_url(url):
# def __init__(self, url, referer):
# def __init__(self, proxy=None):
# def get_html(self, url, raw=False, postdata=None):
# def get_hutf(self, *param, **dd):
# def chrome_hutf(self, url):
# def phantom_hutf(self, url, timeout=300, refer=None, postdata=None):
# def last_m3u8(self, src):
# def try_m3u8(self, src):
# def _get_m3u8_urls(self, src, data):
# def get_outfn(self, title, ext, unum=0):
# def align_title_num(self, t):
# def get_total_size(self, urllist):
# def use_dwm_merge(self, urls, title, ext, clean=True):
# def download_urls_you_get(self, title, ext, urls, totalsize):
# def get_real_url(self, bu, rt, uri):
# def try_key(self, bu, rt, dn, line):
# def wget_m3u8(self, title, url):
# def download_m3u8(self, title, url):
# def avconv_m3u8(self, title, ext, url):
# def wget_urls(self, title, ext, urls, tsize):
# def wget_one_url(self, outfn, url, unum, totalsize=0):
# def get_one(self, url, t=UTITLE, n=False):
# def try_playlist(self, ispl, url):
# def get_playlist(self, page_url):
# def clean_up(self):
# def test(self, args):
# def can_handle_it(cls, url):
# def get_kind_size(u, cookie=""):
# def get_total_size_st(urllist):
# def get_total_size_mt(urllist, tn=10):
# def worker():
# def search_first(text, *patterns):
# def match1(text, *patterns):
# def c2n(cs):
# def norm_title(title):
# def start(kls):
# def run(k, args):
# class ConnectionResetError(Exception):
# class UO(object):
# class DWM(object):
# USER_AGENT = 'Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.109 Safari/537.36'
# USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.146 Safari/537.36'
# DEBUG = False
# UTITLE = "UnknownTitle"
# DEBUG = args.debug
# DEBUG = True
, which may contain function names, class names, or code. Output only the next line. | if 'ttwanda.com/ftn_handler/' in dst: |
Based on the snippet: <|code_start|> title = SelStr("div.video-content article p strong", hutf)[0].text
r = "《(.+)》"
if not py3:
r = r.decode('utf8')
t = match1(title, r)
if t and '/films/' in url:
title = t
src = SelStr('iframe.player', hutf)[0]['src']
if '/player/v.php?url=' in src:
# http://www.ttwanda.com/tv/ustv/945.html
# ../../player/v.php?url=www.le.com/ptv/vplay/20723618.html
src = 'http://' + src.split('?url=', 1)[1]
return LETV().query_info(src)
if not src.startswith("http://") and not src.startswith("https://"):
src = 'http://www.ttwanda.com/' + src
echo(src)
self.extra_headers['Referer'] = url # this is important
hutf = self.get_hutf(src)
dst = match1(hutf, 'var play_url \= "([^"]+)"')
echo(dst)
if not dst:
echo("Can not find var play_url")
sys.exit(1)
if ('youku.com/' in dst and '/m3u8' in dst) \
or 'lecloud.com/' in dst \
or '/letv-uts/' in dst:
return title, None, self.try_m3u8(dst), None
if 'ttwanda.com/ftn_handler/' in dst:
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import re
import sys
from mybs import SelStr
from comm import DWM, match1, echo, start, debug, py3, get_kind_size
from letv import LETV
and context (classes, functions, sometimes code) from other files:
# Path: mybs.py
# def SelStr(sel, data):
# mp = MyHtmlParser(tidy=False)
# mp.feed(data)
# return mp.select(sel)
#
# Path: comm.py
# def echo(*args):
# def U(dat):
# def echo(*args):
# def U(dat):
# def debug(*args):
# def norm_url(url):
# def __init__(self, url, referer):
# def __init__(self, proxy=None):
# def get_html(self, url, raw=False, postdata=None):
# def get_hutf(self, *param, **dd):
# def chrome_hutf(self, url):
# def phantom_hutf(self, url, timeout=300, refer=None, postdata=None):
# def last_m3u8(self, src):
# def try_m3u8(self, src):
# def _get_m3u8_urls(self, src, data):
# def get_outfn(self, title, ext, unum=0):
# def align_title_num(self, t):
# def get_total_size(self, urllist):
# def use_dwm_merge(self, urls, title, ext, clean=True):
# def download_urls_you_get(self, title, ext, urls, totalsize):
# def get_real_url(self, bu, rt, uri):
# def try_key(self, bu, rt, dn, line):
# def wget_m3u8(self, title, url):
# def download_m3u8(self, title, url):
# def avconv_m3u8(self, title, ext, url):
# def wget_urls(self, title, ext, urls, tsize):
# def wget_one_url(self, outfn, url, unum, totalsize=0):
# def get_one(self, url, t=UTITLE, n=False):
# def try_playlist(self, ispl, url):
# def get_playlist(self, page_url):
# def clean_up(self):
# def test(self, args):
# def can_handle_it(cls, url):
# def get_kind_size(u, cookie=""):
# def get_total_size_st(urllist):
# def get_total_size_mt(urllist, tn=10):
# def worker():
# def search_first(text, *patterns):
# def match1(text, *patterns):
# def c2n(cs):
# def norm_title(title):
# def start(kls):
# def run(k, args):
# class ConnectionResetError(Exception):
# class UO(object):
# class DWM(object):
# USER_AGENT = 'Mozilla/5.0 (X11; Linux i686) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/48.0.2564.109 Safari/537.36'
# USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.146 Safari/537.36'
# DEBUG = False
# UTITLE = "UnknownTitle"
# DEBUG = args.debug
# DEBUG = True
. Output only the next line. | cs = ["%s=%s" % (c.name, c.value) |
Here is a snippet: <|code_start|>#! /usr/bin/python -B
# python -B
sys.dont_write_bytecode = True
def find_kls(url):
p = os.path.dirname(sys.argv[0])
n = os.path.basename(sys.argv[0])
if not p:
p = "."
dwmkls = re.compile("^class\s+(\S+)\s*\(DWM\)\:", re.M)
for fn in os.listdir(p):
if not fn.endswith(".py") or fn == n:
<|code_end|>
. Write the next line using the current file imports:
import os
import re
import sys
import imp
from comm import start, echo
and context from other files:
# Path: comm.py
# def start(kls):
# global DEBUG
# p = argparse.ArgumentParser(description='Download Web Movie')
# #, add_help=False)
# p.add_argument('url', metavar='URL', type=str, action='store',
# help='url of movie')
# p.add_argument('-i', '--info_only', action='store_true',
# help='show information only')
# p.add_argument('-o', '--output', metavar='dir', action='store',
# #help='where download file go, dir or url to post',
# help='where download file go, dir',
# default='.')
# p.add_argument('-n', '--norm_title', action='store_true',
# help='normalize title')
# p.add_argument('-p', '--playlist_only', action='store_true',
# help='try playlist only')
# p.add_argument('-P', '--not_playlist', action='store_true',
# help='not try playlist')
# p.add_argument('--playlist_top', type=int, metavar='#', action='store',
# help='only get top # of playlist', default=0)
# p.add_argument('--playlist_skip', type=int, metavar='#', action='store',
# help='skip # in playlist', default=0)
# p.add_argument('--title', metavar='TITLE', action='store',
# help='movie name if you want to define it',
# default=UTITLE)
# p.add_argument('--post_uri', metavar='URI', action='store',
# help='uri to post downloaded file')
# #p.add_argument('--wget_skip', type=int, metavar='#', action='store',
# # help='wget skip # urls in list', default=0)
# p.add_argument('--align_num', type=int, metavar='#', action='store',
# help='align number', default=0)
# p.add_argument('--cookie', metavar='COOKIE_STR', action='store',
# help='input cookie for login', default='')
# p.add_argument('--user_agent', metavar='USER_AGENT', action='store',
# help='pair with cookie for login', default='')
# p.add_argument('--no_merge', action='store_true',
# help='skip merge video pieces')
# p.add_argument('--no_check_certificate', action='store_true',
# help='not check https certificate')
# p.add_argument('--no_proxy', action='store_true',
# help='disable auto proxy')
# p.add_argument('--skim_output', action='store_true',
# help='only output data for WUI')
# p.add_argument('--avconv_m3u8', action='store_true',
# help='download m3u8 by avconv')
# p.add_argument('--debug', action='store_true',
# help='display debug message')
# p.add_argument('--testing', action='store_true',
# help='do testing')
# args = p.parse_args()
# DEBUG = args.debug
# debug(args)
#
# if not getattr(kls, 'query_info', None):
# kls = kls(args.url)
# if kls is None:
# echo("Not support ", args.url)
# sys.exit(1)
# if args.title == "":
# args.title = UTITLE
# if py3:
# kls.title = args.title
# else:
# kls.title = args.title.decode('utf8')
# kls.out_dir = args.output
# kls.no_merge = args.no_merge
# kls.no_proxy = args.no_proxy
# kls.info_only = args.info_only
# kls.align_num = args.align_num
# kls.login_cookie = args.cookie
# kls.login_agent = args.user_agent
# DWM.no_check_certificate = args.no_check_certificate
# #if args.no_check_certificate:
# if kls.no_check_certificate:
# ssl._create_default_https_context = ssl._create_unverified_context
# kls.download_urls = DWM.wget_urls
# kls.skim_output = args.skim_output
# k = kls()
# k.parsed_args = args
# if args.testing:
# DEBUG = True
# k.test(args)
# else:
# run(k, args)
#
# def echo(*args):
# sys.stdout.write(" ".join(map(str, args)) + "\n")
# sys.stdout.flush()
, which may include functions, classes, or code. Output only the next line. | continue |
Here is a snippet: <|code_start|>#! /usr/bin/python -B
# python -B
sys.dont_write_bytecode = True
def find_kls(url):
p = os.path.dirname(sys.argv[0])
n = os.path.basename(sys.argv[0])
if not p:
p = "."
dwmkls = re.compile("^class\s+(\S+)\s*\(DWM\)\:", re.M)
for fn in os.listdir(p):
if not fn.endswith(".py") or fn == n:
continue
ret = dwmkls.findall(open(fn).read())
if not ret:
continue
name = fn[:-3]
<|code_end|>
. Write the next line using the current file imports:
import os
import re
import sys
import imp
from comm import start, echo
and context from other files:
# Path: comm.py
# def start(kls):
# global DEBUG
# p = argparse.ArgumentParser(description='Download Web Movie')
# #, add_help=False)
# p.add_argument('url', metavar='URL', type=str, action='store',
# help='url of movie')
# p.add_argument('-i', '--info_only', action='store_true',
# help='show information only')
# p.add_argument('-o', '--output', metavar='dir', action='store',
# #help='where download file go, dir or url to post',
# help='where download file go, dir',
# default='.')
# p.add_argument('-n', '--norm_title', action='store_true',
# help='normalize title')
# p.add_argument('-p', '--playlist_only', action='store_true',
# help='try playlist only')
# p.add_argument('-P', '--not_playlist', action='store_true',
# help='not try playlist')
# p.add_argument('--playlist_top', type=int, metavar='#', action='store',
# help='only get top # of playlist', default=0)
# p.add_argument('--playlist_skip', type=int, metavar='#', action='store',
# help='skip # in playlist', default=0)
# p.add_argument('--title', metavar='TITLE', action='store',
# help='movie name if you want to define it',
# default=UTITLE)
# p.add_argument('--post_uri', metavar='URI', action='store',
# help='uri to post downloaded file')
# #p.add_argument('--wget_skip', type=int, metavar='#', action='store',
# # help='wget skip # urls in list', default=0)
# p.add_argument('--align_num', type=int, metavar='#', action='store',
# help='align number', default=0)
# p.add_argument('--cookie', metavar='COOKIE_STR', action='store',
# help='input cookie for login', default='')
# p.add_argument('--user_agent', metavar='USER_AGENT', action='store',
# help='pair with cookie for login', default='')
# p.add_argument('--no_merge', action='store_true',
# help='skip merge video pieces')
# p.add_argument('--no_check_certificate', action='store_true',
# help='not check https certificate')
# p.add_argument('--no_proxy', action='store_true',
# help='disable auto proxy')
# p.add_argument('--skim_output', action='store_true',
# help='only output data for WUI')
# p.add_argument('--avconv_m3u8', action='store_true',
# help='download m3u8 by avconv')
# p.add_argument('--debug', action='store_true',
# help='display debug message')
# p.add_argument('--testing', action='store_true',
# help='do testing')
# args = p.parse_args()
# DEBUG = args.debug
# debug(args)
#
# if not getattr(kls, 'query_info', None):
# kls = kls(args.url)
# if kls is None:
# echo("Not support ", args.url)
# sys.exit(1)
# if args.title == "":
# args.title = UTITLE
# if py3:
# kls.title = args.title
# else:
# kls.title = args.title.decode('utf8')
# kls.out_dir = args.output
# kls.no_merge = args.no_merge
# kls.no_proxy = args.no_proxy
# kls.info_only = args.info_only
# kls.align_num = args.align_num
# kls.login_cookie = args.cookie
# kls.login_agent = args.user_agent
# DWM.no_check_certificate = args.no_check_certificate
# #if args.no_check_certificate:
# if kls.no_check_certificate:
# ssl._create_default_https_context = ssl._create_unverified_context
# kls.download_urls = DWM.wget_urls
# kls.skim_output = args.skim_output
# k = kls()
# k.parsed_args = args
# if args.testing:
# DEBUG = True
# k.test(args)
# else:
# run(k, args)
#
# def echo(*args):
# sys.stdout.write(" ".join(map(str, args)) + "\n")
# sys.stdout.flush()
, which may include functions, classes, or code. Output only the next line. | try: |
Predict the next line after this snippet: <|code_start|>#! /usr/bin/python3 -B
try:
py3 = False
except ImportError:
<|code_end|>
using the current file's imports:
import re
import sys
import cgi
from itertools import chain
from gettext import gettext
from HTMLParser import HTMLParser
from html.parser import HTMLParser
from comm import echo
and any relevant context from other files:
# Path: comm.py
# def echo(*args):
# sys.stdout.write(" ".join(map(str, args)) + "\n")
# sys.stdout.flush()
. Output only the next line. | py3 = True |
Given snippet: <|code_start|>#-*- coding: utf-8 -*-
from __future__ import absolute_import, division, print_function, unicode_literals
class DebugToolbar(object):
@property
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from ..utils import merge_items
and context:
# Path: common_configs/utils.py
# def merge_items(base, new_items):
# """
# Merges two lists and eliminates duplicates
#
# :type base: list
# :type new_items: list
# :rtype: list
# """
# for item in new_items:
# if not item in base:
# base = base + [item]
# return base
which might include code, classes, or functions. Output only the next line. | def MIDDLEWARE_CLASSES(self): |
Predict the next line after this snippet: <|code_start|>
class Command(BaseCommand):
help = '''Starts monitoring the instance /data folder for file events,
specifically for the addition of complete DICOM series datasets'''
<|code_end|>
using the current file's imports:
from sendit.apps.watcher.commands import start_watcher
from django.core.management.base import (
BaseCommand
)
and any relevant context from other files:
# Path: sendit/apps/watcher/commands.py
# def start_watcher(request=None,as_command=False):
# '''start the watcher, if the process is not started.
# '''
#
# # Verify INOTIFIER_WATCH_PATHS is defined and non-empty
# try:
# assert settings.INOTIFIER_WATCH_PATHS
# except (AttributeError, AssertionError):
# return watcher_error(message="Missing/empty settings/watcher.py INOTIFY_WATCH_PATHS",
# as_command=as_command,
# request=request)
#
#
# # Verify INOTIFIER_WATCH_PATHS is properly formatted
# try:
# length_3 = [len(tup) == 3 for tup in settings.INOTIFIER_WATCH_PATHS]
# assert all(length_3)
# except AssertionError:
# message = '''setting INOTIFIER_WATCH_PATHS should be an iterable of
# 3-tuples of the form [ ("/path1/", <pyinotify event mask>, <processor cls>), ]'''
# return watcher_error(message=message,
# as_command=as_command,
# request=request)
#
#
# error_message = verify_monitor_paths(return_message=True)
# if error_message is not None:
# return watcher_error(message=error_message,
# as_command=as_command,
# request=request)
#
#
# # Setup watches using pyinotify
# notifier = get_notifier()
#
# # Error with import or setup returns None
# if notifier is None:
# return watcher_error(message="Cannot import pyinotify.",
# as_command=as_command,
# request=request)
#
# pid_file = get_pid_file()
#
# # Daemonize, killing any existing process specified in pid file
# daemon_kwargs = get_daemon_kwargs()
# notifier.loop(daemonize=True, pid_file=pid_file, **daemon_kwargs)
# watcher_message(message="Dicom watching has been started.",request=request)
. Output only the next line. | def handle(self, *args, **options): |
Given the following code snippet before the placeholder: <|code_start|>
class Command(BaseCommand):
help = '''show batch logs with errors'''
def add_arguments(self, parser):
parser.add_argument('bid', nargs='*', type=int)
def handle(self,*args, **options):
<|code_end|>
, predict the next line using imports from the current file:
from sendit.logger import bot
from sendit.apps.main.models import Batch
from django.core.management.base import (
BaseCommand
)
import sys
and context including class names, function names, and sometimes code from other files:
# Path: sendit/logger.py
# ABRT = -4
# ERROR = -3
# WARNING = -2
# LOG = -1
# INFO = 1
# QUIET = 0
# VERBOSE = VERBOSE1 = 2
# VERBOSE2 = 3
# VERBOSE3 = 4
# DEBUG = 5
# COLORIZE = get_user_color_preference()
# COLORIZE = os.environ.get('SENDIT_COLORIZE',None)
# COLORIZE = convert2boolean(COLORIZE)
# class SenditMessage:
# def __init__(self,MESSAGELEVEL=None):
# def useColor(self):
# def addColor(self,level,text):
# def emitError(self,level):
# def emitOutput(self,level):
# def isEnabledFor(self,messageLevel):
# def emit(self,level,message,prefix=None):
# def write(self,stream,message):
# def get_logs(self,join_newline=True):
# def show_progress(self,iteration,total,length=40,min_level=0,prefix=None,
# carriage_return=True,suffix=None,symbol=None):
# def abort(self,message):
# def error(self,message):
# def warning(self,message):
# def log(self,message):
# def info(self,message):
# def verbose(self,message):
# def verbose1(self,message):
# def verbose2(self,message):
# def verbose3(self,message):
# def debug(self,message):
# def is_quiet(self):
# def get_logging_level():
# def get_user_color_preference():
# def convert2boolean(arg):
#
# Path: sendit/apps/main/models.py
# class Batch(models.Model):
# '''A batch has one or more images for some number of patients, each of which
# is associated with a Study or Session. A batch maps cleanly to a folder that is
# dropped into data for processing, and the application moves through tasks based
# on batches.
# '''
# uid = models.CharField(max_length=200, null=False, unique=True)
#
# status = models.CharField(choices=BATCH_STATUS,
# default="NEW",
# max_length=250)
#
# add_date = models.DateTimeField('date added', auto_now_add=True)
# has_error = models.BooleanField(choices=ERROR_STATUS,
# default=False,
# verbose_name="HasError")
#
# qa = JSONField(default=dict())
# logs = JSONField(default=dict())
# modify_date = models.DateTimeField('date modified', auto_now=True)
# tags = TaggableManager()
#
# def change_images_status(self,status):
# '''change all images to have the same status'''
# for dcm in self.image_set.all():
# dcm.status = status
# dcm.save()
#
#
# def get_image_paths(self):
# '''return file paths for all images associated
# with a batch'''
# image_files = []
# for dcm in self.image_set.all():
# try:
# if hasattr(dcm.image, 'file'):
# dicom_file = dcm.image.path
# if os.path.exists(dicom_file):
# image_files.append(dicom_file)
#
# # Image object has no file associated with it
# except ValueError:
# pass
#
# return image_files
#
# def get_finished(self):
# '''return file paths that aren't in PHI folder'''
# return [ x for x in self.get_image_paths() if "/PHI/" not in x ]
#
# def get_path(self):
# return "%s/%s" %(MEDIA_ROOT,self.id)
#
# def get_absolute_url(self):
# return reverse('batch_details', args=[str(self.id)])
#
# def __str__(self):
# return "%s-%s" %(self.id,self.uid)
#
# def __unicode__(self):
# return "%s-%s" %(self.id,self.uid)
#
# def get_label(self):
# return "batch"
#
# class Meta:
# app_label = 'main'
. Output only the next line. | nbids = len(options['bid']) |
Given the code snippet: <|code_start|>
class Command(BaseCommand):
help = '''show batch logs with errors'''
def add_arguments(self, parser):
parser.add_argument('bid', nargs='*', type=int)
def handle(self,*args, **options):
nbids = len(options['bid'])
if nbids > 0:
bot.debug("Inspecting for errors for %s batch ids" %nbids)
batches = Batch.objects.filter(id__in=options['bid'],
has_error=True)
else:
batches = Batch.objects.filter(has_error=True)
if len(batches) == 0:
bot.info("There are no batches with error.")
sys.exit(1)
for batch in batches:
bot.info("\n# %s" %batch.uid)
errors = batch.logs['errors']
<|code_end|>
, generate the next line using the imports in this file:
from sendit.logger import bot
from sendit.apps.main.models import Batch
from django.core.management.base import (
BaseCommand
)
import sys
and context (functions, classes, or occasionally code) from other files:
# Path: sendit/logger.py
# ABRT = -4
# ERROR = -3
# WARNING = -2
# LOG = -1
# INFO = 1
# QUIET = 0
# VERBOSE = VERBOSE1 = 2
# VERBOSE2 = 3
# VERBOSE3 = 4
# DEBUG = 5
# COLORIZE = get_user_color_preference()
# COLORIZE = os.environ.get('SENDIT_COLORIZE',None)
# COLORIZE = convert2boolean(COLORIZE)
# class SenditMessage:
# def __init__(self,MESSAGELEVEL=None):
# def useColor(self):
# def addColor(self,level,text):
# def emitError(self,level):
# def emitOutput(self,level):
# def isEnabledFor(self,messageLevel):
# def emit(self,level,message,prefix=None):
# def write(self,stream,message):
# def get_logs(self,join_newline=True):
# def show_progress(self,iteration,total,length=40,min_level=0,prefix=None,
# carriage_return=True,suffix=None,symbol=None):
# def abort(self,message):
# def error(self,message):
# def warning(self,message):
# def log(self,message):
# def info(self,message):
# def verbose(self,message):
# def verbose1(self,message):
# def verbose2(self,message):
# def verbose3(self,message):
# def debug(self,message):
# def is_quiet(self):
# def get_logging_level():
# def get_user_color_preference():
# def convert2boolean(arg):
#
# Path: sendit/apps/main/models.py
# class Batch(models.Model):
# '''A batch has one or more images for some number of patients, each of which
# is associated with a Study or Session. A batch maps cleanly to a folder that is
# dropped into data for processing, and the application moves through tasks based
# on batches.
# '''
# uid = models.CharField(max_length=200, null=False, unique=True)
#
# status = models.CharField(choices=BATCH_STATUS,
# default="NEW",
# max_length=250)
#
# add_date = models.DateTimeField('date added', auto_now_add=True)
# has_error = models.BooleanField(choices=ERROR_STATUS,
# default=False,
# verbose_name="HasError")
#
# qa = JSONField(default=dict())
# logs = JSONField(default=dict())
# modify_date = models.DateTimeField('date modified', auto_now=True)
# tags = TaggableManager()
#
# def change_images_status(self,status):
# '''change all images to have the same status'''
# for dcm in self.image_set.all():
# dcm.status = status
# dcm.save()
#
#
# def get_image_paths(self):
# '''return file paths for all images associated
# with a batch'''
# image_files = []
# for dcm in self.image_set.all():
# try:
# if hasattr(dcm.image, 'file'):
# dicom_file = dcm.image.path
# if os.path.exists(dicom_file):
# image_files.append(dicom_file)
#
# # Image object has no file associated with it
# except ValueError:
# pass
#
# return image_files
#
# def get_finished(self):
# '''return file paths that aren't in PHI folder'''
# return [ x for x in self.get_image_paths() if "/PHI/" not in x ]
#
# def get_path(self):
# return "%s/%s" %(MEDIA_ROOT,self.id)
#
# def get_absolute_url(self):
# return reverse('batch_details', args=[str(self.id)])
#
# def __str__(self):
# return "%s-%s" %(self.id,self.uid)
#
# def __unicode__(self):
# return "%s-%s" %(self.id,self.uid)
#
# def get_label(self):
# return "batch"
#
# class Meta:
# app_label = 'main'
. Output only the next line. | for error in errors: |
Continue the code snippet: <|code_start|>
class Command(BaseCommand):
help = '''start queue will parse over:
1. First preference: a list of subfolders DATA_INPUT_FOLDERS
<|code_end|>
. Use current file imports:
from sendit.logger import bot
from django.core.management.base import BaseCommand
from sendit.apps.main.utils import start_queue
import sys
import os
and context (classes, functions, or code) from other files:
# Path: sendit/logger.py
# ABRT = -4
# ERROR = -3
# WARNING = -2
# LOG = -1
# INFO = 1
# QUIET = 0
# VERBOSE = VERBOSE1 = 2
# VERBOSE2 = 3
# VERBOSE3 = 4
# DEBUG = 5
# COLORIZE = get_user_color_preference()
# COLORIZE = os.environ.get('SENDIT_COLORIZE',None)
# COLORIZE = convert2boolean(COLORIZE)
# class SenditMessage:
# def __init__(self,MESSAGELEVEL=None):
# def useColor(self):
# def addColor(self,level,text):
# def emitError(self,level):
# def emitOutput(self,level):
# def isEnabledFor(self,messageLevel):
# def emit(self,level,message,prefix=None):
# def write(self,stream,message):
# def get_logs(self,join_newline=True):
# def show_progress(self,iteration,total,length=40,min_level=0,prefix=None,
# carriage_return=True,suffix=None,symbol=None):
# def abort(self,message):
# def error(self,message):
# def warning(self,message):
# def log(self,message):
# def info(self,message):
# def verbose(self,message):
# def verbose1(self,message):
# def verbose2(self,message):
# def verbose3(self,message):
# def debug(self,message):
# def is_quiet(self):
# def get_logging_level():
# def get_user_color_preference():
# def convert2boolean(arg):
#
# Path: sendit/apps/main/utils.py
# def start_queue(subfolder=None, max_count=None):
# '''
# start queue will be used to move new Batches (jobs) from the QUEUE to be
# run with celery tasks. The status is changed from QUEUE to NEW when this is done.
# If the QUEUE is empty, we parse the filesystem (and queue new jobs) again.
# This job submission is done all at once to ensure that we don't have race
# conditions of multiple workers trying to grab a job at the same time.
# '''
# from sendit.apps.main.tasks import import_dicomdir
#
# contenders = Batch.objects.filter(status="QUEUE")
# if len(contenders) == 0:
# update_cached(subfolder)
# contenders = Batch.objects.filter(status="QUEUE")
#
# started = 0
# for batch in contenders:
# # not seen folders in queue
# dicom_dir = batch.logs.get('DICOM_DIR')
# if dicom_dir is not None:
# import_dicomdir.apply_async(kwargs={"dicom_dir":dicom_dir})
# started +=1
# if max_count is not None:
# if started >= max_count:
# break
#
# print("Added %s tasks to the active queue." %started)
. Output only the next line. | 2. Second preference, a single subfolder at the base (eg /data/<subfolder>) |
Based on the snippet: <|code_start|># Licensed under a 3-clause BSD style license - see LICENSE.rst
# If additional pytest markers are defined the key in the dictionary below
# should be the name of the marker.
DEFAULTS = {
'seed': 123,
'data_size': 100,
'data_scale': 1.0,
'data_mean': 0.0
}
DEFAULT_SEED = 123
DEFAULT_DATA_SIZE = 100
DEFAULT_DATA_SCALE = 1.0
DEFAULT_DATA_MEAN = 0.0
def value_from_markers(key, request):
m = request.node.get_closest_marker(key)
if m is not None:
return m.args[0]
else:
return DEFAULTS[key]
<|code_end|>
, predict the immediate next line with the help of imports:
from shutil import rmtree
from astropy import units as u
from astropy.utils import NumpyRNGContext
from astropy.nddata import CCDData
from ..utils.sample_directory import directory_for_testing
import numpy as np
import pytest
and context (classes, functions, sometimes code) from other files:
# Path: ccdproc/utils/sample_directory.py
# def directory_for_testing():
# """
# Set up directory with these contents:
#
# One file with imagetyp BIAS. It has an the keyword EXPOSURE in
# the header, but no others beyond IMAGETYP and the bare minimum
# created with the FITS file.
#
# File name(s)
# ------------
#
# no_filter_no_object_bias.fit
#
# Five (5) files with imagetyp LIGHT, including two compressed
# files.
#
# + One file for each compression type, currently .gz and .fz.
# + ALL of the files will have the keyword EXPOSURE
# in the header.
# + Only ONE of them will have the value EXPOSURE=15.0.
# + All of the files EXCEPT ONE will have the keyword
# FILTER with the value 'R'.
# + NONE of the files have the keyword OBJECT
#
# File names
# ----------
#
# test.fits.fz
# filter_no_object_light.fit
# filter_object_light.fit.gz
# filter_object_light.fit
# no_filter_no_object_light.fit <---- this one has no filter
# """
# n_test = {
# 'files': 6,
# 'missing_filter_value': 1,
# 'bias': 1,
# 'compressed': 2,
# 'light': 5
# }
#
# test_dir = mkdtemp()
#
# # Directory is reset on teardown.
# original_dir = os.getcwd()
# os.chdir(test_dir)
#
# _make_file_for_testing(file_name='no_filter_no_object_bias.fit',
# imagetyp='BIAS',
# EXPOSURE=0.0)
#
# _make_file_for_testing(file_name='no_filter_no_object_light.fit',
# imagetyp='LIGHT',
# EXPOSURE=1.0)
#
# _make_file_for_testing(file_name='filter_no_object_light.fit',
# imagetyp='LIGHT',
# EXPOSURE=1.0,
# filter='R')
#
# _make_file_for_testing(file_name='filter_object_light.fit',
# imagetyp='LIGHT',
# EXPOSURE=1.0,
# filter='R')
#
# with open('filter_object_light.fit', 'rb') as f_in:
# with gzip.open('filter_object_light.fit.gz', 'wb') as f_out:
# f_out.write(f_in.read())
#
# # filter_object.writeto('filter_object_RA_keyword_light.fit')
#
# _make_file_for_testing(file_name='test.fits.fz',
# imagetyp='LIGHT',
# EXPOSURE=15.0,
# filter='R')
#
# os.chdir(original_dir)
#
# return n_test, test_dir
. Output only the next line. | def ccd_data(data_size=DEFAULT_DATA_SIZE, |
Using the snippet: <|code_start|># Licensed under a 3-clause BSD style license - see LICENSE.rst
# none of these are properly enclosed in brackets; is an error raised?
@pytest.mark.parametrize('arg',
['1:2', '[1:2', '1:2]'])
def test_slice_from_string_needs_enclosing_brackets(arg):
with pytest.raises(ValueError):
slice_from_string(arg)
@pytest.mark.parametrize('start,stop,step', [
<|code_end|>
, determine the next line of code. You have imports:
import numpy as np
import pytest
from ..slices import slice_from_string
and context (class names, function names, or code) available:
# Path: ccdproc/utils/slices.py
# def slice_from_string(string, fits_convention=False):
# """
# Convert a string to a tuple of slices.
#
# Parameters
# ----------
#
# string : str
# A string that can be converted to a slice.
#
# fits_convention : bool, optional
# If True, assume the input string follows the FITS convention for
# indexing: the indexing is one-based (not zero-based) and the first
# axis is that which changes most rapidly as the index increases.
#
# Returns
# -------
#
# slice_tuple : tuple of slice objects
# A tuple able to be used to index a numpy.array
#
# Notes
# -----
#
# The ``string`` argument can be anything that would work as a valid way to
# slice an array in Numpy. It must be enclosed in matching brackets; all
# spaces are stripped from the string before processing.
#
# Examples
# --------
#
# >>> import numpy as np
# >>> arr1d = np.arange(5)
# >>> a_slice = slice_from_string('[2:5]')
# >>> arr1d[a_slice]
# array([2, 3, 4])
# >>> a_slice = slice_from_string('[ : : -2] ')
# >>> arr1d[a_slice]
# array([4, 2, 0])
# >>> arr2d = np.array([arr1d, arr1d + 5, arr1d + 10])
# >>> arr2d
# array([[ 0, 1, 2, 3, 4],
# [ 5, 6, 7, 8, 9],
# [10, 11, 12, 13, 14]])
# >>> a_slice = slice_from_string('[1:-1, 0:4:2]')
# >>> arr2d[a_slice]
# array([[5, 7]])
# >>> a_slice = slice_from_string('[0:2,0:3]')
# >>> arr2d[a_slice]
# array([[0, 1, 2],
# [5, 6, 7]])
# """
# no_space = string.replace(' ', '')
#
# if not no_space:
# return ()
#
# if not (no_space.startswith('[') and no_space.endswith(']')):
# raise ValueError('Slice string must be enclosed in square brackets.')
#
# no_space = no_space.strip('[]')
# if fits_convention:
# # Special cases first
# # Flip dimension, with step
# no_space = no_space.replace('-*:', '::-')
# # Flip dimension
# no_space = no_space.replace('-*', '::-1')
# # Normal wildcard
# no_space = no_space.replace('*', ':')
# string_slices = no_space.split(',')
# slices = []
# for string_slice in string_slices:
# slice_args = [int(arg) if arg else None
# for arg in string_slice.split(':')]
# a_slice = slice(*slice_args)
# slices.append(a_slice)
#
# if fits_convention:
# slices = _defitsify_slice(slices)
#
# return tuple(slices)
. Output only the next line. | (None, None, -1), |
Here is a snippet: <|code_start|># Licensed under a 3-clause BSD style license - see LICENSE.rst
def test_bitfield_not_integer():
with pytest.raises(TypeError):
bitfield_to_boolean_mask(np.random.random((10, 10)))
def test_bitfield_negative_flags():
bm = np.random.randint(0, 10, (10, 10))
with pytest.raises(ValueError):
bitfield_to_boolean_mask(bm, [-1])
def test_bitfield_non_poweroftwo_flags():
bm = np.random.randint(0, 10, (10, 10))
<|code_end|>
. Write the next line using the current file imports:
import numpy as np
import pytest
from ccdproc.core import bitfield_to_boolean_mask
and context from other files:
# Path: ccdproc/core.py
# def bitfield_to_boolean_mask(bitfield, ignore_bits=0, flip_bits=None):
# """Convert an integer bit field to a boolean mask.
#
# Parameters
# ----------
# bitfield : `numpy.ndarray` of integer dtype
# The array of bit flags.
#
# ignore_bits : int, None or str, optional
# The bits to ignore when converting the bitfield.
#
# - If it's an integer it's binary representation is interpreted as the
# bits to ignore. ``0`` means that all bit flags are taken into
# account while a binary representation of all ``1`` means that all
# flags would be ignored.
# - If it's ``None`` then all flags are ignored
# - If it's a string then it must be a ``,`` or ``+`` separated string
# of integers that bits to ignore. If the string starts with an ``~``
# the integers are interpreted as **the only flags** to take into
# account.
#
# Default is ``0``.
#
# Returns
# -------
# mask : `numpy.ndarray` of boolean dtype
# The bitfield converted to a boolean mask that can be used for
# `numpy.ma.MaskedArray` or `~astropy.nddata.CCDData`.
#
# Examples
# --------
# Bitfields (or data quality arrays) are integer arrays where the binary
# representation of the values indicates whether a specific flag is set or
# not. The convention is that a value of ``0`` represents a **good value**
# and a value that is ``!= 0`` represents a value that is in some (or
# multiple) ways considered a **bad value**. The ``bitfield_to_boolean_mask``
# function can be used by default to create a boolean mask wherever any bit
# flag is set::
#
# >>> import ccdproc
# >>> import numpy as np
# >>> ccdproc.bitfield_to_boolean_mask(np.arange(8))
# array([False, True, True, True, True, True, True, True]...)
#
# To ignore all bit flags ``ignore_bits=None`` can be used::
#
# >>> ccdproc.bitfield_to_boolean_mask(np.arange(8), ignore_bits=None)
# array([False, False, False, False, False, False, False, False]...)
#
# To ignore only specific bit flags one can use a ``list`` of bits flags to
# ignore::
#
# >>> ccdproc.bitfield_to_boolean_mask(np.arange(8), ignore_bits=[1, 4])
# array([False, False, True, True, False, False, True, True]...)
#
# There are some equivalent ways::
#
# >>> # pass in the sum of the "ignore_bits" directly
# >>> ccdproc.bitfield_to_boolean_mask(np.arange(8), ignore_bits=5) # 1 + 4
# array([False, False, True, True, False, False, True, True]...)
# >>> # use a comma seperated string of integers
# >>> ccdproc.bitfield_to_boolean_mask(np.arange(8), ignore_bits='1, 4')
# array([False, False, True, True, False, False, True, True]...)
# >>> # use a + seperated string of integers
# >>> ccdproc.bitfield_to_boolean_mask(np.arange(8), ignore_bits='1+4')
# array([False, False, True, True, False, False, True, True]...)
#
# Instead of directly specifying the **bits flags to ignore** one can also
# pass in the **only bits that shouldn't be ignored** by prepending a ``~``
# to the string of ``ignore_bits`` (or if it's not a string in
# ``ignore_bits`` one can set ``flip_bits=True``)::
#
# >>> # ignore all bit flags except the one for 2.
# >>> ccdproc.bitfield_to_boolean_mask(np.arange(8), ignore_bits='~(2)')
# array([False, False, True, True, False, False, True, True]...)
# >>> # ignore all bit flags except the one for 1, 8 and 32.
# >>> ccdproc.bitfield_to_boolean_mask(np.arange(8), ignore_bits='~(1, 8, 32)')
# array([False, True, False, True, False, True, False, True]...)
#
# >>> # Equivalent for a list using flip_bits.
# >>> ccdproc.bitfield_to_boolean_mask(np.arange(8), ignore_bits=[1, 8, 32], flip_bits=True)
# array([False, True, False, True, False, True, False, True]...)
#
# """
# return _bitfield_to_boolean_mask(
# bitfield, ignore_bits, flip_bits=flip_bits,
# good_mask_value=False, dtype=bool)
, which may include functions, classes, or code. Output only the next line. | with pytest.raises(ValueError): |
Predict the next line for this snippet: <|code_start|># Licensed under a 3-clause BSD style license - see LICENSE.rst
logger = logging.getLogger(__name__)
__all__ = ['ImageFileCollection']
__doctest_skip__ = ['*']
<|code_end|>
with the help of current file imports:
from collections import OrderedDict
from os import listdir, path
from astropy.table import Table, MaskedColumn
from astropy.utils import minversion
from astropy.utils.exceptions import AstropyUserWarning
from .ccddata import fits_ccddata_reader, _recognized_fits_file_extensions
import fnmatch
import re
import logging
import numpy as np
import numpy.ma as ma
import astropy.io.fits as fits
import warnings
and context from other files:
# Path: ccdproc/ccddata.py
, which may contain function names, class names, or code. Output only the next line. | _ASTROPY_LT_1_3 = not minversion("astropy", "1.3") |
Continue the code snippet: <|code_start|>
def test_medianfilter_correct():
ccd = CCDData([[2, 6, 6, 1, 7, 2, 4, 5, 9, 1],
[10, 10, 9, 0, 2, 10, 8, 3, 9, 7],
[2, 4, 0, 4, 4, 10, 0, 5, 6, 5],
[7, 10, 8, 7, 7, 0, 5, 3, 5, 9],
[9, 6, 3, 8, 6, 9, 2, 8, 10, 10],
[6, 5, 1, 7, 8, 0, 8, 2, 9, 3],
[0, 6, 0, 6, 3, 10, 8, 9, 7, 8],
[5, 8, 3, 2, 3, 0, 2, 0, 3, 5],
[9, 6, 3, 7, 1, 0, 5, 4, 8, 3],
[5, 6, 9, 9, 0, 4, 9, 1, 7, 8]], unit='adu')
result = core.median_filter(ccd, 3)
assert isinstance(result, CCDData)
assert np.all(result.data == [[6, 6, 6, 6, 2, 4, 4, 5, 5, 7],
[4, 6, 4, 4, 4, 4, 5, 5, 5, 6],
[7, 8, 7, 4, 4, 5, 5, 5, 5, 7],
[7, 6, 6, 6, 7, 5, 5, 5, 6, 9],
[7, 6, 7, 7, 7, 6, 3, 5, 8, 9],
[6, 5, 6, 6, 7, 8, 8, 8, 8, 8],
[5, 5, 5, 3, 3, 3, 2, 7, 5, 5],
[6, 5, 6, 3, 3, 3, 4, 5, 5, 5],
[6, 6, 6, 3, 2, 2, 2, 4, 4, 5],
[6, 6, 7, 7, 4, 4, 4, 7, 7, 8]])
assert result.unit == 'adu'
<|code_end|>
. Use current file imports:
import numpy as np
from astropy.nddata import StdDevUncertainty, CCDData
from scipy import ndimage
from ccdproc import core
and context (classes, functions, or code) from other files:
# Path: ccdproc/core.py
# def ccd_process(ccd, oscan=None, trim=None, error=False, master_bias=None,
# dark_frame=None, master_flat=None, bad_pixel_mask=None,
# gain=None, readnoise=None, oscan_median=True, oscan_model=None,
# min_value=None, dark_exposure=None, data_exposure=None,
# exposure_key=None, exposure_unit=None,
# dark_scale=False, gain_corrected=True):
# def create_deviation(ccd_data, gain=None, readnoise=None, disregard_nan=False):
# def subtract_overscan(ccd, overscan=None, overscan_axis=1, fits_section=None,
# median=False, model=None):
# def trim_image(ccd, fits_section=None):
# def subtract_bias(ccd, master):
# def subtract_dark(ccd, master, dark_exposure=None, data_exposure=None,
# exposure_time=None, exposure_unit=None,
# scale=False):
# def gain_correct(ccd, gain, gain_unit=None):
# def flat_correct(ccd, flat, min_value=None, norm_value=None):
# def transform_image(ccd, transform_func, **kwargs):
# def wcs_project(ccd, target_wcs, target_shape=None, order='bilinear'):
# def sigma_func(arr, axis=None, ignore_nan=False):
# def setbox(x, y, mbox, xmax, ymax):
# def background_deviation_box(data, bbox):
# def background_deviation_filter(data, bbox):
# def rebin(ccd, newshape):
# def block_reduce(ccd, block_size, func=np.sum):
# def block_average(ccd, block_size):
# def block_replicate(ccd, block_size, conserve_sum=True):
# def _blkavg(data, newshape):
# def median_filter(data, *args, **kwargs):
# def cosmicray_lacosmic(ccd, sigclip=4.5, sigfrac=0.3,
# objlim=5.0, gain=1.0, readnoise=6.5,
# satlevel=65535.0, pssl=0.0, niter=4,
# sepmed=True, cleantype='meanmask', fsmode='median',
# psfmodel='gauss', psffwhm=2.5, psfsize=7,
# psfk=None, psfbeta=4.765, verbose=False,
# gain_apply=True,
# inbkg=None, invar=None):
# def _astroscrappy_gain_apply_helper(cleaned_data, gain,
# gain_apply, old_interface):
# def cosmicray_median(ccd, error_image=None, thresh=5, mbox=11, gbox=0,
# rbox=0):
# def ccdmask(ratio, findbadcolumns=False, byblocks=False, ncmed=7, nlmed=7,
# ncsig=15, nlsig=15, lsigma=9, hsigma=9, ngood=5):
# def _sigma_mask(baseline, one_sigma_value, lower_sigma, upper_sigma):
# def bitfield_to_boolean_mask(bitfield, ignore_bits=0, flip_bits=None):
# def __init__(self, name, unit=None, value=None):
# def name(self):
# def unit(self):
# def value(self):
# def value(self, value):
# def value_from(self, header):
# class Keyword:
. Output only the next line. | assert all(getattr(result, attr) is None |
Given the code snippet: <|code_start|> assert key.name == key_name
assert key.unit == u.second
def test_keyword_properties_read_only():
key = Keyword('observer')
with pytest.raises(AttributeError):
key.name = 'error'
with pytest.raises(AttributeError):
key.unit = u.hour
unit = u.second
numerical_value = 30
# The variable "expected" below is
# True if the expected result is key.value == numerical_value * key.unit
# Name of an error if an error is expected
# A string if the expected value is a string
@pytest.mark.parametrize('value,unit,expected', [
(numerical_value, unit, True),
(numerical_value, None, ValueError),
(numerical_value * unit, None, True),
(numerical_value * unit, unit, True),
(numerical_value * unit, u.km, True),
('some string', None, 'some string'),
('no strings with unit', unit, ValueError)
])
def test_value_setting(value, unit, expected):
<|code_end|>
, generate the next line using the imports in this file:
import pytest
from astropy import units as u
from astropy.io import fits
from ccdproc.core import Keyword
and context (functions, classes, or occasionally code) from other files:
# Path: ccdproc/core.py
# class Keyword:
# """
# """
# def __init__(self, name, unit=None, value=None):
# self._name = name
# self._unit = unit
# self.value = value
#
# @property
# def name(self):
# return self._name
#
# @property
# def unit(self):
# return self._unit
#
# @property
# def value(self):
# return self._value
#
# @value.setter
# def value(self, value):
# if value is None:
# self._value = value
# elif isinstance(value, Quantity):
# self._unit = value.unit
# self._value = value
# elif isinstance(value, str):
# if self.unit is not None:
# raise ValueError("keyword with a unit cannot have a "
# "string value.")
# else:
# self._value = value
# else:
# if self.unit is None:
# raise ValueError("no unit provided. Set value with "
# "an astropy.units.Quantity.")
# self._value = value * self.unit
#
# def value_from(self, header):
# """
# Set value of keyword from FITS header.
#
# Parameters
# ----------
# header : `~astropy.io.fits.Header`
# FITS header containing a value for this keyword.
# """
# value_from_header = header[self.name]
# self.value = value_from_header
# return self.value
. Output only the next line. | name = 'exposure' |
Given the code snippet: <|code_start|>def test_rebin_smaller():
ccd_data = ccd_data_func(data_size=10)
a = ccd_data.data
with pytest.warns(AstropyDeprecationWarning):
b = rebin(a, (20, 20))
c = rebin(b, (10, 10))
assert c.shape == (10, 10)
assert (c - a).sum() == 0
# test rebinning with ccddata object
@pytest.mark.parametrize('mask_data, uncertainty', [
(False, False),
(True, True)])
def test_rebin_ccddata(mask_data, uncertainty):
ccd_data = ccd_data_func(data_size=10)
if mask_data:
ccd_data.mask = np.zeros_like(ccd_data)
if uncertainty:
err = np.random.normal(size=ccd_data.shape)
ccd_data.uncertainty = StdDevUncertainty(err)
with pytest.warns(AstropyDeprecationWarning):
b = rebin(ccd_data, (20, 20))
assert b.shape == (20, 20)
if mask_data:
assert b.mask.shape == (20, 20)
if uncertainty:
<|code_end|>
, generate the next line using the imports in this file:
import numpy as np
import pytest
from astropy.nddata import StdDevUncertainty
from astropy.utils.exceptions import AstropyDeprecationWarning
from ccdproc.core import rebin
from ccdproc.tests.pytest_fixtures import ccd_data as ccd_data_func
and context (functions, classes, or occasionally code) from other files:
# Path: ccdproc/core.py
# @deprecated('1.1',
# message='The rebin function will be removed in ccdproc 3.0 '
# 'Use block_reduce or block_replicate instead.')
# def rebin(ccd, newshape):
# """
# Rebin an array to have a new shape.
#
# Parameters
# ----------
# ccd : `~astropy.nddata.CCDData` or `numpy.ndarray`
# Data to rebin.
#
# newshape : tuple
# Tuple containing the new shape for the array.
#
# Returns
# -------
# output : `~astropy.nddata.CCDData` or `numpy.ndarray`
# An array with the new shape. It will have the same type as the input
# object.
#
# Raises
# ------
# TypeError
# A type error is raised if data is not an `numpy.ndarray` or
# `~astropy.nddata.CCDData`.
#
# ValueError
# A value error is raised if the dimension of the new shape is not equal
# to the data's.
#
# Notes
# -----
# This is based on the scipy cookbook for rebinning:
# http://wiki.scipy.org/Cookbook/Rebinning
#
# If rebinning a CCDData object to a smaller shape, the masking and
# uncertainty are not handled correctly.
#
# Examples
# --------
# Given an array that is 100x100::
#
# import numpy as np
# from astropy import units as u
# arr1 = CCDData(np.ones([10, 10]), unit=u.adu)
#
# The syntax for rebinning an array to a shape
# of (20,20) is::
#
# rebin(arr1, (20,20))
# """
# # check to see that is in a nddata type
# if isinstance(ccd, np.ndarray):
#
# # check to see that the two arrays are going to be the same length
# if len(ccd.shape) != len(newshape):
# raise ValueError('newshape does not have the same dimensions as '
# 'ccd.')
#
# slices = [slice(0, old, old/new) for old, new in
# zip(ccd.shape, newshape)]
# coordinates = np.mgrid[slices]
# indices = coordinates.astype('i')
# return ccd[tuple(indices)]
#
# elif isinstance(ccd, CCDData):
# # check to see that the two arrays are going to be the same length
# if len(ccd.shape) != len(newshape):
# raise ValueError('newshape does not have the same dimensions as '
# 'ccd.')
#
# nccd = ccd.copy()
# # rebin the data plane
# nccd.data = rebin(nccd.data, newshape)
#
# # rebin the uncertainty plane
# if nccd.uncertainty is not None:
# nccd.uncertainty.array = rebin(nccd.uncertainty.array, newshape)
#
# # rebin the mask plane
# if nccd.mask is not None:
# nccd.mask = rebin(nccd.mask, newshape)
#
# return nccd
# else:
# raise TypeError('ccd is not an ndarray or a CCDData object.')
#
# Path: ccdproc/tests/pytest_fixtures.py
# def ccd_data(data_size=DEFAULT_DATA_SIZE,
# data_scale=DEFAULT_DATA_SCALE,
# data_mean=DEFAULT_DATA_MEAN,
# rng_seed=DEFAULT_SEED):
# """
# Return a CCDData object with units of ADU.
#
# The size of the data array is 100x100 but can be changed using the marker
# @pytest.mark.data_size(N) on the test function, where N should be the
# desired dimension.
#
# Data values are initialized to random numbers drawn from a normal
# distribution with mean of 0 and scale 1.
#
# The scale can be changed with the marker @pytest.marker.scale(s) on the
# test function, where s is the desired scale.
#
# The mean can be changed with the marker @pytest.marker.scale(m) on the
# test function, where m is the desired mean.
# """
# size = data_size
# scale = data_scale
# mean = data_mean
#
# with NumpyRNGContext(rng_seed):
# data = np.random.normal(loc=mean, size=[size, size], scale=scale)
#
# fake_meta = {'my_key': 42, 'your_key': 'not 42'}
# ccd = CCDData(data, unit=u.adu)
# ccd.header = fake_meta
# return ccd
. Output only the next line. | assert b.uncertainty.array.shape == (20, 20) |
Continue the code snippet: <|code_start|>
# test rebinning ndarray
def test_rebin_ndarray():
with pytest.raises(TypeError), pytest.warns(AstropyDeprecationWarning):
rebin(1, (5, 5))
# test rebinning dimensions
def test_rebin_dimensions():
ccd_data = ccd_data_func(data_size=10)
with pytest.raises(ValueError), pytest.warns(AstropyDeprecationWarning):
rebin(ccd_data.data, (5,))
# test rebinning dimensions
def test_rebin_ccddata_dimensions():
ccd_data = ccd_data_func(data_size=10)
with pytest.raises(ValueError), pytest.warns(AstropyDeprecationWarning):
rebin(ccd_data, (5,))
# test rebinning works
def test_rebin_larger():
ccd_data = ccd_data_func(data_size=10)
a = ccd_data.data
with pytest.warns(AstropyDeprecationWarning):
b = rebin(a, (20, 20))
assert b.shape == (20, 20)
<|code_end|>
. Use current file imports:
import numpy as np
import pytest
from astropy.nddata import StdDevUncertainty
from astropy.utils.exceptions import AstropyDeprecationWarning
from ccdproc.core import rebin
from ccdproc.tests.pytest_fixtures import ccd_data as ccd_data_func
and context (classes, functions, or code) from other files:
# Path: ccdproc/core.py
# @deprecated('1.1',
# message='The rebin function will be removed in ccdproc 3.0 '
# 'Use block_reduce or block_replicate instead.')
# def rebin(ccd, newshape):
# """
# Rebin an array to have a new shape.
#
# Parameters
# ----------
# ccd : `~astropy.nddata.CCDData` or `numpy.ndarray`
# Data to rebin.
#
# newshape : tuple
# Tuple containing the new shape for the array.
#
# Returns
# -------
# output : `~astropy.nddata.CCDData` or `numpy.ndarray`
# An array with the new shape. It will have the same type as the input
# object.
#
# Raises
# ------
# TypeError
# A type error is raised if data is not an `numpy.ndarray` or
# `~astropy.nddata.CCDData`.
#
# ValueError
# A value error is raised if the dimension of the new shape is not equal
# to the data's.
#
# Notes
# -----
# This is based on the scipy cookbook for rebinning:
# http://wiki.scipy.org/Cookbook/Rebinning
#
# If rebinning a CCDData object to a smaller shape, the masking and
# uncertainty are not handled correctly.
#
# Examples
# --------
# Given an array that is 100x100::
#
# import numpy as np
# from astropy import units as u
# arr1 = CCDData(np.ones([10, 10]), unit=u.adu)
#
# The syntax for rebinning an array to a shape
# of (20,20) is::
#
# rebin(arr1, (20,20))
# """
# # check to see that is in a nddata type
# if isinstance(ccd, np.ndarray):
#
# # check to see that the two arrays are going to be the same length
# if len(ccd.shape) != len(newshape):
# raise ValueError('newshape does not have the same dimensions as '
# 'ccd.')
#
# slices = [slice(0, old, old/new) for old, new in
# zip(ccd.shape, newshape)]
# coordinates = np.mgrid[slices]
# indices = coordinates.astype('i')
# return ccd[tuple(indices)]
#
# elif isinstance(ccd, CCDData):
# # check to see that the two arrays are going to be the same length
# if len(ccd.shape) != len(newshape):
# raise ValueError('newshape does not have the same dimensions as '
# 'ccd.')
#
# nccd = ccd.copy()
# # rebin the data plane
# nccd.data = rebin(nccd.data, newshape)
#
# # rebin the uncertainty plane
# if nccd.uncertainty is not None:
# nccd.uncertainty.array = rebin(nccd.uncertainty.array, newshape)
#
# # rebin the mask plane
# if nccd.mask is not None:
# nccd.mask = rebin(nccd.mask, newshape)
#
# return nccd
# else:
# raise TypeError('ccd is not an ndarray or a CCDData object.')
#
# Path: ccdproc/tests/pytest_fixtures.py
# def ccd_data(data_size=DEFAULT_DATA_SIZE,
# data_scale=DEFAULT_DATA_SCALE,
# data_mean=DEFAULT_DATA_MEAN,
# rng_seed=DEFAULT_SEED):
# """
# Return a CCDData object with units of ADU.
#
# The size of the data array is 100x100 but can be changed using the marker
# @pytest.mark.data_size(N) on the test function, where N should be the
# desired dimension.
#
# Data values are initialized to random numbers drawn from a normal
# distribution with mean of 0 and scale 1.
#
# The scale can be changed with the marker @pytest.marker.scale(s) on the
# test function, where s is the desired scale.
#
# The mean can be changed with the marker @pytest.marker.scale(m) on the
# test function, where m is the desired mean.
# """
# size = data_size
# scale = data_scale
# mean = data_mean
#
# with NumpyRNGContext(rng_seed):
# data = np.random.normal(loc=mean, size=[size, size], scale=scale)
#
# fake_meta = {'my_key': 42, 'your_key': 'not 42'}
# ccd = CCDData(data, unit=u.adu)
# ccd.header = fake_meta
# return ccd
. Output only the next line. | np.testing.assert_almost_equal(b.sum(), 4 * a.sum()) |
Predict the next line after this snippet: <|code_start|>
class SmtpServerDetailView(DetailView):
model = SmtpServer
class SmtpServerUpdateView(UpdateView):
model = SmtpServer
class SmtpServerListView(ListView):
model = SmtpServer
# Create your views here.
#, JsonResponse Django 1.7
def debug(*args):
#return
print(">>>>>>")
for arg in args:
pprint(arg)
print("<<<<<<")
try:
except:
<|code_end|>
using the current file's imports:
from django.views.generic import (
CreateView,
DeleteView,
DetailView,
UpdateView,
ListView
)
from .models import (
ImapServer,
SmtpServer,
)
from .forms import (
ImapServerForm,
SmtpServerForm,
)
from pprint import pprint
from django.shortcuts import render, render_to_response, HttpResponse
from django.contrib.auth.decorators import login_required
from django.http import HttpResponseRedirect
from django.template import RequestContext
from django.urls import reverse
from django.core.mail import send_mail, BadHeaderError#, EmailMultiAlternatives
import codecs
import email
import json
import smtplib
import sys
import imapclient
import imaplib
import ssl
and any relevant context from other files:
# Path: simone/models.py
# class ImapServer(models.Model):
# user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
# address = models.CharField(max_length=255,null=True)
# port = models.IntegerField(default=143,null=True)
# username = models.CharField(max_length=255,null=True)
# passwd = models.CharField(max_length=255,null=True)
# ssl = models.BooleanField(default=False)
# def __str__(self):
# if not self.address and not self.port and not self.username and not self.passwd:
# return 'None'
# if self.ssl:
# return '%s@imaps://%s:%s' % (self.username, self.address, self.port)
# return '%s@imap://%s:%s' % (self.username, self.address, self.port)
#
# class SmtpServer(models.Model):
# user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
# address = models.CharField(max_length=255,null=True)
# port = models.IntegerField(default=25,null=True)
# username = models.CharField(max_length=255,null=True)
# passwd = models.CharField("Password", max_length=255,null=True)
# def __str__(self):
# if not self.address and not self.port and not self.username and not self.passwd:
# return 'None'
# return '%s@smtp://%s:%s' % (self.username, self.address, self.port)
#
# Path: simone/forms.py
# class ImapServerForm(forms.ModelForm):
# class Meta:
# model = ImapServer
# exclude = ['user']
# widgets = {
# 'passwd': forms.PasswordInput(),
# }
#
# class SmtpServerForm(forms.ModelForm):
# class Meta:
# model = SmtpServer
# exclude = ['user']
# widgets = {
# 'passwd': forms.PasswordInput(),
# }
. Output only the next line. | print("imapclient module not available, please install it (pip install imapclient)") |
Predict the next line after this snippet: <|code_start|>class ImapServerDetailView(DetailView):
model = ImapServer
class ImapServerUpdateView(UpdateView):
model = ImapServer
class ImapServerListView(ListView):
model = ImapServer
class SmtpServerCreateView(CreateView):
model = SmtpServer
class SmtpServerDeleteView(DeleteView):
model = SmtpServer
class SmtpServerDetailView(DetailView):
model = SmtpServer
<|code_end|>
using the current file's imports:
from django.views.generic import (
CreateView,
DeleteView,
DetailView,
UpdateView,
ListView
)
from .models import (
ImapServer,
SmtpServer,
)
from .forms import (
ImapServerForm,
SmtpServerForm,
)
from pprint import pprint
from django.shortcuts import render, render_to_response, HttpResponse
from django.contrib.auth.decorators import login_required
from django.http import HttpResponseRedirect
from django.template import RequestContext
from django.urls import reverse
from django.core.mail import send_mail, BadHeaderError#, EmailMultiAlternatives
import codecs
import email
import json
import smtplib
import sys
import imapclient
import imaplib
import ssl
and any relevant context from other files:
# Path: simone/models.py
# class ImapServer(models.Model):
# user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
# address = models.CharField(max_length=255,null=True)
# port = models.IntegerField(default=143,null=True)
# username = models.CharField(max_length=255,null=True)
# passwd = models.CharField(max_length=255,null=True)
# ssl = models.BooleanField(default=False)
# def __str__(self):
# if not self.address and not self.port and not self.username and not self.passwd:
# return 'None'
# if self.ssl:
# return '%s@imaps://%s:%s' % (self.username, self.address, self.port)
# return '%s@imap://%s:%s' % (self.username, self.address, self.port)
#
# class SmtpServer(models.Model):
# user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
# address = models.CharField(max_length=255,null=True)
# port = models.IntegerField(default=25,null=True)
# username = models.CharField(max_length=255,null=True)
# passwd = models.CharField("Password", max_length=255,null=True)
# def __str__(self):
# if not self.address and not self.port and not self.username and not self.passwd:
# return 'None'
# return '%s@smtp://%s:%s' % (self.username, self.address, self.port)
#
# Path: simone/forms.py
# class ImapServerForm(forms.ModelForm):
# class Meta:
# model = ImapServer
# exclude = ['user']
# widgets = {
# 'passwd': forms.PasswordInput(),
# }
#
# class SmtpServerForm(forms.ModelForm):
# class Meta:
# model = SmtpServer
# exclude = ['user']
# widgets = {
# 'passwd': forms.PasswordInput(),
# }
. Output only the next line. | class SmtpServerUpdateView(UpdateView): |
Given the following code snippet before the placeholder: <|code_start|> #if imap.has_capability(u'MOVE'):
# rtext = imap.move(uids, newfolder)
#else:
# raise # I'm lazy, if their server doesn't support move, neither do we
rtext1 = imap.copy(uids, newfolder)
rtext2 = imap.delete_messages(uids)
rtext3 = imap.expunge()
rtext.extend(rtext1)
rtext.extend(rtext2)
rtext.extend(rtext3)
except:
rstat = 'FAILURE'
imap.logout()
return HttpResponse(json.dumps({'status':rstat, 'msg': str(rtext)}))
def escape(s, quote=None):
'''replace special characters "&", "<" and ">" to HTML-safe sequences.
If the optional flag quote is true, the quotation mark character (")
is also translated.
copied from python's cgi module and slightly
massaged.'''
if s is None:
return ""
try:
<|code_end|>
, predict the next line using imports from the current file:
from django.views.generic import (
CreateView,
DeleteView,
DetailView,
UpdateView,
ListView
)
from .models import (
ImapServer,
SmtpServer,
)
from .forms import (
ImapServerForm,
SmtpServerForm,
)
from pprint import pprint
from django.shortcuts import render, render_to_response, HttpResponse
from django.contrib.auth.decorators import login_required
from django.http import HttpResponseRedirect
from django.template import RequestContext
from django.urls import reverse
from django.core.mail import send_mail, BadHeaderError#, EmailMultiAlternatives
import codecs
import email
import json
import smtplib
import sys
import imapclient
import imaplib
import ssl
and context including class names, function names, and sometimes code from other files:
# Path: simone/models.py
# class ImapServer(models.Model):
# user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
# address = models.CharField(max_length=255,null=True)
# port = models.IntegerField(default=143,null=True)
# username = models.CharField(max_length=255,null=True)
# passwd = models.CharField(max_length=255,null=True)
# ssl = models.BooleanField(default=False)
# def __str__(self):
# if not self.address and not self.port and not self.username and not self.passwd:
# return 'None'
# if self.ssl:
# return '%s@imaps://%s:%s' % (self.username, self.address, self.port)
# return '%s@imap://%s:%s' % (self.username, self.address, self.port)
#
# class SmtpServer(models.Model):
# user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
# address = models.CharField(max_length=255,null=True)
# port = models.IntegerField(default=25,null=True)
# username = models.CharField(max_length=255,null=True)
# passwd = models.CharField("Password", max_length=255,null=True)
# def __str__(self):
# if not self.address and not self.port and not self.username and not self.passwd:
# return 'None'
# return '%s@smtp://%s:%s' % (self.username, self.address, self.port)
#
# Path: simone/forms.py
# class ImapServerForm(forms.ModelForm):
# class Meta:
# model = ImapServer
# exclude = ['user']
# widgets = {
# 'passwd': forms.PasswordInput(),
# }
#
# class SmtpServerForm(forms.ModelForm):
# class Meta:
# model = SmtpServer
# exclude = ['user']
# widgets = {
# 'passwd': forms.PasswordInput(),
# }
. Output only the next line. | s2, enc = email.header.decode_header(s)[0] |
Given the following code snippet before the placeholder: <|code_start|> rtext2 = imap.delete_messages(uids)
rtext3 = imap.expunge()
rtext.extend(rtext1)
rtext.extend(rtext2)
rtext.extend(rtext3)
except:
rstat = 'FAILURE'
imap.logout()
return HttpResponse(json.dumps({'status':rstat, 'msg': str(rtext)}))
def escape(s, quote=None):
'''replace special characters "&", "<" and ">" to HTML-safe sequences.
If the optional flag quote is true, the quotation mark character (")
is also translated.
copied from python's cgi module and slightly
massaged.'''
if s is None:
return ""
try:
s2, enc = email.header.decode_header(s)[0]
if isinstance(s2, str):
#debug('s2', s2)
s = s2
else:
<|code_end|>
, predict the next line using imports from the current file:
from django.views.generic import (
CreateView,
DeleteView,
DetailView,
UpdateView,
ListView
)
from .models import (
ImapServer,
SmtpServer,
)
from .forms import (
ImapServerForm,
SmtpServerForm,
)
from pprint import pprint
from django.shortcuts import render, render_to_response, HttpResponse
from django.contrib.auth.decorators import login_required
from django.http import HttpResponseRedirect
from django.template import RequestContext
from django.urls import reverse
from django.core.mail import send_mail, BadHeaderError#, EmailMultiAlternatives
import codecs
import email
import json
import smtplib
import sys
import imapclient
import imaplib
import ssl
and context including class names, function names, and sometimes code from other files:
# Path: simone/models.py
# class ImapServer(models.Model):
# user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
# address = models.CharField(max_length=255,null=True)
# port = models.IntegerField(default=143,null=True)
# username = models.CharField(max_length=255,null=True)
# passwd = models.CharField(max_length=255,null=True)
# ssl = models.BooleanField(default=False)
# def __str__(self):
# if not self.address and not self.port and not self.username and not self.passwd:
# return 'None'
# if self.ssl:
# return '%s@imaps://%s:%s' % (self.username, self.address, self.port)
# return '%s@imap://%s:%s' % (self.username, self.address, self.port)
#
# class SmtpServer(models.Model):
# user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
# address = models.CharField(max_length=255,null=True)
# port = models.IntegerField(default=25,null=True)
# username = models.CharField(max_length=255,null=True)
# passwd = models.CharField("Password", max_length=255,null=True)
# def __str__(self):
# if not self.address and not self.port and not self.username and not self.passwd:
# return 'None'
# return '%s@smtp://%s:%s' % (self.username, self.address, self.port)
#
# Path: simone/forms.py
# class ImapServerForm(forms.ModelForm):
# class Meta:
# model = ImapServer
# exclude = ['user']
# widgets = {
# 'passwd': forms.PasswordInput(),
# }
#
# class SmtpServerForm(forms.ModelForm):
# class Meta:
# model = SmtpServer
# exclude = ['user']
# widgets = {
# 'passwd': forms.PasswordInput(),
# }
. Output only the next line. | s = s2.decode(enc) |
Continue the code snippet: <|code_start|>
class ImapServerForm(forms.ModelForm):
class Meta:
model = ImapServer
exclude = ['user']
widgets = {
<|code_end|>
. Use current file imports:
from django import forms
from .models import ImapServer, SmtpServer
and context (classes, functions, or code) from other files:
# Path: simone/models.py
# class ImapServer(models.Model):
# user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
# address = models.CharField(max_length=255,null=True)
# port = models.IntegerField(default=143,null=True)
# username = models.CharField(max_length=255,null=True)
# passwd = models.CharField(max_length=255,null=True)
# ssl = models.BooleanField(default=False)
# def __str__(self):
# if not self.address and not self.port and not self.username and not self.passwd:
# return 'None'
# if self.ssl:
# return '%s@imaps://%s:%s' % (self.username, self.address, self.port)
# return '%s@imap://%s:%s' % (self.username, self.address, self.port)
#
# class SmtpServer(models.Model):
# user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
# address = models.CharField(max_length=255,null=True)
# port = models.IntegerField(default=25,null=True)
# username = models.CharField(max_length=255,null=True)
# passwd = models.CharField("Password", max_length=255,null=True)
# def __str__(self):
# if not self.address and not self.port and not self.username and not self.passwd:
# return 'None'
# return '%s@smtp://%s:%s' % (self.username, self.address, self.port)
. Output only the next line. | 'passwd': forms.PasswordInput(), |
Next line prediction: <|code_start|>
class ImapServerForm(forms.ModelForm):
class Meta:
model = ImapServer
exclude = ['user']
widgets = {
'passwd': forms.PasswordInput(),
}
<|code_end|>
. Use current file imports:
(from django import forms
from .models import ImapServer, SmtpServer)
and context including class names, function names, or small code snippets from other files:
# Path: simone/models.py
# class ImapServer(models.Model):
# user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
# address = models.CharField(max_length=255,null=True)
# port = models.IntegerField(default=143,null=True)
# username = models.CharField(max_length=255,null=True)
# passwd = models.CharField(max_length=255,null=True)
# ssl = models.BooleanField(default=False)
# def __str__(self):
# if not self.address and not self.port and not self.username and not self.passwd:
# return 'None'
# if self.ssl:
# return '%s@imaps://%s:%s' % (self.username, self.address, self.port)
# return '%s@imap://%s:%s' % (self.username, self.address, self.port)
#
# class SmtpServer(models.Model):
# user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
# address = models.CharField(max_length=255,null=True)
# port = models.IntegerField(default=25,null=True)
# username = models.CharField(max_length=255,null=True)
# passwd = models.CharField("Password", max_length=255,null=True)
# def __str__(self):
# if not self.address and not self.port and not self.username and not self.passwd:
# return 'None'
# return '%s@smtp://%s:%s' % (self.username, self.address, self.port)
. Output only the next line. | class SmtpServerForm(forms.ModelForm): |
Next line prediction: <|code_start|> rts = model(imgLR, disc_aux)
torch.cuda.synchronize()
ttime = (time.time() - start_time); print('time = %.2f' % (ttime*1000) )
flow, logmid, occ, biseg, objseg = rts
# upsampling
flow = torch.squeeze(flow).data.cpu().numpy()
flow = np.concatenate( [cv2.resize(flow[0],(input_size[1],input_size[0]))[:,:,np.newaxis],
cv2.resize(flow[1],(input_size[1],input_size[0]))[:,:,np.newaxis]],-1)
flow[:,:,0] *= imgL_o.shape[1] / max_w
flow[:,:,1] *= imgL_o.shape[0] / max_h
flow = np.concatenate( (flow, np.ones([flow.shape[0],flow.shape[1],1])),-1)
torch.cuda.empty_cache()
flow = torch.Tensor(flow).cuda()[None]
return flow
def preprocess_image(img,mask,imgsize):
if len(img.shape) == 2:
img = np.repeat(np.expand_dims(img, 2), 3, axis=2)
mask = mask[:,:,:1]
# crop box
indices = np.where(mask>0); xid = indices[1]; yid = indices[0]
center = ( (xid.max()+xid.min())//2, (yid.max()+yid.min())//2)
length = ( (xid.max()-xid.min())//2, (yid.max()-yid.min())//2)
maxlength = int(1.2*max(length))
length = (maxlength,maxlength)
alp = 2*length[0]/float(imgsize)
refpp = np.asarray(center)/(imgsize/2.) - 1
<|code_end|>
. Use current file imports:
(import time
import sys, os
import torch
import torch.nn as nn
import ext_utils.flowlib as flowlib
import matplotlib.pyplot as plt
import numpy as np
import torch
import cv2
import pdb
import soft_renderer as sr
import argparse
import trimesh
from torch.autograd import Variable
from ext_utils.badja_data import BADJAData
from ext_utils.joint_catalog import SMALJointInfo
from nnutils.geom_utils import obj_to_cam, pinhole_cam, orthographic_cam, render_flow_soft_3
from models.VCN_exp import WarpModule, flow_reg
from models.VCN_exp import VCN)
and context including class names, function names, or small code snippets from other files:
# Path: nnutils/geom_utils.py
# def obj_to_cam(verts, Rmat, Tmat,nmesh,n_hypo,skin,tocam=True):
# """
# transform from canonical object coordinates to camera coordinates
# """
# verts = verts.clone()
# Rmat = Rmat.clone()
# Tmat = Tmat.clone()
# verts = verts.view(-1,verts.shape[1],3)
#
# bodyR = Rmat[::nmesh].clone()
# bodyT = Tmat[::nmesh].clone()
# if nmesh>1:
# vs = []
# for k in range(nmesh-1):
# partR = Rmat[k+1::nmesh].clone()
# partT = Tmat[k+1::nmesh].clone()
# vs.append( (verts.matmul(partR) + partT)[:,np.newaxis] )
# vs = torch.cat(vs,1) # N, K, Nv, 3
# vs = (vs * skin).sum(1)
# else:
# vs = verts
#
# if tocam:
# vs = vs.clone().matmul(bodyR) + bodyT
# else:
# vs = vs.clone()
# return vs
#
# def pinhole_cam(verts,pp,fl):
# n_hypo = verts.shape[0] // pp.shape[0]
# pp = pp.clone()[:,None].repeat(1,n_hypo,1).view(-1,2)
# fl = fl.clone()[:,None].view(-1,1)
# verts = verts.clone()
# verts[:,:,1] = pp[:,1:2]+verts[:, :, 1].clone()*fl/ verts[:,:,2].clone()
# verts[:,:,0] = pp[:,0:1]+verts[:, :, 0].clone()*fl/ verts[:,:,2].clone()
# return verts
#
# def orthographic_cam(verts,pp,fl):
# n_hypo = verts.shape[0] // pp.shape[0]
# pp = pp.clone()[:,None].repeat(1,n_hypo,1).view(-1,2)
# fl = fl.clone()[:,None].view(-1,1)
# verts = verts.clone()
# verts[:,:,1] = pp[:,1:2]+verts[:, :, 1].clone()*fl
# verts[:,:,0] = pp[:,0:1]+verts[:, :, 0].clone()*fl
# return verts
#
# def render_flow_soft_3(renderer_soft, verts, verts_target, faces):
# """
# Render optical flow from two frame 3D vertex locations
# """
# offset = torch.Tensor( renderer_soft.transform.transformer._eye ).cuda()[np.newaxis,np.newaxis]
# verts_pre = verts[:,:,:3]+offset; verts_pre[:,:,1] = -1*verts_pre[:,:,1]
#
# verts_pos_px = renderer_soft.render_mesh(sr.Mesh(verts_pre, faces,
# textures=verts_target[:,:,:3],texture_type='vertex')).clone()
# fgmask = verts_pos_px[:,-1]
# verts_pos_px = verts_pos_px.permute(0,2,3,1)
#
# bgmask = (verts_pos_px[:,:,:,2]<1e-9)
# verts_pos_px[bgmask]=10
#
# verts_pos0_px = torch.Tensor(np.meshgrid(range(bgmask.shape[2]), range(bgmask.shape[1]))).cuda()
# verts_pos0_px[0] = verts_pos0_px[0]*2 / (bgmask.shape[2] - 1) - 1
# verts_pos0_px[1] = verts_pos0_px[1]*2 / (bgmask.shape[1] - 1) - 1
# verts_pos0_px = verts_pos0_px.permute(1,2,0)[None]
#
# flow_fw = (verts_pos_px[:,:,:,:2] - verts_pos0_px)
# flow_fw[bgmask] = flow_fw[bgmask].detach()
# return flow_fw, bgmask, fgmask
. Output only the next line. | return alp, refpp,center,length[0] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.