Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Given the following code snippet before the placeholder: <|code_start|> Arguments
----------
mesh: Trimesh object
face_index: faces to subdivide.
if None: all faces of mesh will be subdivided
if (n,) int array of indices: only specified faces will be
subdivided. Note that in this case the mesh will generally
no longer be manifold, as the additional vertex on the midpoint
will not be used by the adjacent faces to the faces specified,
and an additional postprocessing step will be required to
make resulting mesh watertight
'''
if face_index is None:
face_index = np.arange(len(mesh.faces))
else:
face_index = np.asanyarray(face_index, dtype=np.int64)
# the (c,3) int set of vertex indices
faces = mesh.faces[face_index]
# the (c, 3, 3) float set of points in the triangles
triangles = mesh.triangles[face_index]
# the 3 midpoints of each triangle edge vstacked to a (3*c, 3) float
mid = np.vstack([triangles[:, g, :].mean(axis=1) for g in [[0, 1],
[1, 2],
[2, 0]]])
mid_idx = (np.arange(len(face_index) * 3)).reshape((3, -1)).T
# for adjacent faces we are going to be generating the same midpoint
# twice, so we handle it here by finding the unique vertices
<|code_end|>
, predict the next line using imports from the current file:
import numpy as np
from .grouping import unique_rows
and context including class names, function names, and sometimes code from other files:
# Path: trimesh/grouping.py
# def unique_rows(data, digits=None):
# '''
# Returns indices of unique rows. It will return the
# first occurrence of a row that is duplicated:
# [[1,2], [3,4], [1,2]] will return [0,1]
#
# Arguments
# ---------
# data: (n,m) set of floating point data
# digits: how many digits to consider for the purposes of uniqueness
#
# Returns
# --------
# unique: (j) array, index in data which is a unique row
# inverse: (n) length array to reconstruct original
# example: unique[inverse] == data
# '''
# hashes = hashable_rows(data, digits=digits)
# garbage, unique, inverse = np.unique(hashes,
# return_index=True,
# return_inverse=True)
# return unique, inverse
. Output only the next line. | unique, inverse = unique_rows(mid) |
Continue the code snippet: <|code_start|>
def line_line(origins, directions):
'''
Find the intersection between two lines.
Uses terminology from:
http://geomalgorithms.com/a05-_intersect-1.html
line 1: P(s) = p_0 + sU
line 2: Q(t) = q_0 + tV
Arguments
---------
origins: (2,d) list of points on lines (d in [2,3])
directions: (2,d) list of direction vectors
Returns
---------
intersects: boolean, whether the lines intersect.
In 2D, false if the lines are parallel
In 3D, false if lines are not coplanar
intersection: if intersects: (d) length point of intersection
else: None
'''
<|code_end|>
. Use current file imports:
import numpy as np
from ..util import three_dimensionalize, unitize
from ..constants import tol_path as tol
and context (classes, functions, or code) from other files:
# Path: trimesh/util.py
# def three_dimensionalize(points, return_2D=True):
# '''
# Given a set of (n,2) or (n,3) points, return them as (n,3) points
#
# Arguments
# ----------
# points: (n, 2) or (n,3) points
# return_2D: boolean flag
#
# Returns
# ----------
# if return_2D:
# is_2D: boolean, True if points were (n,2)
# points: (n,3) set of points
# else:
# points: (n,3) set of points
# '''
# points = np.asanyarray(points)
# shape = points.shape
#
# if len(shape) != 2:
# raise ValueError('Points must be 2D array!')
#
# if shape[1] == 2:
# points = np.column_stack((points, np.zeros(len(points))))
# is_2D = True
# elif shape[1] == 3:
# is_2D = False
# else:
# raise ValueError('Points must be (n,2) or (n,3)!')
#
# if return_2D:
# return is_2D, points
# return points
#
# def unitize(points, check_valid=False):
# '''
# Turn a list of vectors into a list of unit vectors.
#
# Arguments
# ---------
# points: (n,m) or (j) input array of vectors.
# For 1D arrays, points is treated as a single vector
# For 2D arrays, each row is treated as a vector
# check_valid: boolean, if True enables valid output and checking
#
# Returns
# ---------
# unit_vectors: (n,m) or (j) length array of unit vectors
#
# valid: (n) boolean array, output only if check_valid.
# True for all valid (nonzero length) vectors, thus m=sum(valid)
# '''
# points = np.asanyarray(points)
# axis = len(points.shape) - 1
# length = np.sum(points ** 2, axis=axis) ** .5
#
# if is_sequence(length):
# length[np.isnan(length)] = 0.0
#
# if check_valid:
# valid = np.greater(length, _TOL_ZERO)
# if axis == 1:
# unit_vectors = (points[valid].T / length[valid]).T
# elif len(points.shape) == 1 and valid:
# unit_vectors = points / length
# else:
# unit_vectors = np.array([])
# return unit_vectors, valid
# else:
# unit_vectors = (points.T / length).T
# return unit_vectors
#
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
. Output only the next line. | is_2D, origins = three_dimensionalize(origins) |
Based on the snippet: <|code_start|>
def line_line(origins, directions):
'''
Find the intersection between two lines.
Uses terminology from:
http://geomalgorithms.com/a05-_intersect-1.html
line 1: P(s) = p_0 + sU
line 2: Q(t) = q_0 + tV
Arguments
---------
origins: (2,d) list of points on lines (d in [2,3])
directions: (2,d) list of direction vectors
Returns
---------
intersects: boolean, whether the lines intersect.
In 2D, false if the lines are parallel
In 3D, false if lines are not coplanar
intersection: if intersects: (d) length point of intersection
else: None
'''
is_2D, origins = three_dimensionalize(origins)
is_2D, directions = three_dimensionalize(directions)
<|code_end|>
, predict the immediate next line with the help of imports:
import numpy as np
from ..util import three_dimensionalize, unitize
from ..constants import tol_path as tol
and context (classes, functions, sometimes code) from other files:
# Path: trimesh/util.py
# def three_dimensionalize(points, return_2D=True):
# '''
# Given a set of (n,2) or (n,3) points, return them as (n,3) points
#
# Arguments
# ----------
# points: (n, 2) or (n,3) points
# return_2D: boolean flag
#
# Returns
# ----------
# if return_2D:
# is_2D: boolean, True if points were (n,2)
# points: (n,3) set of points
# else:
# points: (n,3) set of points
# '''
# points = np.asanyarray(points)
# shape = points.shape
#
# if len(shape) != 2:
# raise ValueError('Points must be 2D array!')
#
# if shape[1] == 2:
# points = np.column_stack((points, np.zeros(len(points))))
# is_2D = True
# elif shape[1] == 3:
# is_2D = False
# else:
# raise ValueError('Points must be (n,2) or (n,3)!')
#
# if return_2D:
# return is_2D, points
# return points
#
# def unitize(points, check_valid=False):
# '''
# Turn a list of vectors into a list of unit vectors.
#
# Arguments
# ---------
# points: (n,m) or (j) input array of vectors.
# For 1D arrays, points is treated as a single vector
# For 2D arrays, each row is treated as a vector
# check_valid: boolean, if True enables valid output and checking
#
# Returns
# ---------
# unit_vectors: (n,m) or (j) length array of unit vectors
#
# valid: (n) boolean array, output only if check_valid.
# True for all valid (nonzero length) vectors, thus m=sum(valid)
# '''
# points = np.asanyarray(points)
# axis = len(points.shape) - 1
# length = np.sum(points ** 2, axis=axis) ** .5
#
# if is_sequence(length):
# length[np.isnan(length)] = 0.0
#
# if check_valid:
# valid = np.greater(length, _TOL_ZERO)
# if axis == 1:
# unit_vectors = (points[valid].T / length[valid]).T
# elif len(points.shape) == 1 and valid:
# unit_vectors = points / length
# else:
# unit_vectors = np.array([])
# return unit_vectors, valid
# else:
# unit_vectors = (points.T / length).T
# return unit_vectors
#
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
. Output only the next line. | directions = unitize(directions) |
Using the snippet: <|code_start|>
def line_line(origins, directions):
'''
Find the intersection between two lines.
Uses terminology from:
http://geomalgorithms.com/a05-_intersect-1.html
line 1: P(s) = p_0 + sU
line 2: Q(t) = q_0 + tV
Arguments
---------
origins: (2,d) list of points on lines (d in [2,3])
directions: (2,d) list of direction vectors
Returns
---------
intersects: boolean, whether the lines intersect.
In 2D, false if the lines are parallel
In 3D, false if lines are not coplanar
intersection: if intersects: (d) length point of intersection
else: None
'''
is_2D, origins = three_dimensionalize(origins)
is_2D, directions = three_dimensionalize(directions)
directions = unitize(directions)
<|code_end|>
, determine the next line of code. You have imports:
import numpy as np
from ..util import three_dimensionalize, unitize
from ..constants import tol_path as tol
and context (class names, function names, or code) available:
# Path: trimesh/util.py
# def three_dimensionalize(points, return_2D=True):
# '''
# Given a set of (n,2) or (n,3) points, return them as (n,3) points
#
# Arguments
# ----------
# points: (n, 2) or (n,3) points
# return_2D: boolean flag
#
# Returns
# ----------
# if return_2D:
# is_2D: boolean, True if points were (n,2)
# points: (n,3) set of points
# else:
# points: (n,3) set of points
# '''
# points = np.asanyarray(points)
# shape = points.shape
#
# if len(shape) != 2:
# raise ValueError('Points must be 2D array!')
#
# if shape[1] == 2:
# points = np.column_stack((points, np.zeros(len(points))))
# is_2D = True
# elif shape[1] == 3:
# is_2D = False
# else:
# raise ValueError('Points must be (n,2) or (n,3)!')
#
# if return_2D:
# return is_2D, points
# return points
#
# def unitize(points, check_valid=False):
# '''
# Turn a list of vectors into a list of unit vectors.
#
# Arguments
# ---------
# points: (n,m) or (j) input array of vectors.
# For 1D arrays, points is treated as a single vector
# For 2D arrays, each row is treated as a vector
# check_valid: boolean, if True enables valid output and checking
#
# Returns
# ---------
# unit_vectors: (n,m) or (j) length array of unit vectors
#
# valid: (n) boolean array, output only if check_valid.
# True for all valid (nonzero length) vectors, thus m=sum(valid)
# '''
# points = np.asanyarray(points)
# axis = len(points.shape) - 1
# length = np.sum(points ** 2, axis=axis) ** .5
#
# if is_sequence(length):
# length[np.isnan(length)] = 0.0
#
# if check_valid:
# valid = np.greater(length, _TOL_ZERO)
# if axis == 1:
# unit_vectors = (points[valid].T / length[valid]).T
# elif len(points.shape) == 1 and valid:
# unit_vectors = points / length
# else:
# unit_vectors = np.array([])
# return unit_vectors, valid
# else:
# unit_vectors = (points.T / length).T
# return unit_vectors
#
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
. Output only the next line. | if np.sum(np.abs(np.diff(directions, axis=0))) < tol.zero: |
Predict the next line after this snippet: <|code_start|> [0,1] [1,2] 1 1
[0,1] [2,1] 1 -1
'''
if a[0] == b[0]:
return -1, 1
elif a[0] == b[1]:
return -1, -1
elif a[1] == b[0]:
return 1, 1
elif a[1] == b[1]:
return 1, -1
else:
raise ValueError(
'Can\'t determine direction, edges aren\'t connected!')
if vertices is None:
ccw_direction = 1
else:
ccw_check = is_ccw(vertices[np.append(vertex_path, vertex_path[0])])
ccw_direction = (ccw_check * 2) - 1
# populate the list of entities
vertex_path = np.asanyarray(vertex_path)
entity_path = deque()
for i in np.arange(len(vertex_path) + 1):
vertex_path_pos = np.mod(np.arange(2) + i, len(vertex_path))
vertex_index = vertex_path[vertex_path_pos]
entity_index = graph.get_edge_data(*vertex_index)['entity_index']
entity_path.append(entity_index)
# remove duplicate entities
<|code_end|>
using the current file's imports:
import numpy as np
import networkx as nx
from collections import deque
from ..grouping import unique_ordered
from ..util import unitize
from ..constants import tol_path as tol
from .util import is_ccw
and any relevant context from other files:
# Path: trimesh/grouping.py
# def unique_ordered(data):
# '''
# Returns the same as np.unique, but ordered as per the
# first occurance of the unique value in data.
#
# Example
# ---------
# In [1]: a = [0, 3, 3, 4, 1, 3, 0, 3, 2, 1]
#
# In [2]: np.unique(a)
# Out[2]: array([0, 1, 2, 3, 4])
#
# In [3]: trimesh.grouping.unique_ordered(a)
# Out[3]: array([0, 3, 4, 1, 2])
# '''
# data = np.asanyarray(data)
# order = np.sort(np.unique(data, return_index=True)[1])
# result = data[order]
# return result
#
# Path: trimesh/util.py
# def unitize(points, check_valid=False):
# '''
# Turn a list of vectors into a list of unit vectors.
#
# Arguments
# ---------
# points: (n,m) or (j) input array of vectors.
# For 1D arrays, points is treated as a single vector
# For 2D arrays, each row is treated as a vector
# check_valid: boolean, if True enables valid output and checking
#
# Returns
# ---------
# unit_vectors: (n,m) or (j) length array of unit vectors
#
# valid: (n) boolean array, output only if check_valid.
# True for all valid (nonzero length) vectors, thus m=sum(valid)
# '''
# points = np.asanyarray(points)
# axis = len(points.shape) - 1
# length = np.sum(points ** 2, axis=axis) ** .5
#
# if is_sequence(length):
# length[np.isnan(length)] = 0.0
#
# if check_valid:
# valid = np.greater(length, _TOL_ZERO)
# if axis == 1:
# unit_vectors = (points[valid].T / length[valid]).T
# elif len(points.shape) == 1 and valid:
# unit_vectors = points / length
# else:
# unit_vectors = np.array([])
# return unit_vectors, valid
# else:
# unit_vectors = (points.T / length).T
# return unit_vectors
#
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/path/util.py
# def is_ccw(points):
# '''
# Given an (n,2) set of points, return True if they are counterclockwise
# '''
# xd = np.diff(points[:, 0])
# yd = np.sum(np.column_stack((points[:, 1],
# points[:, 1])).reshape(-1)[1:-1].reshape((-1, 2)), axis=1)
# area = np.sum(xd * yd) * .5
# ccw = area < 0
#
# return ccw
. Output only the next line. | entity_path = unique_ordered(entity_path)[::ccw_direction] |
Given the code snippet: <|code_start|> self._cum_norm = np.cumsum(self._norms)
def sample(self, distances):
# return the indices in cum_norm that each sample would
# need to be inserted at to maintain the sorted property
positions = np.searchsorted(self._cum_norm, distances)
positions = np.clip(positions, 0, len(self._unit_vec) - 1)
offsets = np.append(0, self._cum_norm)[positions]
# the distance past the reference vertex we need to travel
projection = distances - offsets
# find out which dirction we need to project
direction = self._unit_vec[positions]
# find out which vertex we're offset from
origin = self._points[positions]
# just the parametric equation for a line
resampled = origin + (direction * projection.reshape((-1, 1)))
return resampled
def truncate(self, distance):
'''
Return a truncated version of the path.
Only one vertex (at the endpoint) will be added.
'''
position = np.searchsorted(self._cum_norm, distance)
offset = distance - self._cum_norm[position - 1]
if offset < tol.merge:
truncated = self._points[:position + 1]
else:
<|code_end|>
, generate the next line using the imports in this file:
import numpy as np
import networkx as nx
from collections import deque
from ..grouping import unique_ordered
from ..util import unitize
from ..constants import tol_path as tol
from .util import is_ccw
and context (functions, classes, or occasionally code) from other files:
# Path: trimesh/grouping.py
# def unique_ordered(data):
# '''
# Returns the same as np.unique, but ordered as per the
# first occurance of the unique value in data.
#
# Example
# ---------
# In [1]: a = [0, 3, 3, 4, 1, 3, 0, 3, 2, 1]
#
# In [2]: np.unique(a)
# Out[2]: array([0, 1, 2, 3, 4])
#
# In [3]: trimesh.grouping.unique_ordered(a)
# Out[3]: array([0, 3, 4, 1, 2])
# '''
# data = np.asanyarray(data)
# order = np.sort(np.unique(data, return_index=True)[1])
# result = data[order]
# return result
#
# Path: trimesh/util.py
# def unitize(points, check_valid=False):
# '''
# Turn a list of vectors into a list of unit vectors.
#
# Arguments
# ---------
# points: (n,m) or (j) input array of vectors.
# For 1D arrays, points is treated as a single vector
# For 2D arrays, each row is treated as a vector
# check_valid: boolean, if True enables valid output and checking
#
# Returns
# ---------
# unit_vectors: (n,m) or (j) length array of unit vectors
#
# valid: (n) boolean array, output only if check_valid.
# True for all valid (nonzero length) vectors, thus m=sum(valid)
# '''
# points = np.asanyarray(points)
# axis = len(points.shape) - 1
# length = np.sum(points ** 2, axis=axis) ** .5
#
# if is_sequence(length):
# length[np.isnan(length)] = 0.0
#
# if check_valid:
# valid = np.greater(length, _TOL_ZERO)
# if axis == 1:
# unit_vectors = (points[valid].T / length[valid]).T
# elif len(points.shape) == 1 and valid:
# unit_vectors = points / length
# else:
# unit_vectors = np.array([])
# return unit_vectors, valid
# else:
# unit_vectors = (points.T / length).T
# return unit_vectors
#
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/path/util.py
# def is_ccw(points):
# '''
# Given an (n,2) set of points, return True if they are counterclockwise
# '''
# xd = np.diff(points[:, 0])
# yd = np.sum(np.column_stack((points[:, 1],
# points[:, 1])).reshape(-1)[1:-1].reshape((-1, 2)), axis=1)
# area = np.sum(xd * yd) * .5
# ccw = area < 0
#
# return ccw
. Output only the next line. | vector = unitize(np.diff(self._points[np.arange(2) + position], |
Given snippet: <|code_start|> '''
Return a (n, dimension) list of vertices.
Samples arcs/curves to be line segments
'''
path_len = len(path)
if path_len == 0:
raise NameError('Cannot discretize empty path!')
if path_len == 1:
return np.array(entities[path[0]].discrete(vertices))
discrete = deque()
for i, entity_id in enumerate(path):
last = (i == (path_len - 1))
current = entities[entity_id].discrete(vertices, scale=scale)
slice = (int(last) * len(current)) + (int(not last) * -1)
discrete.extend(current[:slice])
discrete = np.array(discrete)
return discrete
class PathSample:
def __init__(self, points):
# make sure input array is numpy
self._points = np.array(points)
# find the direction of each segment
self._vectors = np.diff(self._points, axis=0)
# find the length of each segment
self._norms = np.linalg.norm(self._vectors, axis=1)
# unit vectors for each segment
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import numpy as np
import networkx as nx
from collections import deque
from ..grouping import unique_ordered
from ..util import unitize
from ..constants import tol_path as tol
from .util import is_ccw
and context:
# Path: trimesh/grouping.py
# def unique_ordered(data):
# '''
# Returns the same as np.unique, but ordered as per the
# first occurance of the unique value in data.
#
# Example
# ---------
# In [1]: a = [0, 3, 3, 4, 1, 3, 0, 3, 2, 1]
#
# In [2]: np.unique(a)
# Out[2]: array([0, 1, 2, 3, 4])
#
# In [3]: trimesh.grouping.unique_ordered(a)
# Out[3]: array([0, 3, 4, 1, 2])
# '''
# data = np.asanyarray(data)
# order = np.sort(np.unique(data, return_index=True)[1])
# result = data[order]
# return result
#
# Path: trimesh/util.py
# def unitize(points, check_valid=False):
# '''
# Turn a list of vectors into a list of unit vectors.
#
# Arguments
# ---------
# points: (n,m) or (j) input array of vectors.
# For 1D arrays, points is treated as a single vector
# For 2D arrays, each row is treated as a vector
# check_valid: boolean, if True enables valid output and checking
#
# Returns
# ---------
# unit_vectors: (n,m) or (j) length array of unit vectors
#
# valid: (n) boolean array, output only if check_valid.
# True for all valid (nonzero length) vectors, thus m=sum(valid)
# '''
# points = np.asanyarray(points)
# axis = len(points.shape) - 1
# length = np.sum(points ** 2, axis=axis) ** .5
#
# if is_sequence(length):
# length[np.isnan(length)] = 0.0
#
# if check_valid:
# valid = np.greater(length, _TOL_ZERO)
# if axis == 1:
# unit_vectors = (points[valid].T / length[valid]).T
# elif len(points.shape) == 1 and valid:
# unit_vectors = points / length
# else:
# unit_vectors = np.array([])
# return unit_vectors, valid
# else:
# unit_vectors = (points.T / length).T
# return unit_vectors
#
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/path/util.py
# def is_ccw(points):
# '''
# Given an (n,2) set of points, return True if they are counterclockwise
# '''
# xd = np.diff(points[:, 0])
# yd = np.sum(np.column_stack((points[:, 1],
# points[:, 1])).reshape(-1)[1:-1].reshape((-1, 2)), axis=1)
# area = np.sum(xd * yd) * .5
# ccw = area < 0
#
# return ccw
which might include code, classes, or functions. Output only the next line. | nonzero = self._norms > tol.zero |
Based on the snippet: <|code_start|>
Returns
----------
entity_path: (q,) int, list of entity indices which make up vertex_path
'''
def edge_direction(a, b):
'''
Given two edges, figure out if the first needs to be reversed to
keep the progression forward
[1,0] [1,2] -1 1
[1,0] [2,1] -1 -1
[0,1] [1,2] 1 1
[0,1] [2,1] 1 -1
'''
if a[0] == b[0]:
return -1, 1
elif a[0] == b[1]:
return -1, -1
elif a[1] == b[0]:
return 1, 1
elif a[1] == b[1]:
return 1, -1
else:
raise ValueError(
'Can\'t determine direction, edges aren\'t connected!')
if vertices is None:
ccw_direction = 1
else:
<|code_end|>
, predict the immediate next line with the help of imports:
import numpy as np
import networkx as nx
from collections import deque
from ..grouping import unique_ordered
from ..util import unitize
from ..constants import tol_path as tol
from .util import is_ccw
and context (classes, functions, sometimes code) from other files:
# Path: trimesh/grouping.py
# def unique_ordered(data):
# '''
# Returns the same as np.unique, but ordered as per the
# first occurance of the unique value in data.
#
# Example
# ---------
# In [1]: a = [0, 3, 3, 4, 1, 3, 0, 3, 2, 1]
#
# In [2]: np.unique(a)
# Out[2]: array([0, 1, 2, 3, 4])
#
# In [3]: trimesh.grouping.unique_ordered(a)
# Out[3]: array([0, 3, 4, 1, 2])
# '''
# data = np.asanyarray(data)
# order = np.sort(np.unique(data, return_index=True)[1])
# result = data[order]
# return result
#
# Path: trimesh/util.py
# def unitize(points, check_valid=False):
# '''
# Turn a list of vectors into a list of unit vectors.
#
# Arguments
# ---------
# points: (n,m) or (j) input array of vectors.
# For 1D arrays, points is treated as a single vector
# For 2D arrays, each row is treated as a vector
# check_valid: boolean, if True enables valid output and checking
#
# Returns
# ---------
# unit_vectors: (n,m) or (j) length array of unit vectors
#
# valid: (n) boolean array, output only if check_valid.
# True for all valid (nonzero length) vectors, thus m=sum(valid)
# '''
# points = np.asanyarray(points)
# axis = len(points.shape) - 1
# length = np.sum(points ** 2, axis=axis) ** .5
#
# if is_sequence(length):
# length[np.isnan(length)] = 0.0
#
# if check_valid:
# valid = np.greater(length, _TOL_ZERO)
# if axis == 1:
# unit_vectors = (points[valid].T / length[valid]).T
# elif len(points.shape) == 1 and valid:
# unit_vectors = points / length
# else:
# unit_vectors = np.array([])
# return unit_vectors, valid
# else:
# unit_vectors = (points.T / length).T
# return unit_vectors
#
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/path/util.py
# def is_ccw(points):
# '''
# Given an (n,2) set of points, return True if they are counterclockwise
# '''
# xd = np.diff(points[:, 0])
# yd = np.sum(np.column_stack((points[:, 1],
# points[:, 1])).reshape(-1)[1:-1].reshape((-1, 2)), axis=1)
# area = np.sum(xd * yd) * .5
# ccw = area < 0
#
# return ccw
. Output only the next line. | ccw_check = is_ccw(vertices[np.append(vertex_path, vertex_path[0])]) |
Given snippet: <|code_start|> Using this over openCASCADE as it is signifigantly more stable (though not OSS.)
STEPtools Inc. provides the binary under this license:
http://www.steptools.com/demos/license_author.html
To install the required binary ('export_product_asm') into PATH:
wget http://www.steptools.com/demos/stpidx_author_linux_x86_64_16.0.zip
unzip stpidx_author_linux_x86_64_16.0.zip
sudo cp stpidx_author_linux_x86_64/bin/export_product_asm /usr/bin/
Arguments
----------
file_obj: file like object containing step file
file_type: unused
Returns
----------
meshes: list of Trimesh objects (with correct metadata set from STEP file)
'''
with NamedTemporaryFile() as out_file:
with NamedTemporaryFile(suffix='.STEP') as in_file:
if hasattr(file_obj, 'read'):
in_file.write(file_obj.read())
in_file.flush()
in_file.seek(0)
file_name = in_file.name
else:
file_name = file_obj
check_call([_STEP_FACETER, file_name,
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import numpy as np
import networkx as nx
import itertools
from collections import deque
from tempfile import NamedTemporaryFile
from distutils.spawn import find_executable
from subprocess import check_call
from xml.etree import cElementTree
from ..constants import res, log
and context:
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
which might include code, classes, or functions. Output only the next line. | '-tol', str(res.mesh), |
Predict the next line after this snippet: <|code_start|> else:
paths = nx.all_simple_paths(g, shape_root, shape_id)
paths = np.array(list(paths))
garbage, unique = np.unique(['.'.join(i)
for i in paths], return_index=True)
paths = paths[unique]
for path in paths:
path_name = [g.node[i]['product_name'] for i in path[:-1]]
edges = np.column_stack((path[:-1],
path[:-1])).reshape(-1)[1:-1].reshape((-1, 2))
transforms = [np.eye(4)]
for e in edges:
# get every transform from the edge
local = [i['transform']
for i in g.edge[e[0]][e[1]].values()]
# all the transforms are sequential, so we want
# combinations
transforms = [np.dot(*i)
for i in itertools.product(transforms, local)]
transforms_all.extend(transforms)
path_str.extend(['/'.join(path_name)] * len(transforms))
meshes[mesh_id]['vertices'] *= to_inches
meshes[mesh_id]['metadata']['units'] = 'inches'
meshes[mesh_id]['metadata']['name'] = path_name[-1]
meshes[mesh_id]['metadata']['paths'] = np.array(path_str)
meshes[mesh_id]['metadata']['quantity'] = len(transforms_all)
meshes[mesh_id]['metadata'][
'transforms'] = np.array(transforms_all)
except:
<|code_end|>
using the current file's imports:
import numpy as np
import networkx as nx
import itertools
from collections import deque
from tempfile import NamedTemporaryFile
from distutils.spawn import find_executable
from subprocess import check_call
from xml.etree import cElementTree
from ..constants import res, log
and any relevant context from other files:
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
. Output only the next line. | log.error( |
Predict the next line after this snippet: <|code_start|> '''
Arguments
----------
points: (o,d) list of points of the bezier. The first and last
points should be the start and end of the curve.
For a 2D cubic bezier, order o=3, dimension d=2
Returns
----------
discrete: (n,d) list of points, a polyline representation
of the bezier curve which respects constants.RES_LENGTH
'''
def compute(t):
# compute discrete points given a sampling t
t_d = 1.0 - t
n = len(points) - 1
# binomial coefficents, i, and each point
iterable = zip(binomial(n), np.arange(n + 1), points)
stacked = [((t**i) * (t_d**(n - i))).reshape((-1, 1))
* p * c for c, i, p in iterable]
discrete = np.sum(stacked, axis=0)
return discrete
# make sure we have a numpy array
points = np.array(points)
if count is None:
# how much distance does a small percentage of the curve take
# this is so we can figure out how finely we have to sample t
norm = np.linalg.norm(np.diff(points, axis=0), axis=1).sum()
<|code_end|>
using the current file's imports:
import numpy as np
from ..constants import res_path as res
from ..constants import tol_path as tol
from scipy.interpolate import splev
from scipy.special import binom
and any relevant context from other files:
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
. Output only the next line. | count = np.ceil(norm / (res.seg_frac * scale)) |
Predict the next line for this snippet: <|code_start|> Returns
----------
discrete: (n,d) list of points, a polyline representation
of the bezier curve which respects constants.RES_LENGTH
'''
def compute(t):
# compute discrete points given a sampling t
t_d = 1.0 - t
n = len(points) - 1
# binomial coefficents, i, and each point
iterable = zip(binomial(n), np.arange(n + 1), points)
stacked = [((t**i) * (t_d**(n - i))).reshape((-1, 1))
* p * c for c, i, p in iterable]
discrete = np.sum(stacked, axis=0)
return discrete
# make sure we have a numpy array
points = np.array(points)
if count is None:
# how much distance does a small percentage of the curve take
# this is so we can figure out how finely we have to sample t
norm = np.linalg.norm(np.diff(points, axis=0), axis=1).sum()
count = np.ceil(norm / (res.seg_frac * scale))
count = int(np.clip(count,
res.min_sections * len(points),
res.max_sections * len(points)))
result = compute(np.linspace(0.0, 1.0, count))
test = np.sum((result[[0, -1]] - points[[0, -1]])**2, axis=1)
<|code_end|>
with the help of current file imports:
import numpy as np
from ..constants import res_path as res
from ..constants import tol_path as tol
from scipy.interpolate import splev
from scipy.special import binom
and context from other files:
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
, which may contain function names, class names, or code. Output only the next line. | assert (test < tol.merge).all() |
Continue the code snippet: <|code_start|>
try:
except:
log.warning('SVG path loading unavailable!')
def svg_to_path(file_obj, file_type=None):
def complex_to_float(values):
return np.array([[i.real, i.imag] for i in values])
def load_line(svg_line):
points = complex_to_float([svg_line.point(0.0),
svg_line.point(1.0)])
if not starting:
points[0] = vertices[-1]
<|code_end|>
. Use current file imports:
import numpy as np
from ...constants import log
from ..entities import Line, Arc, Bezier
from collections import deque
from xml.dom.minidom import parseString as parse_xml
from svg.path import parse_path
and context (classes, functions, or code) from other files:
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/path/entities.py
# class Line(Entity):
# '''
# A line or poly-line entity
# '''
#
# def discrete(self, vertices, scale=1.0):
# return vertices[self.points]
#
# @property
# def is_valid(self):
# valid = np.any((self.points - self.points[0]) != 0)
# return valid
#
# def explode(self):
# points = np.column_stack((self.points,
# self.points)).ravel()[1:-1].reshape((-1, 2))
# return [Line(i) for i in points]
#
# class Arc(Entity):
#
# @property
# def closed(self):
# if hasattr(self, '_closed'):
# return self._closed
# return False
#
# @closed.setter
# def closed(self, value):
# self._closed = bool(value)
#
# def discrete(self, vertices, scale=1.0):
# return discretize_arc(vertices[self.points],
# close=self.closed,
# scale=scale)
#
# def center(self, vertices):
# return arc_center(vertices[self.points])
#
# class Bezier(Curve):
#
# def discrete(self, vertices, scale=1.0):
# return discretize_bezier(vertices[self.points], scale=scale)
. Output only the next line. | entities.append(Line(np.arange(2) + len(vertices))) |
Predict the next line after this snippet: <|code_start|>
try:
except:
log.warning('SVG path loading unavailable!')
def svg_to_path(file_obj, file_type=None):
def complex_to_float(values):
return np.array([[i.real, i.imag] for i in values])
def load_line(svg_line):
points = complex_to_float([svg_line.point(0.0),
svg_line.point(1.0)])
if not starting:
points[0] = vertices[-1]
entities.append(Line(np.arange(2) + len(vertices)))
vertices.extend(points)
def load_arc(svg_arc):
points = complex_to_float([svg_arc.start,
svg_arc.point(.5),
svg_arc.end])
if not starting:
points[0] = vertices[-1]
<|code_end|>
using the current file's imports:
import numpy as np
from ...constants import log
from ..entities import Line, Arc, Bezier
from collections import deque
from xml.dom.minidom import parseString as parse_xml
from svg.path import parse_path
and any relevant context from other files:
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/path/entities.py
# class Line(Entity):
# '''
# A line or poly-line entity
# '''
#
# def discrete(self, vertices, scale=1.0):
# return vertices[self.points]
#
# @property
# def is_valid(self):
# valid = np.any((self.points - self.points[0]) != 0)
# return valid
#
# def explode(self):
# points = np.column_stack((self.points,
# self.points)).ravel()[1:-1].reshape((-1, 2))
# return [Line(i) for i in points]
#
# class Arc(Entity):
#
# @property
# def closed(self):
# if hasattr(self, '_closed'):
# return self._closed
# return False
#
# @closed.setter
# def closed(self, value):
# self._closed = bool(value)
#
# def discrete(self, vertices, scale=1.0):
# return discretize_arc(vertices[self.points],
# close=self.closed,
# scale=scale)
#
# def center(self, vertices):
# return arc_center(vertices[self.points])
#
# class Bezier(Curve):
#
# def discrete(self, vertices, scale=1.0):
# return discretize_bezier(vertices[self.points], scale=scale)
. Output only the next line. | entities.append(Arc(np.arange(3) + len(vertices))) |
Here is a snippet: <|code_start|> log.warning('SVG path loading unavailable!')
def svg_to_path(file_obj, file_type=None):
def complex_to_float(values):
return np.array([[i.real, i.imag] for i in values])
def load_line(svg_line):
points = complex_to_float([svg_line.point(0.0),
svg_line.point(1.0)])
if not starting:
points[0] = vertices[-1]
entities.append(Line(np.arange(2) + len(vertices)))
vertices.extend(points)
def load_arc(svg_arc):
points = complex_to_float([svg_arc.start,
svg_arc.point(.5),
svg_arc.end])
if not starting:
points[0] = vertices[-1]
entities.append(Arc(np.arange(3) + len(vertices)))
vertices.extend(points)
def load_quadratic(svg_quadratic):
points = complex_to_float([svg_quadratic.start,
svg_quadratic.control,
svg_quadratic.end])
if not starting:
points[0] = vertices[-1]
<|code_end|>
. Write the next line using the current file imports:
import numpy as np
from ...constants import log
from ..entities import Line, Arc, Bezier
from collections import deque
from xml.dom.minidom import parseString as parse_xml
from svg.path import parse_path
and context from other files:
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/path/entities.py
# class Line(Entity):
# '''
# A line or poly-line entity
# '''
#
# def discrete(self, vertices, scale=1.0):
# return vertices[self.points]
#
# @property
# def is_valid(self):
# valid = np.any((self.points - self.points[0]) != 0)
# return valid
#
# def explode(self):
# points = np.column_stack((self.points,
# self.points)).ravel()[1:-1].reshape((-1, 2))
# return [Line(i) for i in points]
#
# class Arc(Entity):
#
# @property
# def closed(self):
# if hasattr(self, '_closed'):
# return self._closed
# return False
#
# @closed.setter
# def closed(self, value):
# self._closed = bool(value)
#
# def discrete(self, vertices, scale=1.0):
# return discretize_arc(vertices[self.points],
# close=self.closed,
# scale=scale)
#
# def center(self, vertices):
# return arc_center(vertices[self.points])
#
# class Bezier(Curve):
#
# def discrete(self, vertices, scale=1.0):
# return discretize_bezier(vertices[self.points], scale=scale)
, which may include functions, classes, or code. Output only the next line. | entities.append(Bezier(np.arange(3) + len(vertices))) |
Using the snippet: <|code_start|> self.script_out = NamedTemporaryFile(mode='wb',
delete=False)
# export the meshes to a temporary STL container
for mesh, file_obj in zip(self.meshes, self.mesh_pre):
mesh.export(file_type='stl', file_obj=file_obj.name)
self.replacement = {
'mesh_' + str(i): m.name for i, m in enumerate(self.mesh_pre)}
self.replacement['mesh_pre'] = str([i.name for i in self.mesh_pre])
self.replacement['mesh_post'] = self.mesh_post.name
self.replacement['script'] = self.script_out.name
script_text = Template(self.script).substitute(self.replacement)
self.script_out.write(script_text.encode('utf-8'))
# close all temporary files
self.script_out.close()
self.mesh_post.close()
for file_obj in self.mesh_pre:
file_obj.close()
return self
def run(self, command):
command_run = Template(command).substitute(self.replacement).split()
# run the binary
check_call(command_run)
# bring the binaries result back as a Trimesh object
with open(self.mesh_post.name, mode='rb') as file_obj:
<|code_end|>
, determine the next line of code. You have imports:
from ..io.stl import load_stl
from string import Template
from tempfile import NamedTemporaryFile
from subprocess import check_call
from os import remove
and context (class names, function names, or code) available:
# Path: trimesh/io/stl.py
# def load_stl(file_obj, file_type=None):
# '''
# Load an STL file from a file object.
#
# Arguments
# ----------
# file_obj: open file- like object
# file_type: not used
#
# Returns
# ----------
# loaded: kwargs for a Trimesh constructor with keys:
# vertices: (n,3) float, vertices
# faces: (m,3) int, indexes of vertices
# face_normals: (m,3) float, normal vector of each face
# '''
# # save start of file obj
# file_pos = file_obj.tell()
# try:
# # check the file for a header which matches the file length
# # if that is true, it is almost certainly a binary STL file
# # if the header doesn't match the file length a HeaderError will be
# # raised
# return load_stl_binary(file_obj)
# except HeaderError:
# # move the file back to where it was initially
# file_obj.seek(file_pos)
# # try to load the file as an ASCII STL
# # if the header doesn't match the file length a HeaderError will be
# # raised
# return load_stl_ascii(file_obj)
. Output only the next line. | mesh_result = load_stl(file_obj) |
Based on the snippet: <|code_start|>
_scad_executable = find_executable('openscad')
exists = _scad_executable is not None
def interface_scad(meshes, script):
'''
A way to interface with openSCAD which is itself an interface
to the CGAL CSG bindings.
CGAL is very stable if difficult to install/use, so this function provides a
tempfile- happy solution for getting the basic CGAL CSG functionality.
Arguments
---------
meshes: list of Trimesh objects
script: string of the script to send to scad.
Trimesh objects can be referenced in the script as
$mesh_0, $mesh_1, etc.
'''
if not exists:
raise ValueError('No SCAD available!')
<|code_end|>
, predict the immediate next line with the help of imports:
from .generic import MeshScript
from distutils.spawn import find_executable
and context (classes, functions, sometimes code) from other files:
# Path: trimesh/interfaces/generic.py
# class MeshScript:
#
# def __init__(self,
# meshes,
# script):
# self.meshes = meshes
# self.script = script
#
# def __enter__(self):
# # windows has problems with multiple programs using open files so we close
# # them at the end of the enter call, and delete them ourselves at the
# # exit
# self.mesh_pre = [NamedTemporaryFile(suffix='.STL',
# mode='wb',
# delete=False) for i in self.meshes]
# self.mesh_post = NamedTemporaryFile(suffix='.STL',
# mode='rb',
# delete=False)
# self.script_out = NamedTemporaryFile(mode='wb',
# delete=False)
#
# # export the meshes to a temporary STL container
# for mesh, file_obj in zip(self.meshes, self.mesh_pre):
# mesh.export(file_type='stl', file_obj=file_obj.name)
#
# self.replacement = {
# 'mesh_' + str(i): m.name for i, m in enumerate(self.mesh_pre)}
# self.replacement['mesh_pre'] = str([i.name for i in self.mesh_pre])
# self.replacement['mesh_post'] = self.mesh_post.name
# self.replacement['script'] = self.script_out.name
#
# script_text = Template(self.script).substitute(self.replacement)
# self.script_out.write(script_text.encode('utf-8'))
#
# # close all temporary files
# self.script_out.close()
# self.mesh_post.close()
# for file_obj in self.mesh_pre:
# file_obj.close()
# return self
#
# def run(self, command):
# command_run = Template(command).substitute(self.replacement).split()
# # run the binary
# check_call(command_run)
#
# # bring the binaries result back as a Trimesh object
# with open(self.mesh_post.name, mode='rb') as file_obj:
# mesh_result = load_stl(file_obj)
# return mesh_result
#
# def __exit__(self, *args, **kwargs):
# # delete all the temporary files by name
# # they are closed but their names are still available
# remove(self.script_out.name)
# for file_obj in self.mesh_pre:
# remove(file_obj.name)
# remove(self.mesh_post.name)
. Output only the next line. | with MeshScript(meshes=meshes, script=script) as scad: |
Using the snippet: <|code_start|>
def unit_guess(scale):
'''
Wild ass guess for the units of a drawing or model, based on the scale.
'''
if scale > 100.0:
return 'millimeters'
else:
return 'inches'
def _set_units(obj, desired, guess):
'''
Given an object that has units and vertices attributes convert units.
Arguments
---------
obj: object with units and vertices (eg Path or Trimesh)
desired: units desired (eg 'inches')
guess: boolean, whether we are allowed to guess the units of the document
if they are not specified.
'''
desired = str(desired)
if not validate(desired):
raise ValueError(desired + ' are not a valid unit!')
if obj.units is None:
if guess:
obj.units = unit_guess(obj.scale)
<|code_end|>
, determine the next line of code. You have imports:
from .constants import log
and context (class names, function names, or code) available:
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
. Output only the next line. | log.warning('No units specified, guessing units are %s', |
Continue the code snippet: <|code_start|>
def multipack(polygons,
sheet_size=None,
iterations=50,
density_escape=.985,
buffer_dist=0.09,
plot=False,
return_all=False):
'''
Run multiple iterations of rectangle packing, by randomly permutating the
insertion order
If sheet size isn't specified, it creates a large sheet that can fit all
of the polygons
'''
transforms_obb, rectangles = polygons_obb(polygons)
rectangles += 2.0 * buffer_dist
polygon_area = np.array([p.area for p in polygons])
for i, r in enumerate(rectangles):
transforms_obb[i][0:2, 2] += r * .5
tic = time_function()
overall_density = 0
if sheet_size is None:
max_dim = np.max(rectangles, axis=0)
sum_dim = np.sum(rectangles, axis=0)
sheet_size = [sum_dim[0], max_dim[1] * 2]
<|code_end|>
. Use current file imports:
import numpy as np
import matplotlib.pyplot as plt
from collections import deque
from ..constants import log, time_function
from ..constants import tol_path as tol
from .polygons import polygons_obb, transform_polygon
and context (classes, functions, or code) from other files:
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/path/polygons.py
# def polygons_obb(polygons):
# '''
# Find the OBBs for a list of shapely.geometry.Polygons
# '''
# rectangles = [None] * len(polygons)
# transforms = [None] * len(polygons)
# for i, p in enumerate(polygons):
# transforms[i], rectangles[i] = polygon_obb(p)
# return np.array(transforms), np.array(rectangles)
#
# def transform_polygon(polygon, transform, plot=False):
# if is_sequence(polygon):
# result = [transform_polygon(p, t) for p, t in zip(polygon, transform)]
# else:
# shell = transform_points(np.array(polygon.exterior.coords), transform)
# holes = [transform_points(np.array(i.coords), transform)
# for i in polygon.interiors]
# result = Polygon(shell=shell, holes=holes)
# if plot:
# plot_polygon(result)
# return result
. Output only the next line. | log.info('Packing %d polygons', len(polygons)) |
Predict the next line after this snippet: <|code_start|> for path, transform in zip(paths_full, transforms):
path.apply_transform(transform)
if show:
path.plot_discrete(show=False)
if show:
plt.show()
return paths_full
def multipack(polygons,
sheet_size=None,
iterations=50,
density_escape=.985,
buffer_dist=0.09,
plot=False,
return_all=False):
'''
Run multiple iterations of rectangle packing, by randomly permutating the
insertion order
If sheet size isn't specified, it creates a large sheet that can fit all
of the polygons
'''
transforms_obb, rectangles = polygons_obb(polygons)
rectangles += 2.0 * buffer_dist
polygon_area = np.array([p.area for p in polygons])
for i, r in enumerate(rectangles):
transforms_obb[i][0:2, 2] += r * .5
<|code_end|>
using the current file's imports:
import numpy as np
import matplotlib.pyplot as plt
from collections import deque
from ..constants import log, time_function
from ..constants import tol_path as tol
from .polygons import polygons_obb, transform_polygon
and any relevant context from other files:
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/path/polygons.py
# def polygons_obb(polygons):
# '''
# Find the OBBs for a list of shapely.geometry.Polygons
# '''
# rectangles = [None] * len(polygons)
# transforms = [None] * len(polygons)
# for i, p in enumerate(polygons):
# transforms[i], rectangles[i] = polygon_obb(p)
# return np.array(transforms), np.array(rectangles)
#
# def transform_polygon(polygon, transform, plot=False):
# if is_sequence(polygon):
# result = [transform_polygon(p, t) for p, t in zip(polygon, transform)]
# else:
# shell = transform_points(np.array(polygon.exterior.coords), transform)
# holes = [transform_points(np.array(i.coords), transform)
# for i in polygon.interiors]
# result = Polygon(shell=shell, holes=holes)
# if plot:
# plot_polygon(result)
# return result
. Output only the next line. | tic = time_function() |
Based on the snippet: <|code_start|>class RectangleBin:
'''
2D BSP tree node.
http://www.blackpawn.com/texts/lightmaps/
'''
def __init__(self, bounds=None, size=None):
self.child = [None] * 2
# bounds: (minx, miny, maxx, maxy)
self.bounds = bounds
self.occupied = False
if size is not None:
self.bounds = np.append([0, 0], size)
def insert(self, rectangle_size):
for child in self.child:
if child is not None:
attempt = child.insert(rectangle_size)
if attempt:
return attempt
if self.occupied:
return None
# compare the bin size to the insertion candidate size
size_test = bounds_to_size(self.bounds) - rectangle_size
# this means the inserted rectangle is too big for the cell
<|code_end|>
, predict the immediate next line with the help of imports:
import numpy as np
import matplotlib.pyplot as plt
from collections import deque
from ..constants import log, time_function
from ..constants import tol_path as tol
from .polygons import polygons_obb, transform_polygon
and context (classes, functions, sometimes code) from other files:
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/path/polygons.py
# def polygons_obb(polygons):
# '''
# Find the OBBs for a list of shapely.geometry.Polygons
# '''
# rectangles = [None] * len(polygons)
# transforms = [None] * len(polygons)
# for i, p in enumerate(polygons):
# transforms[i], rectangles[i] = polygon_obb(p)
# return np.array(transforms), np.array(rectangles)
#
# def transform_polygon(polygon, transform, plot=False):
# if is_sequence(polygon):
# result = [transform_polygon(p, t) for p, t in zip(polygon, transform)]
# else:
# shell = transform_points(np.array(polygon.exterior.coords), transform)
# holes = [transform_points(np.array(i.coords), transform)
# for i in polygon.interiors]
# result = Polygon(shell=shell, holes=holes)
# if plot:
# plot_polygon(result)
# return result
. Output only the next line. | if np.any(size_test < -tol.zero): |
Predict the next line for this snippet: <|code_start|> paths_full.extend([path.copy()
for i in range(path.metadata['quantity'])])
else:
paths_full.append(path.copy())
polygons = [i.polygons_closed[i.root[0]] for i in paths_full]
inserted, transforms = multipack(np.array(polygons))
for path, transform in zip(paths_full, transforms):
path.apply_transform(transform)
if show:
path.plot_discrete(show=False)
if show:
plt.show()
return paths_full
def multipack(polygons,
sheet_size=None,
iterations=50,
density_escape=.985,
buffer_dist=0.09,
plot=False,
return_all=False):
'''
Run multiple iterations of rectangle packing, by randomly permutating the
insertion order
If sheet size isn't specified, it creates a large sheet that can fit all
of the polygons
'''
<|code_end|>
with the help of current file imports:
import numpy as np
import matplotlib.pyplot as plt
from collections import deque
from ..constants import log, time_function
from ..constants import tol_path as tol
from .polygons import polygons_obb, transform_polygon
and context from other files:
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/path/polygons.py
# def polygons_obb(polygons):
# '''
# Find the OBBs for a list of shapely.geometry.Polygons
# '''
# rectangles = [None] * len(polygons)
# transforms = [None] * len(polygons)
# for i, p in enumerate(polygons):
# transforms[i], rectangles[i] = polygon_obb(p)
# return np.array(transforms), np.array(rectangles)
#
# def transform_polygon(polygon, transform, plot=False):
# if is_sequence(polygon):
# result = [transform_polygon(p, t) for p, t in zip(polygon, transform)]
# else:
# shell = transform_points(np.array(polygon.exterior.coords), transform)
# holes = [transform_points(np.array(i.coords), transform)
# for i in polygon.interiors]
# result = Polygon(shell=shell, holes=holes)
# if plot:
# plot_polygon(result)
# return result
, which may contain function names, class names, or code. Output only the next line. | transforms_obb, rectangles = polygons_obb(polygons) |
Given the following code snippet before the placeholder: <|code_start|> sheet_size = [sum_dim[0], max_dim[1] * 2]
log.info('Packing %d polygons', len(polygons))
for i in range(iterations):
density, offset, inserted, sheet = pack_rectangles(rectangles,
sheet_size=sheet_size,
shuffle=(i != 0))
if density > overall_density:
overall_density = density
overall_offset = offset
overall_inserted = inserted
overall_sheet = sheet
if density > density_escape:
break
toc = time_function()
log.info('Packing finished %i iterations in %f seconds', i + 1, toc - tic)
log.info('%i/%i parts were packed successfully',
np.sum(overall_inserted), len(polygons))
log.info('Final rectangular density is %f.', overall_density)
polygon_density = np.sum(
polygon_area[overall_inserted]) / np.product(overall_sheet)
log.info('Final polygonal density is %f.', polygon_density)
transforms_obb = transforms_obb[overall_inserted]
transforms_packed = transforms_obb.copy()
transforms_packed.reshape(-1, 9)[:, [2, 5]] += overall_offset + buffer_dist
if plot:
<|code_end|>
, predict the next line using imports from the current file:
import numpy as np
import matplotlib.pyplot as plt
from collections import deque
from ..constants import log, time_function
from ..constants import tol_path as tol
from .polygons import polygons_obb, transform_polygon
and context including class names, function names, and sometimes code from other files:
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/constants.py
# class NumericalToleranceMesh(object):
# class NumericalResolutionMesh(object):
# class NumericalTolerancePath(object):
# class NumericalResolutionPath(object):
# class MeshError(Exception):
# class TransformError(Exception):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def __init__(self, **kwargs):
# def _log_time(method):
# def timed(*args, **kwargs):
#
# Path: trimesh/path/polygons.py
# def polygons_obb(polygons):
# '''
# Find the OBBs for a list of shapely.geometry.Polygons
# '''
# rectangles = [None] * len(polygons)
# transforms = [None] * len(polygons)
# for i, p in enumerate(polygons):
# transforms[i], rectangles[i] = polygon_obb(p)
# return np.array(transforms), np.array(rectangles)
#
# def transform_polygon(polygon, transform, plot=False):
# if is_sequence(polygon):
# result = [transform_polygon(p, t) for p, t in zip(polygon, transform)]
# else:
# shell = transform_points(np.array(polygon.exterior.coords), transform)
# holes = [transform_points(np.array(i.coords), transform)
# for i in polygon.interiors]
# result = Polygon(shell=shell, holes=holes)
# if plot:
# plot_polygon(result)
# return result
. Output only the next line. | transform_polygon(np.array(polygons)[overall_inserted], |
Here is a snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Color.parse('#ffF')
self.assertEqual(
response,
<|code_end|>
. Write the next line using the current file imports:
import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Color, ColorParseException
and context from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Color(BaseParser):
# """Parse a color value. It can be hex, RGB or RGBA"""
#
# ParseException = ColorParseException
#
# HEX_CHARS = '0123456789ABCDEFabcdef'
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a color value"""
# hex3 = (
# pp.Suppress(pp.Literal('#')) +
# pp.Word(cls.HEX_CHARS, exact=3).leaveWhitespace()
# )
# hex6 = (
# pp.Suppress(pp.Literal('#')) +
# pp.Word(cls.HEX_CHARS, exact=6).leaveWhitespace()
# )
# rgb = (
# pp.Suppress(pp.CaselessLiteral('rgb(')) +
# Number.grammar() +
# pp.Suppress(pp.Literal(',')) +
# Number.grammar() +
# pp.Suppress(pp.Literal(',')) +
# Number.grammar() +
# pp.Suppress(pp.Literal(')'))
# )
# rgba = (
# pp.Suppress(pp.CaselessLiteral('rgba(')) +
# Number.grammar() +
# pp.Suppress(pp.Literal(',')) +
# Number.grammar() +
# pp.Suppress(pp.Literal(',')) +
# Number.grammar() +
# pp.Suppress(pp.Literal(',')) +
# Number.grammar() +
# pp.Suppress(pp.Literal(')'))
# )
# return hex6 | hex3 | rgba | rgb
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# alpha = 1
# if len(tokens) == 1:
# red, green, blue = cls.hex_to_rgb(tokens[0])
# elif len(tokens) == 3:
# red, green, blue = map(float, tokens)
# elif len(tokens) == 4:
# red, green, blue, alpha = map(float, tokens)
#
# return {
# 'type': ValueType.color,
# 'red': red,
# 'green': green,
# 'blue': blue,
# 'alpha': alpha
# }
#
# @classmethod
# def hex_to_rgb(cls, hexval):
# """Convert hex value to RGB value"""
# if len(hexval) == 3:
# new_hexval = ''
# for c in hexval:
# new_hexval += c * 2
# hexval = new_hexval
# return [int(hexval[i:i + 2], base=16)for i in range(0, 6, 2)]
#
# class ColorParseException(Exception):
# """Raised when there is an exception while parsing a color value"""
# pass
, which may include functions, classes, or code. Output only the next line. | dict(type=ValueType.color, red=255, green=255, blue=255, alpha=1) |
Using the snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Color.parse('#ffF')
self.assertEqual(
response,
dict(type=ValueType.color, red=255, green=255, blue=255, alpha=1)
)
response = Color.parse('#FFFFFF')
self.assertEqual(
response,
dict(type=ValueType.color, red=255, green=255, blue=255, alpha=1)
)
response = Color.parse('rgba(0, 0, 0, 1)')
self.assertEqual(
response,
dict(type=ValueType.color, red=0, green=0, blue=0, alpha=1)
)
response = Color.parse('RGB(0, 0, 0)')
self.assertEqual(
response,
dict(type=ValueType.color, red=0, green=0, blue=0, alpha=1)
)
<|code_end|>
, determine the next line of code. You have imports:
import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Color, ColorParseException
and context (class names, function names, or code) available:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Color(BaseParser):
# """Parse a color value. It can be hex, RGB or RGBA"""
#
# ParseException = ColorParseException
#
# HEX_CHARS = '0123456789ABCDEFabcdef'
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a color value"""
# hex3 = (
# pp.Suppress(pp.Literal('#')) +
# pp.Word(cls.HEX_CHARS, exact=3).leaveWhitespace()
# )
# hex6 = (
# pp.Suppress(pp.Literal('#')) +
# pp.Word(cls.HEX_CHARS, exact=6).leaveWhitespace()
# )
# rgb = (
# pp.Suppress(pp.CaselessLiteral('rgb(')) +
# Number.grammar() +
# pp.Suppress(pp.Literal(',')) +
# Number.grammar() +
# pp.Suppress(pp.Literal(',')) +
# Number.grammar() +
# pp.Suppress(pp.Literal(')'))
# )
# rgba = (
# pp.Suppress(pp.CaselessLiteral('rgba(')) +
# Number.grammar() +
# pp.Suppress(pp.Literal(',')) +
# Number.grammar() +
# pp.Suppress(pp.Literal(',')) +
# Number.grammar() +
# pp.Suppress(pp.Literal(',')) +
# Number.grammar() +
# pp.Suppress(pp.Literal(')'))
# )
# return hex6 | hex3 | rgba | rgb
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# alpha = 1
# if len(tokens) == 1:
# red, green, blue = cls.hex_to_rgb(tokens[0])
# elif len(tokens) == 3:
# red, green, blue = map(float, tokens)
# elif len(tokens) == 4:
# red, green, blue, alpha = map(float, tokens)
#
# return {
# 'type': ValueType.color,
# 'red': red,
# 'green': green,
# 'blue': blue,
# 'alpha': alpha
# }
#
# @classmethod
# def hex_to_rgb(cls, hexval):
# """Convert hex value to RGB value"""
# if len(hexval) == 3:
# new_hexval = ''
# for c in hexval:
# new_hexval += c * 2
# hexval = new_hexval
# return [int(hexval[i:i + 2], base=16)for i in range(0, 6, 2)]
#
# class ColorParseException(Exception):
# """Raised when there is an exception while parsing a color value"""
# pass
. Output only the next line. | with self.assertRaises(ColorParseException): |
Given the following code snippet before the placeholder: <|code_start|>
class MissingProperty(Exception):
'''Exception raised when a property value is missing while interpolating
values'''
pass
class StyleSheetInterpolator(object):
'''Generate stylesheet dictionary object'''
def __init__(self, stylesheet_dict, *args, **kwargs):
super(StyleSheetInterpolator, self).__init__(*args, **kwargs)
<|code_end|>
, predict the next line using imports from the current file:
from ..components import StyleSheetComponent
from .value import interpolate_value
and context including class names, function names, and sometimes code from other files:
# Path: css2video/components/stylesheet.py
# class StyleSheetComponent(BaseComponent):
# """A wrapper from stylesheet dictionary object"""
#
# def __init__(self, *args, **kwargs):
# super(StyleSheetComponent, self).__init__(*args, **kwargs)
#
# @property
# def style_rules(self):
# """Returns the style components"""
# style_rules = filter(
# lambda x: x['type'] == 'style', self.Dict.get('rules', []))
# return [
# StyleRuleComponent.from_dict(Dict=rule) for rule in style_rules
# ]
#
# @property
# def keyframes_rules(self):
# keyframes_rules = filter(
# lambda x: x['type'] == 'keyframes', self.Dict.get('rules', []))
# return [
# KeyframesRuleComponent.from_dict(Dict=rule)
# for rule in keyframes_rules
# ]
#
# def animation_names(self):
# """Returns a list of animation names"""
# return [rule.name for rule in self.keyframes_rules]
#
# def get_keyframes_rule(self, name):
# """Returns the keyframes rule with this name
# Args:
# - name: name of the animation
# """
# for keyframes_rule in self.keyframes_rules:
# if name == keyframes_rule.name:
# return keyframes_rule
#
# Path: css2video/interpolators/value.py
# def interpolate_value(from_value, to_value, fraction, type='linear'):
# '''Interpolate a value between the given two values
# from_value - initial value
# to_value - final value
# fraction - fraction position from the initial value
# type - type of interpolation function'''
#
# if from_value.get('type') != to_value.get('type'):
# raise ValueTypeMismatch()
#
# value_type = from_value.get('type')
# interpolator_fn = Interpolators.get_timing_function(name=type)
#
# required_value = copy.deepcopy(from_value)
#
# if value_type in ['number', 'length', 'percentage', 'time']:
# # Interpolate the value
# required_value['value'] = interpolator_fn(
# from_value['value'], to_value['value'], fraction)
#
# if value_type == 'color':
# # Interpolate RGBA values
# required_value['red'] = interpolator_fn(
# from_value['red'], to_value['red'], fraction)
# required_value['green'] = interpolator_fn(
# from_value['green'], to_value['green'], fraction)
# required_value['blue'] = interpolator_fn(
# from_value['blue'], to_value['blue'], fraction)
# required_value['alpha'] = interpolator_fn(
# from_value['alpha'], to_value['alpha'], fraction)
#
# if value_type in ['text', 'url']:
# # Text values cannot be interpolated.
# # When the fraction is 1, return the final value
# if fraction == 1:
# required_value['value'] = to_value['value']
#
# if value_type == 'function':
# # Check the argument count of both the values and interpolate each of
# # the value
# from_args = from_value.get('args', [])
# to_args = to_value.get('args', [])
# if len(from_args) != len(to_args):
# raise FunctionValueArgCountMismatch()
# args = []
# for arg1, arg2 in zip(from_args, to_args):
# args.append(interpolate_value(arg1, arg2, fraction, type))
# required_value['args'] = args
#
# if value_type == 'array':
# # Check the length of the array and interpolate each of the array items
# from_values = from_value.get('values', [])
# to_values = to_value.get('values', [])
# if len(from_values) != len(to_values):
# raise ArrayLengthMismatch()
# values = []
# for value1, value2 in zip(from_values, to_values):
# values.append(interpolate_value(value1, value2, fraction, type))
# required_value['values'] = values
#
# return required_value
. Output only the next line. | self.stylesheet = StyleSheetComponent.from_dict(Dict=stylesheet_dict) |
Next line prediction: <|code_start|> def generate(self, time):
'''Returns a stylesheet dictionary object for the given time'''
stylesheet = self.stylesheet.duplicate()
for rule in stylesheet.style_rules:
animation_properties = rule.animation_properties()
animation_name = animation_properties.get('animation-name')
if not animation_name:
continue
time_offset = self.get_time_offset(animation_properties, time)
if time_offset is None:
continue
keyframes_rule = stylesheet.get_keyframes_rule(animation_name)
kfp1, kfp2 = keyframes_rule.get_property_sets(
time_offset=time_offset)
if kfp2.time_offset == kfp1.time_offset:
fraction = 0
else:
fraction = (
(time_offset - kfp1.time_offset) /
(kfp2.time_offset - kfp1.time_offset)
)
for pname1, value1 in kfp1.properties.items():
if pname1 not in kfp2.properties:
raise MissingProperty('Missing property %s' % pname1)
value2 = kfp2.properties[pname1]
<|code_end|>
. Use current file imports:
(from ..components import StyleSheetComponent
from .value import interpolate_value)
and context including class names, function names, or small code snippets from other files:
# Path: css2video/components/stylesheet.py
# class StyleSheetComponent(BaseComponent):
# """A wrapper from stylesheet dictionary object"""
#
# def __init__(self, *args, **kwargs):
# super(StyleSheetComponent, self).__init__(*args, **kwargs)
#
# @property
# def style_rules(self):
# """Returns the style components"""
# style_rules = filter(
# lambda x: x['type'] == 'style', self.Dict.get('rules', []))
# return [
# StyleRuleComponent.from_dict(Dict=rule) for rule in style_rules
# ]
#
# @property
# def keyframes_rules(self):
# keyframes_rules = filter(
# lambda x: x['type'] == 'keyframes', self.Dict.get('rules', []))
# return [
# KeyframesRuleComponent.from_dict(Dict=rule)
# for rule in keyframes_rules
# ]
#
# def animation_names(self):
# """Returns a list of animation names"""
# return [rule.name for rule in self.keyframes_rules]
#
# def get_keyframes_rule(self, name):
# """Returns the keyframes rule with this name
# Args:
# - name: name of the animation
# """
# for keyframes_rule in self.keyframes_rules:
# if name == keyframes_rule.name:
# return keyframes_rule
#
# Path: css2video/interpolators/value.py
# def interpolate_value(from_value, to_value, fraction, type='linear'):
# '''Interpolate a value between the given two values
# from_value - initial value
# to_value - final value
# fraction - fraction position from the initial value
# type - type of interpolation function'''
#
# if from_value.get('type') != to_value.get('type'):
# raise ValueTypeMismatch()
#
# value_type = from_value.get('type')
# interpolator_fn = Interpolators.get_timing_function(name=type)
#
# required_value = copy.deepcopy(from_value)
#
# if value_type in ['number', 'length', 'percentage', 'time']:
# # Interpolate the value
# required_value['value'] = interpolator_fn(
# from_value['value'], to_value['value'], fraction)
#
# if value_type == 'color':
# # Interpolate RGBA values
# required_value['red'] = interpolator_fn(
# from_value['red'], to_value['red'], fraction)
# required_value['green'] = interpolator_fn(
# from_value['green'], to_value['green'], fraction)
# required_value['blue'] = interpolator_fn(
# from_value['blue'], to_value['blue'], fraction)
# required_value['alpha'] = interpolator_fn(
# from_value['alpha'], to_value['alpha'], fraction)
#
# if value_type in ['text', 'url']:
# # Text values cannot be interpolated.
# # When the fraction is 1, return the final value
# if fraction == 1:
# required_value['value'] = to_value['value']
#
# if value_type == 'function':
# # Check the argument count of both the values and interpolate each of
# # the value
# from_args = from_value.get('args', [])
# to_args = to_value.get('args', [])
# if len(from_args) != len(to_args):
# raise FunctionValueArgCountMismatch()
# args = []
# for arg1, arg2 in zip(from_args, to_args):
# args.append(interpolate_value(arg1, arg2, fraction, type))
# required_value['args'] = args
#
# if value_type == 'array':
# # Check the length of the array and interpolate each of the array items
# from_values = from_value.get('values', [])
# to_values = to_value.get('values', [])
# if len(from_values) != len(to_values):
# raise ArrayLengthMismatch()
# values = []
# for value1, value2 in zip(from_values, to_values):
# values.append(interpolate_value(value1, value2, fraction, type))
# required_value['values'] = values
#
# return required_value
. Output only the next line. | value = interpolate_value( |
Next line prediction: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Text.parse('inline-block')
self.assertEqual(
<|code_end|>
. Use current file imports:
(import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Text, TextParseException)
and context including class names, function names, or small code snippets from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Text(BaseParser):
# """Parse a text value"""
#
# ParseException = TextParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a text value"""
# return pp.Word(pp.alphas + '-')
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.text,
# 'value': tokens[0]
# }
#
# class TextParseException(Exception):
# """Raised when there is an exception while parsing a text value"""
# pass
. Output only the next line. | response, dict(type=ValueType.text, value='inline-block')) |
Next line prediction: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Text.parse('inline-block')
self.assertEqual(
response, dict(type=ValueType.text, value='inline-block'))
<|code_end|>
. Use current file imports:
(import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Text, TextParseException)
and context including class names, function names, or small code snippets from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Text(BaseParser):
# """Parse a text value"""
#
# ParseException = TextParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a text value"""
# return pp.Word(pp.alphas + '-')
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.text,
# 'value': tokens[0]
# }
#
# class TextParseException(Exception):
# """Raised when there is an exception while parsing a text value"""
# pass
. Output only the next line. | with self.assertRaises(TextParseException): |
Here is a snippet: <|code_start|> (
{
'type': 'function',
'name': 'translateX',
'args': [
{'type': 'length', 'value': 100, 'unit': 'px'},
{'type': 'number', 'value': 0},
]
},
{
'type': 'function',
'name': 'translateX',
'args': [
{'type': 'length', 'value': 0, 'unit': 'px'},
{'type': 'number', 'value': 100},
]
},
0.5,
'linear',
{
'type': 'function',
'name': 'translateX',
'args': [
{'type': 'length', 'value': 50, 'unit': 'px'},
{'type': 'number', 'value': 50},
]
}
)
]
for v1, v2, f, t, expected_value in data:
<|code_end|>
. Write the next line using the current file imports:
import unittest
from css2video.interpolators import interpolate_value
from .utils import isEqual
and context from other files:
# Path: css2video/interpolators/value.py
# def interpolate_value(from_value, to_value, fraction, type='linear'):
# '''Interpolate a value between the given two values
# from_value - initial value
# to_value - final value
# fraction - fraction position from the initial value
# type - type of interpolation function'''
#
# if from_value.get('type') != to_value.get('type'):
# raise ValueTypeMismatch()
#
# value_type = from_value.get('type')
# interpolator_fn = Interpolators.get_timing_function(name=type)
#
# required_value = copy.deepcopy(from_value)
#
# if value_type in ['number', 'length', 'percentage', 'time']:
# # Interpolate the value
# required_value['value'] = interpolator_fn(
# from_value['value'], to_value['value'], fraction)
#
# if value_type == 'color':
# # Interpolate RGBA values
# required_value['red'] = interpolator_fn(
# from_value['red'], to_value['red'], fraction)
# required_value['green'] = interpolator_fn(
# from_value['green'], to_value['green'], fraction)
# required_value['blue'] = interpolator_fn(
# from_value['blue'], to_value['blue'], fraction)
# required_value['alpha'] = interpolator_fn(
# from_value['alpha'], to_value['alpha'], fraction)
#
# if value_type in ['text', 'url']:
# # Text values cannot be interpolated.
# # When the fraction is 1, return the final value
# if fraction == 1:
# required_value['value'] = to_value['value']
#
# if value_type == 'function':
# # Check the argument count of both the values and interpolate each of
# # the value
# from_args = from_value.get('args', [])
# to_args = to_value.get('args', [])
# if len(from_args) != len(to_args):
# raise FunctionValueArgCountMismatch()
# args = []
# for arg1, arg2 in zip(from_args, to_args):
# args.append(interpolate_value(arg1, arg2, fraction, type))
# required_value['args'] = args
#
# if value_type == 'array':
# # Check the length of the array and interpolate each of the array items
# from_values = from_value.get('values', [])
# to_values = to_value.get('values', [])
# if len(from_values) != len(to_values):
# raise ArrayLengthMismatch()
# values = []
# for value1, value2 in zip(from_values, to_values):
# values.append(interpolate_value(value1, value2, fraction, type))
# required_value['values'] = values
#
# return required_value
#
# Path: tests/utils.py
# def isEqual(value1, value2):
# '''Compare any two values and returns true if they are equal'''
# if isinstance(value1, list) and isinstance(value2, list):
# is_equal = True
# for v1, v2 in zip(value1, value2):
# is_equal = is_equal and isEqual(v1, v2)
# if not is_equal:
# break
# return is_equal
#
# if isinstance(value1, dict) and isinstance(value2, dict):
# is_equal = len(value1.keys()) == len(value2.keys())
# for key1 in value1:
# is_equal = is_equal and (key1 in value2)
# if not is_equal:
# break
# is_equal = is_equal and isEqual(value1[key1], value2[key1])
# if not is_equal:
# break
# return is_equal
# return value1 == value2
, which may include functions, classes, or code. Output only the next line. | v = interpolate_value(v1, v2, f, t) |
Next line prediction: <|code_start|> {
'type': 'function',
'name': 'translateX',
'args': [
{'type': 'length', 'value': 100, 'unit': 'px'},
{'type': 'number', 'value': 0},
]
},
{
'type': 'function',
'name': 'translateX',
'args': [
{'type': 'length', 'value': 0, 'unit': 'px'},
{'type': 'number', 'value': 100},
]
},
0.5,
'linear',
{
'type': 'function',
'name': 'translateX',
'args': [
{'type': 'length', 'value': 50, 'unit': 'px'},
{'type': 'number', 'value': 50},
]
}
)
]
for v1, v2, f, t, expected_value in data:
v = interpolate_value(v1, v2, f, t)
<|code_end|>
. Use current file imports:
(import unittest
from css2video.interpolators import interpolate_value
from .utils import isEqual)
and context including class names, function names, or small code snippets from other files:
# Path: css2video/interpolators/value.py
# def interpolate_value(from_value, to_value, fraction, type='linear'):
# '''Interpolate a value between the given two values
# from_value - initial value
# to_value - final value
# fraction - fraction position from the initial value
# type - type of interpolation function'''
#
# if from_value.get('type') != to_value.get('type'):
# raise ValueTypeMismatch()
#
# value_type = from_value.get('type')
# interpolator_fn = Interpolators.get_timing_function(name=type)
#
# required_value = copy.deepcopy(from_value)
#
# if value_type in ['number', 'length', 'percentage', 'time']:
# # Interpolate the value
# required_value['value'] = interpolator_fn(
# from_value['value'], to_value['value'], fraction)
#
# if value_type == 'color':
# # Interpolate RGBA values
# required_value['red'] = interpolator_fn(
# from_value['red'], to_value['red'], fraction)
# required_value['green'] = interpolator_fn(
# from_value['green'], to_value['green'], fraction)
# required_value['blue'] = interpolator_fn(
# from_value['blue'], to_value['blue'], fraction)
# required_value['alpha'] = interpolator_fn(
# from_value['alpha'], to_value['alpha'], fraction)
#
# if value_type in ['text', 'url']:
# # Text values cannot be interpolated.
# # When the fraction is 1, return the final value
# if fraction == 1:
# required_value['value'] = to_value['value']
#
# if value_type == 'function':
# # Check the argument count of both the values and interpolate each of
# # the value
# from_args = from_value.get('args', [])
# to_args = to_value.get('args', [])
# if len(from_args) != len(to_args):
# raise FunctionValueArgCountMismatch()
# args = []
# for arg1, arg2 in zip(from_args, to_args):
# args.append(interpolate_value(arg1, arg2, fraction, type))
# required_value['args'] = args
#
# if value_type == 'array':
# # Check the length of the array and interpolate each of the array items
# from_values = from_value.get('values', [])
# to_values = to_value.get('values', [])
# if len(from_values) != len(to_values):
# raise ArrayLengthMismatch()
# values = []
# for value1, value2 in zip(from_values, to_values):
# values.append(interpolate_value(value1, value2, fraction, type))
# required_value['values'] = values
#
# return required_value
#
# Path: tests/utils.py
# def isEqual(value1, value2):
# '''Compare any two values and returns true if they are equal'''
# if isinstance(value1, list) and isinstance(value2, list):
# is_equal = True
# for v1, v2 in zip(value1, value2):
# is_equal = is_equal and isEqual(v1, v2)
# if not is_equal:
# break
# return is_equal
#
# if isinstance(value1, dict) and isinstance(value2, dict):
# is_equal = len(value1.keys()) == len(value2.keys())
# for key1 in value1:
# is_equal = is_equal and (key1 in value2)
# if not is_equal:
# break
# is_equal = is_equal and isEqual(value1[key1], value2[key1])
# if not is_equal:
# break
# return is_equal
# return value1 == value2
. Output only the next line. | self.assertTrue(isEqual(v, expected_value)) |
Here is a snippet: <|code_start|>
class ValueTypeMismatch(Exception):
'''Exception raised when there is mismatch between the two values'''
class FunctionValueArgCountMismatch(Exception):
'''Exception raised when trying to interpolate function values which don't
have the same number of arguments'''
class ArrayLengthMismatch(Exception):
'''Exception raised when trying to interpolate array values which don't
have the same length'''
def interpolate_value(from_value, to_value, fraction, type='linear'):
'''Interpolate a value between the given two values
from_value - initial value
to_value - final value
fraction - fraction position from the initial value
type - type of interpolation function'''
if from_value.get('type') != to_value.get('type'):
raise ValueTypeMismatch()
value_type = from_value.get('type')
<|code_end|>
. Write the next line using the current file imports:
import copy
from .interpolators import Interpolators
and context from other files:
# Path: css2video/interpolators/interpolators.py
# class Interpolators:
# '''Standard interpolators'''
# LINEAR = lambda v1, v2, f: v1 * (1-f) + v2 * f
# EASE = lambda v1, v2, f: Interpolators.LINEAR(v1, v2, bezier_interpolate(0.25,0.1,0.25,1,f))
# EASE_IN = lambda v1, v2, f: Interpolators.LINEAR(v1, v2, bezier_interpolate(0.42,0,1,1,f))
# EASE_OUT = lambda v1, v2, f: Interpolators.LINEAR(v1, v2, bezier_interpolate(0,0,0.58,1,f))
# EASE_IN_OUT = lambda v1, v2, f: Interpolators.LINEAR(v1, v2, bezier_interpolate(0.42,0,0.58,1,f))
#
# @staticmethod
# def get_timing_function(name):
# name = name.upper()
# name = name.replace('-', '_')
# return getattr(Interpolators, name)
, which may include functions, classes, or code. Output only the next line. | interpolator_fn = Interpolators.get_timing_function(name=type) |
Using the snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Style.parse('div { margin: 20px; }')
<|code_end|>
, determine the next line of code. You have imports:
import unittest
from css2video.constants import RuleType, ValueType
from css2video.parsers.rule import Style, StyleParseException
and context (class names, function names, or code) available:
# Path: css2video/constants.py
# class RuleType(object):
# """Class to define constants for rule types"""
#
# style = 'style'
# keyframes = 'keyframes'
#
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/rule.py
# class Style(BaseParser):
# """Parse a CSS style rule"""
#
# ParseException = StyleParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a CSS style rule"""
# selector = pp.Word(pp.alphanums + '#.,*>+~[]=|^$:-() ')
# return (
# selector +
# pp.Suppress(pp.Literal('{')) +
# pp.ZeroOrMore(Property.parser()) +
# pp.Suppress(pp.Literal('}'))
# )
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': RuleType.style,
# 'selector': tokens[0].strip(),
# 'properties': tokens[1:]
# }
#
# class StyleParseException(Exception):
# """Raised when there is an exception while parsing the style rule"""
# pass
. Output only the next line. | self.assertEqual(response['type'], RuleType.style) |
Using the snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Style.parse('div { margin: 20px; }')
self.assertEqual(response['type'], RuleType.style)
self.assertEqual(response['selector'], 'div')
self.assertEqual(response['properties'], [
dict(
property_name='margin',
property_value=dict(
<|code_end|>
, determine the next line of code. You have imports:
import unittest
from css2video.constants import RuleType, ValueType
from css2video.parsers.rule import Style, StyleParseException
and context (class names, function names, or code) available:
# Path: css2video/constants.py
# class RuleType(object):
# """Class to define constants for rule types"""
#
# style = 'style'
# keyframes = 'keyframes'
#
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/rule.py
# class Style(BaseParser):
# """Parse a CSS style rule"""
#
# ParseException = StyleParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a CSS style rule"""
# selector = pp.Word(pp.alphanums + '#.,*>+~[]=|^$:-() ')
# return (
# selector +
# pp.Suppress(pp.Literal('{')) +
# pp.ZeroOrMore(Property.parser()) +
# pp.Suppress(pp.Literal('}'))
# )
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': RuleType.style,
# 'selector': tokens[0].strip(),
# 'properties': tokens[1:]
# }
#
# class StyleParseException(Exception):
# """Raised when there is an exception while parsing the style rule"""
# pass
. Output only the next line. | type=ValueType.length, value=20., unit='px' |
Using the snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Style.parse('div { margin: 20px; }')
self.assertEqual(response['type'], RuleType.style)
self.assertEqual(response['selector'], 'div')
self.assertEqual(response['properties'], [
dict(
property_name='margin',
property_value=dict(
type=ValueType.length, value=20., unit='px'
)
)
])
<|code_end|>
, determine the next line of code. You have imports:
import unittest
from css2video.constants import RuleType, ValueType
from css2video.parsers.rule import Style, StyleParseException
and context (class names, function names, or code) available:
# Path: css2video/constants.py
# class RuleType(object):
# """Class to define constants for rule types"""
#
# style = 'style'
# keyframes = 'keyframes'
#
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/rule.py
# class Style(BaseParser):
# """Parse a CSS style rule"""
#
# ParseException = StyleParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a CSS style rule"""
# selector = pp.Word(pp.alphanums + '#.,*>+~[]=|^$:-() ')
# return (
# selector +
# pp.Suppress(pp.Literal('{')) +
# pp.ZeroOrMore(Property.parser()) +
# pp.Suppress(pp.Literal('}'))
# )
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': RuleType.style,
# 'selector': tokens[0].strip(),
# 'properties': tokens[1:]
# }
#
# class StyleParseException(Exception):
# """Raised when there is an exception while parsing the style rule"""
# pass
. Output only the next line. | with self.assertRaises(StyleParseException): |
Predict the next line after this snippet: <|code_start|> self.assertEqual(response['properties'], [
Property.parse('margin: 10px;')
])
response = KeyframeProperties.parse('to { padding: 0 5px; }')
self.assertEqual(response['selector'], 100.)
self.assertEqual(response['properties'], [
Property.parse('padding: 0 5px;')
])
response = KeyframeProperties.parse('50% { padding: 0 5px; }')
self.assertEqual(response['selector'], 50.)
self.assertEqual(response['properties'], [
Property.parse('padding: 0 5px;')
])
with self.assertRaises(KeyframePropertiesParseException):
KeyframeProperties.parse('50 % { ; }')
def test_keyframes_parser(self):
keyframes = [
'from { margin-left: 1000px; }',
'50% { margin-left: 800px; }',
'to { margin-left: 0; }'
]
response = Keyframes.parse("""
@keyframes slide-in {{
{keyframes}
}}
""".format(keyframes='\n'.join(keyframes)))
<|code_end|>
using the current file's imports:
import unittest
from css2video.constants import RuleType
from css2video.parsers.rule import (
Property, KeyframeProperties, KeyframePropertiesParseException,
Keyframes, KeyframesParseException
)
and any relevant context from other files:
# Path: css2video/constants.py
# class RuleType(object):
# """Class to define constants for rule types"""
#
# style = 'style'
# keyframes = 'keyframes'
#
# Path: css2video/parsers/rule.py
# class StyleParseException(Exception):
# class Style(BaseParser):
# class KeyframePropertiesParseException(Exception):
# class KeyframeProperties(BaseParser):
# class KeyframesParseException(Exception):
# class Keyframes(BaseParser):
# class RuleParseException(Exception):
# class Rule(object):
# def grammar(cls):
# def parse_action(cls, tokens):
# def grammar(cls):
# def parse_action(cls, tokens):
# def grammar(cls):
# def parse_action(cls, tokens):
# def parser(cls):
. Output only the next line. | self.assertEqual(response['type'], RuleType.keyframes) |
Continue the code snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_keyframe_properties_parser(self):
response = KeyframeProperties.parse('from { margin: 10px; }')
self.assertEqual(response['selector'], 0.)
self.assertEqual(response['properties'], [
<|code_end|>
. Use current file imports:
import unittest
from css2video.constants import RuleType
from css2video.parsers.rule import (
Property, KeyframeProperties, KeyframePropertiesParseException,
Keyframes, KeyframesParseException
)
and context (classes, functions, or code) from other files:
# Path: css2video/constants.py
# class RuleType(object):
# """Class to define constants for rule types"""
#
# style = 'style'
# keyframes = 'keyframes'
#
# Path: css2video/parsers/rule.py
# class StyleParseException(Exception):
# class Style(BaseParser):
# class KeyframePropertiesParseException(Exception):
# class KeyframeProperties(BaseParser):
# class KeyframesParseException(Exception):
# class Keyframes(BaseParser):
# class RuleParseException(Exception):
# class Rule(object):
# def grammar(cls):
# def parse_action(cls, tokens):
# def grammar(cls):
# def parse_action(cls, tokens):
# def grammar(cls):
# def parse_action(cls, tokens):
# def parser(cls):
. Output only the next line. | Property.parse('margin: 10px;') |
Given the following code snippet before the placeholder: <|code_start|>
class TestCase(unittest.TestCase):
def test_keyframe_properties_parser(self):
response = KeyframeProperties.parse('from { margin: 10px; }')
self.assertEqual(response['selector'], 0.)
self.assertEqual(response['properties'], [
Property.parse('margin: 10px;')
])
response = KeyframeProperties.parse('to { padding: 0 5px; }')
self.assertEqual(response['selector'], 100.)
self.assertEqual(response['properties'], [
Property.parse('padding: 0 5px;')
])
response = KeyframeProperties.parse('50% { padding: 0 5px; }')
self.assertEqual(response['selector'], 50.)
self.assertEqual(response['properties'], [
Property.parse('padding: 0 5px;')
])
<|code_end|>
, predict the next line using imports from the current file:
import unittest
from css2video.constants import RuleType
from css2video.parsers.rule import (
Property, KeyframeProperties, KeyframePropertiesParseException,
Keyframes, KeyframesParseException
)
and context including class names, function names, and sometimes code from other files:
# Path: css2video/constants.py
# class RuleType(object):
# """Class to define constants for rule types"""
#
# style = 'style'
# keyframes = 'keyframes'
#
# Path: css2video/parsers/rule.py
# class StyleParseException(Exception):
# class Style(BaseParser):
# class KeyframePropertiesParseException(Exception):
# class KeyframeProperties(BaseParser):
# class KeyframesParseException(Exception):
# class Keyframes(BaseParser):
# class RuleParseException(Exception):
# class Rule(object):
# def grammar(cls):
# def parse_action(cls, tokens):
# def grammar(cls):
# def parse_action(cls, tokens):
# def grammar(cls):
# def parse_action(cls, tokens):
# def parser(cls):
. Output only the next line. | with self.assertRaises(KeyframePropertiesParseException): |
Based on the snippet: <|code_start|>class TestCase(unittest.TestCase):
def test_keyframe_properties_parser(self):
response = KeyframeProperties.parse('from { margin: 10px; }')
self.assertEqual(response['selector'], 0.)
self.assertEqual(response['properties'], [
Property.parse('margin: 10px;')
])
response = KeyframeProperties.parse('to { padding: 0 5px; }')
self.assertEqual(response['selector'], 100.)
self.assertEqual(response['properties'], [
Property.parse('padding: 0 5px;')
])
response = KeyframeProperties.parse('50% { padding: 0 5px; }')
self.assertEqual(response['selector'], 50.)
self.assertEqual(response['properties'], [
Property.parse('padding: 0 5px;')
])
with self.assertRaises(KeyframePropertiesParseException):
KeyframeProperties.parse('50 % { ; }')
def test_keyframes_parser(self):
keyframes = [
'from { margin-left: 1000px; }',
'50% { margin-left: 800px; }',
'to { margin-left: 0; }'
]
<|code_end|>
, predict the immediate next line with the help of imports:
import unittest
from css2video.constants import RuleType
from css2video.parsers.rule import (
Property, KeyframeProperties, KeyframePropertiesParseException,
Keyframes, KeyframesParseException
)
and context (classes, functions, sometimes code) from other files:
# Path: css2video/constants.py
# class RuleType(object):
# """Class to define constants for rule types"""
#
# style = 'style'
# keyframes = 'keyframes'
#
# Path: css2video/parsers/rule.py
# class StyleParseException(Exception):
# class Style(BaseParser):
# class KeyframePropertiesParseException(Exception):
# class KeyframeProperties(BaseParser):
# class KeyframesParseException(Exception):
# class Keyframes(BaseParser):
# class RuleParseException(Exception):
# class Rule(object):
# def grammar(cls):
# def parse_action(cls, tokens):
# def grammar(cls):
# def parse_action(cls, tokens):
# def grammar(cls):
# def parse_action(cls, tokens):
# def parser(cls):
. Output only the next line. | response = Keyframes.parse(""" |
Given the code snippet: <|code_start|> self.assertEqual(response['properties'], [
Property.parse('padding: 0 5px;')
])
response = KeyframeProperties.parse('50% { padding: 0 5px; }')
self.assertEqual(response['selector'], 50.)
self.assertEqual(response['properties'], [
Property.parse('padding: 0 5px;')
])
with self.assertRaises(KeyframePropertiesParseException):
KeyframeProperties.parse('50 % { ; }')
def test_keyframes_parser(self):
keyframes = [
'from { margin-left: 1000px; }',
'50% { margin-left: 800px; }',
'to { margin-left: 0; }'
]
response = Keyframes.parse("""
@keyframes slide-in {{
{keyframes}
}}
""".format(keyframes='\n'.join(keyframes)))
self.assertEqual(response['type'], RuleType.keyframes)
self.assertEqual(response['name'], 'slide-in')
self.assertEqual(response['keyframes'], [
KeyframeProperties.parse(kf) for kf in keyframes
])
<|code_end|>
, generate the next line using the imports in this file:
import unittest
from css2video.constants import RuleType
from css2video.parsers.rule import (
Property, KeyframeProperties, KeyframePropertiesParseException,
Keyframes, KeyframesParseException
)
and context (functions, classes, or occasionally code) from other files:
# Path: css2video/constants.py
# class RuleType(object):
# """Class to define constants for rule types"""
#
# style = 'style'
# keyframes = 'keyframes'
#
# Path: css2video/parsers/rule.py
# class StyleParseException(Exception):
# class Style(BaseParser):
# class KeyframePropertiesParseException(Exception):
# class KeyframeProperties(BaseParser):
# class KeyframesParseException(Exception):
# class Keyframes(BaseParser):
# class RuleParseException(Exception):
# class Rule(object):
# def grammar(cls):
# def parse_action(cls, tokens):
# def grammar(cls):
# def parse_action(cls, tokens):
# def grammar(cls):
# def parse_action(cls, tokens):
# def parser(cls):
. Output only the next line. | with self.assertRaises(KeyframesParseException): |
Using the snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Number.parse('20')
<|code_end|>
, determine the next line of code. You have imports:
import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Number, NumberParseException
and context (class names, function names, or code) available:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Number(BaseParser):
# """Parser to parse a number"""
#
# ParseException = NumberParseException
#
# @classmethod
# def grammar(cls):
# """Returns the grammar to parse a number that may have a sign and a
# decimal point"""
# sign = pp.Word('+-', exact=1)
# digits = pp.Word(pp.nums)
# decimal = pp.Combine(pp.Word('.', exact=1) + digits)
# return pp.Combine(pp.Optional(sign) + digits + pp.Optional(decimal))
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.number,
# 'value': float(tokens[0])
# }
#
# class NumberParseException(Exception):
# """Raised when there is an exception while parsing a number"""
# pass
. Output only the next line. | self.assertEqual(response, dict(type=ValueType.number, value=20.)) |
Continue the code snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Number.parse('20')
self.assertEqual(response, dict(type=ValueType.number, value=20.))
response = Number.parse('+1')
self.assertEqual(response, dict(type=ValueType.number, value=1.))
response = Number.parse('-20.5')
self.assertEqual(response, dict(type=ValueType.number, value=-20.5))
<|code_end|>
. Use current file imports:
import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Number, NumberParseException
and context (classes, functions, or code) from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Number(BaseParser):
# """Parser to parse a number"""
#
# ParseException = NumberParseException
#
# @classmethod
# def grammar(cls):
# """Returns the grammar to parse a number that may have a sign and a
# decimal point"""
# sign = pp.Word('+-', exact=1)
# digits = pp.Word(pp.nums)
# decimal = pp.Combine(pp.Word('.', exact=1) + digits)
# return pp.Combine(pp.Optional(sign) + digits + pp.Optional(decimal))
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.number,
# 'value': float(tokens[0])
# }
#
# class NumberParseException(Exception):
# """Raised when there is an exception while parsing a number"""
# pass
. Output only the next line. | with self.assertRaises(NumberParseException): |
Using the snippet: <|code_start|>def render_animation(
html_path, css_path, output_path, duration, framerate=30, width=800,
height=600, image_renderer='CUTYCAPT', video_renderer='FFMPEG'):
with open(css_path, 'r') as fd:
css = fd.read()
html_path = os.path.abspath(html_path)
output_path = os.path.abspath(output_path)
stylesheet_dict = StyleSheet.parse(css)
total_frames = framerate * duration
duration_per_frame = float(duration) / total_frames
temp_dir = tempfile.mkdtemp()
for frame in tqdm(range(total_frames)):
time = frame * duration_per_frame
filename = _get_frame_image_name(
frame=frame, total_frames=total_frames)
temp_stylesheet_dict = interpolate_stylesheet(
stylesheet_dict=stylesheet_dict, time=time)
temp_css = output_stylesheet(stylesheet_dict=temp_stylesheet_dict)
temp_css_path = os.path.join(temp_dir, 'temp.css')
with open(temp_css_path, 'w') as fd:
fd.write(temp_css)
temp_output_path = os.path.join(temp_dir, filename)
<|code_end|>
, determine the next line of code. You have imports:
import os
import shutil
import tempfile
from tqdm import tqdm
from .image import render_image
from .video import render_video
from css2video.interpolators import interpolate_stylesheet
from css2video.parsers.stylesheet import StyleSheet
from css2video.outputters import output_stylesheet
and context (class names, function names, or code) available:
# Path: css2video/renderers/image/render.py
# def render_image(
# html_path, css_path, output_path, width=800, height=600,
# renderer='CUTYCAPT'):
# """Render HTML CSS as an image"""
#
# if renderer == 'CUTYCAPT':
# renderer = CutyCaptRenderer(
# html_path, css_path, output_path, width, height)
#
# renderer.render()
#
# Path: css2video/renderers/video/render.py
# def render_video(image_sequence, output_path, framerate=30, renderer='FFMPEG'):
# if renderer == 'FFMPEG':
# renderer = FFMpegRenderer(image_sequence, output_path, framerate)
# renderer.render()
#
# Path: css2video/interpolators/stylesheet.py
# def interpolate_stylesheet(stylesheet_dict, time):
# """Interpolates the animation property value based on the given time and
# returns the resulting stylesheet as a dictionary"""
# generator = StyleSheetInterpolator(stylesheet_dict=stylesheet_dict)
# return generator.generate(time=time).to_dict()
#
# Path: css2video/parsers/stylesheet.py
# class StyleSheet(BaseParser):
# '''Parse a stylesheet'''
#
# @classmethod
# def grammar(cls):
# '''Grammar to parse a style sheet'''
# return pp.ZeroOrMore(Rule.parser())
#
# @classmethod
# def parse_action(cls, tokens):
# '''Returns a dictionary from the parsed tokens'''
# return {
# 'rules': [rule for rule in tokens]
# }
#
# Path: css2video/outputters/stylesheet.py
# def output_stylesheet(stylesheet_dict):
# '''Returns the stylesheet as a string'''
# return '\n'.join(
# [output_rule(rule) for rule in stylesheet_dict.get('rules', []) if rule['type'] == 'style'])
. Output only the next line. | render_image( |
Given the following code snippet before the placeholder: <|code_start|> output_path = os.path.abspath(output_path)
stylesheet_dict = StyleSheet.parse(css)
total_frames = framerate * duration
duration_per_frame = float(duration) / total_frames
temp_dir = tempfile.mkdtemp()
for frame in tqdm(range(total_frames)):
time = frame * duration_per_frame
filename = _get_frame_image_name(
frame=frame, total_frames=total_frames)
temp_stylesheet_dict = interpolate_stylesheet(
stylesheet_dict=stylesheet_dict, time=time)
temp_css = output_stylesheet(stylesheet_dict=temp_stylesheet_dict)
temp_css_path = os.path.join(temp_dir, 'temp.css')
with open(temp_css_path, 'w') as fd:
fd.write(temp_css)
temp_output_path = os.path.join(temp_dir, filename)
render_image(
html_path=html_path, css_path=temp_css_path,
output_path=temp_output_path, width=width, height=height,
renderer=image_renderer
)
input_image_sequence = os.path.join(
temp_dir, _get_image_sequence(total_frames=total_frames))
<|code_end|>
, predict the next line using imports from the current file:
import os
import shutil
import tempfile
from tqdm import tqdm
from .image import render_image
from .video import render_video
from css2video.interpolators import interpolate_stylesheet
from css2video.parsers.stylesheet import StyleSheet
from css2video.outputters import output_stylesheet
and context including class names, function names, and sometimes code from other files:
# Path: css2video/renderers/image/render.py
# def render_image(
# html_path, css_path, output_path, width=800, height=600,
# renderer='CUTYCAPT'):
# """Render HTML CSS as an image"""
#
# if renderer == 'CUTYCAPT':
# renderer = CutyCaptRenderer(
# html_path, css_path, output_path, width, height)
#
# renderer.render()
#
# Path: css2video/renderers/video/render.py
# def render_video(image_sequence, output_path, framerate=30, renderer='FFMPEG'):
# if renderer == 'FFMPEG':
# renderer = FFMpegRenderer(image_sequence, output_path, framerate)
# renderer.render()
#
# Path: css2video/interpolators/stylesheet.py
# def interpolate_stylesheet(stylesheet_dict, time):
# """Interpolates the animation property value based on the given time and
# returns the resulting stylesheet as a dictionary"""
# generator = StyleSheetInterpolator(stylesheet_dict=stylesheet_dict)
# return generator.generate(time=time).to_dict()
#
# Path: css2video/parsers/stylesheet.py
# class StyleSheet(BaseParser):
# '''Parse a stylesheet'''
#
# @classmethod
# def grammar(cls):
# '''Grammar to parse a style sheet'''
# return pp.ZeroOrMore(Rule.parser())
#
# @classmethod
# def parse_action(cls, tokens):
# '''Returns a dictionary from the parsed tokens'''
# return {
# 'rules': [rule for rule in tokens]
# }
#
# Path: css2video/outputters/stylesheet.py
# def output_stylesheet(stylesheet_dict):
# '''Returns the stylesheet as a string'''
# return '\n'.join(
# [output_rule(rule) for rule in stylesheet_dict.get('rules', []) if rule['type'] == 'style'])
. Output only the next line. | render_video( |
Continue the code snippet: <|code_start|>def _get_image_sequence(total_frames):
return '%0{digits}d.jpg'.format(digits=len(str(total_frames)))
def _get_frame_image_name(frame, total_frames):
image_sequence = _get_image_sequence(total_frames=total_frames)
return image_sequence % frame
def render_animation(
html_path, css_path, output_path, duration, framerate=30, width=800,
height=600, image_renderer='CUTYCAPT', video_renderer='FFMPEG'):
with open(css_path, 'r') as fd:
css = fd.read()
html_path = os.path.abspath(html_path)
output_path = os.path.abspath(output_path)
stylesheet_dict = StyleSheet.parse(css)
total_frames = framerate * duration
duration_per_frame = float(duration) / total_frames
temp_dir = tempfile.mkdtemp()
for frame in tqdm(range(total_frames)):
time = frame * duration_per_frame
filename = _get_frame_image_name(
frame=frame, total_frames=total_frames)
<|code_end|>
. Use current file imports:
import os
import shutil
import tempfile
from tqdm import tqdm
from .image import render_image
from .video import render_video
from css2video.interpolators import interpolate_stylesheet
from css2video.parsers.stylesheet import StyleSheet
from css2video.outputters import output_stylesheet
and context (classes, functions, or code) from other files:
# Path: css2video/renderers/image/render.py
# def render_image(
# html_path, css_path, output_path, width=800, height=600,
# renderer='CUTYCAPT'):
# """Render HTML CSS as an image"""
#
# if renderer == 'CUTYCAPT':
# renderer = CutyCaptRenderer(
# html_path, css_path, output_path, width, height)
#
# renderer.render()
#
# Path: css2video/renderers/video/render.py
# def render_video(image_sequence, output_path, framerate=30, renderer='FFMPEG'):
# if renderer == 'FFMPEG':
# renderer = FFMpegRenderer(image_sequence, output_path, framerate)
# renderer.render()
#
# Path: css2video/interpolators/stylesheet.py
# def interpolate_stylesheet(stylesheet_dict, time):
# """Interpolates the animation property value based on the given time and
# returns the resulting stylesheet as a dictionary"""
# generator = StyleSheetInterpolator(stylesheet_dict=stylesheet_dict)
# return generator.generate(time=time).to_dict()
#
# Path: css2video/parsers/stylesheet.py
# class StyleSheet(BaseParser):
# '''Parse a stylesheet'''
#
# @classmethod
# def grammar(cls):
# '''Grammar to parse a style sheet'''
# return pp.ZeroOrMore(Rule.parser())
#
# @classmethod
# def parse_action(cls, tokens):
# '''Returns a dictionary from the parsed tokens'''
# return {
# 'rules': [rule for rule in tokens]
# }
#
# Path: css2video/outputters/stylesheet.py
# def output_stylesheet(stylesheet_dict):
# '''Returns the stylesheet as a string'''
# return '\n'.join(
# [output_rule(rule) for rule in stylesheet_dict.get('rules', []) if rule['type'] == 'style'])
. Output only the next line. | temp_stylesheet_dict = interpolate_stylesheet( |
Predict the next line after this snippet: <|code_start|>
def _get_image_sequence(total_frames):
return '%0{digits}d.jpg'.format(digits=len(str(total_frames)))
def _get_frame_image_name(frame, total_frames):
image_sequence = _get_image_sequence(total_frames=total_frames)
return image_sequence % frame
def render_animation(
html_path, css_path, output_path, duration, framerate=30, width=800,
height=600, image_renderer='CUTYCAPT', video_renderer='FFMPEG'):
with open(css_path, 'r') as fd:
css = fd.read()
html_path = os.path.abspath(html_path)
output_path = os.path.abspath(output_path)
<|code_end|>
using the current file's imports:
import os
import shutil
import tempfile
from tqdm import tqdm
from .image import render_image
from .video import render_video
from css2video.interpolators import interpolate_stylesheet
from css2video.parsers.stylesheet import StyleSheet
from css2video.outputters import output_stylesheet
and any relevant context from other files:
# Path: css2video/renderers/image/render.py
# def render_image(
# html_path, css_path, output_path, width=800, height=600,
# renderer='CUTYCAPT'):
# """Render HTML CSS as an image"""
#
# if renderer == 'CUTYCAPT':
# renderer = CutyCaptRenderer(
# html_path, css_path, output_path, width, height)
#
# renderer.render()
#
# Path: css2video/renderers/video/render.py
# def render_video(image_sequence, output_path, framerate=30, renderer='FFMPEG'):
# if renderer == 'FFMPEG':
# renderer = FFMpegRenderer(image_sequence, output_path, framerate)
# renderer.render()
#
# Path: css2video/interpolators/stylesheet.py
# def interpolate_stylesheet(stylesheet_dict, time):
# """Interpolates the animation property value based on the given time and
# returns the resulting stylesheet as a dictionary"""
# generator = StyleSheetInterpolator(stylesheet_dict=stylesheet_dict)
# return generator.generate(time=time).to_dict()
#
# Path: css2video/parsers/stylesheet.py
# class StyleSheet(BaseParser):
# '''Parse a stylesheet'''
#
# @classmethod
# def grammar(cls):
# '''Grammar to parse a style sheet'''
# return pp.ZeroOrMore(Rule.parser())
#
# @classmethod
# def parse_action(cls, tokens):
# '''Returns a dictionary from the parsed tokens'''
# return {
# 'rules': [rule for rule in tokens]
# }
#
# Path: css2video/outputters/stylesheet.py
# def output_stylesheet(stylesheet_dict):
# '''Returns the stylesheet as a string'''
# return '\n'.join(
# [output_rule(rule) for rule in stylesheet_dict.get('rules', []) if rule['type'] == 'style'])
. Output only the next line. | stylesheet_dict = StyleSheet.parse(css) |
Using the snippet: <|code_start|>
def _get_frame_image_name(frame, total_frames):
image_sequence = _get_image_sequence(total_frames=total_frames)
return image_sequence % frame
def render_animation(
html_path, css_path, output_path, duration, framerate=30, width=800,
height=600, image_renderer='CUTYCAPT', video_renderer='FFMPEG'):
with open(css_path, 'r') as fd:
css = fd.read()
html_path = os.path.abspath(html_path)
output_path = os.path.abspath(output_path)
stylesheet_dict = StyleSheet.parse(css)
total_frames = framerate * duration
duration_per_frame = float(duration) / total_frames
temp_dir = tempfile.mkdtemp()
for frame in tqdm(range(total_frames)):
time = frame * duration_per_frame
filename = _get_frame_image_name(
frame=frame, total_frames=total_frames)
temp_stylesheet_dict = interpolate_stylesheet(
stylesheet_dict=stylesheet_dict, time=time)
<|code_end|>
, determine the next line of code. You have imports:
import os
import shutil
import tempfile
from tqdm import tqdm
from .image import render_image
from .video import render_video
from css2video.interpolators import interpolate_stylesheet
from css2video.parsers.stylesheet import StyleSheet
from css2video.outputters import output_stylesheet
and context (class names, function names, or code) available:
# Path: css2video/renderers/image/render.py
# def render_image(
# html_path, css_path, output_path, width=800, height=600,
# renderer='CUTYCAPT'):
# """Render HTML CSS as an image"""
#
# if renderer == 'CUTYCAPT':
# renderer = CutyCaptRenderer(
# html_path, css_path, output_path, width, height)
#
# renderer.render()
#
# Path: css2video/renderers/video/render.py
# def render_video(image_sequence, output_path, framerate=30, renderer='FFMPEG'):
# if renderer == 'FFMPEG':
# renderer = FFMpegRenderer(image_sequence, output_path, framerate)
# renderer.render()
#
# Path: css2video/interpolators/stylesheet.py
# def interpolate_stylesheet(stylesheet_dict, time):
# """Interpolates the animation property value based on the given time and
# returns the resulting stylesheet as a dictionary"""
# generator = StyleSheetInterpolator(stylesheet_dict=stylesheet_dict)
# return generator.generate(time=time).to_dict()
#
# Path: css2video/parsers/stylesheet.py
# class StyleSheet(BaseParser):
# '''Parse a stylesheet'''
#
# @classmethod
# def grammar(cls):
# '''Grammar to parse a style sheet'''
# return pp.ZeroOrMore(Rule.parser())
#
# @classmethod
# def parse_action(cls, tokens):
# '''Returns a dictionary from the parsed tokens'''
# return {
# 'rules': [rule for rule in tokens]
# }
#
# Path: css2video/outputters/stylesheet.py
# def output_stylesheet(stylesheet_dict):
# '''Returns the stylesheet as a string'''
# return '\n'.join(
# [output_rule(rule) for rule in stylesheet_dict.get('rules', []) if rule['type'] == 'style'])
. Output only the next line. | temp_css = output_stylesheet(stylesheet_dict=temp_stylesheet_dict) |
Continue the code snippet: <|code_start|>
class StyleParseException(Exception):
"""Raised when there is an exception while parsing the style rule"""
pass
class Style(BaseParser):
"""Parse a CSS style rule"""
ParseException = StyleParseException
@classmethod
def grammar(cls):
"""Grammar to parse a CSS style rule"""
selector = pp.Word(pp.alphanums + '#.,*>+~[]=|^$:-() ')
return (
selector +
pp.Suppress(pp.Literal('{')) +
<|code_end|>
. Use current file imports:
import pyparsing as pp
from .base import BaseParser
from .property import Property
from css2video.constants import RuleType
and context (classes, functions, or code) from other files:
# Path: css2video/parsers/base.py
# class BaseParser(object):
# """
# A base class for all the parsers
#
# Attributes
# ----------
# ParseException : object
# exception to be raised when there is a parsing error
#
# Methods
# -------
# grammar :
# method to be overrridden by inheriting class which defines the grammar
# parse_action :
# method to be overrridden by inheriting class which defines the parse
# action for the matched token
# parser :
# returns a parser by setting the parse action to the grammar
# parse :
# method to parse a string into a dictionary using the grammar and parse
# action
# """
#
# ParseException = None
#
# @classmethod
# def grammar(cls):
# """This method is overridden by the class which inherits the
# BaseParser. The method should return a grammar"""
# raise NotImplemented()
#
# @classmethod
# def parse_action(cls):
# """This method is overridden by the class which inherits the
# BaseParser. The method should create a dictionary from the parsed
# tokens"""
# raise NotImplemented()
#
# @classmethod
# def parser(cls):
# """Returns the grammar with parse action set so that once the result is
# parsed, the output is available as a dictionary"""
# return cls.grammar().setParseAction(cls.parse_action)
#
# @classmethod
# def parse(cls, string):
# """
# Parse a given string using the grammar and parse action and returns
# a dictionary
#
# Parameters
# ----------
# string : str
# string to be parsed
#
# Returns
# -------
# dict :
# dictionary after parsing the string
# """
# try:
# return cls.parser().parseString(string, parseAll=True)[0]
# except pp.ParseException:
# raise cls.ParseException()
#
# Path: css2video/parsers/property.py
# class Property(BaseParser):
# """Parse a CSS property"""
#
# ParseException = PropertyParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a CSS property"""
# name = pp.Word(pp.alphas + '-')
# value = Value.parser()
# return (
# name +
# pp.Suppress(pp.Literal(':')) +
# value +
# pp.Suppress(pp.Literal(";"))
# )
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'property_name': tokens[0].lower(), # Normalize the name
# 'property_value': tokens[1]
# }
#
# Path: css2video/constants.py
# class RuleType(object):
# """Class to define constants for rule types"""
#
# style = 'style'
# keyframes = 'keyframes'
. Output only the next line. | pp.ZeroOrMore(Property.parser()) + |
Predict the next line after this snippet: <|code_start|>
class StyleParseException(Exception):
"""Raised when there is an exception while parsing the style rule"""
pass
class Style(BaseParser):
"""Parse a CSS style rule"""
ParseException = StyleParseException
@classmethod
def grammar(cls):
"""Grammar to parse a CSS style rule"""
selector = pp.Word(pp.alphanums + '#.,*>+~[]=|^$:-() ')
return (
selector +
pp.Suppress(pp.Literal('{')) +
pp.ZeroOrMore(Property.parser()) +
pp.Suppress(pp.Literal('}'))
)
@classmethod
def parse_action(cls, tokens):
"""Returns a dictionary from the parsed tokens"""
return {
<|code_end|>
using the current file's imports:
import pyparsing as pp
from .base import BaseParser
from .property import Property
from css2video.constants import RuleType
and any relevant context from other files:
# Path: css2video/parsers/base.py
# class BaseParser(object):
# """
# A base class for all the parsers
#
# Attributes
# ----------
# ParseException : object
# exception to be raised when there is a parsing error
#
# Methods
# -------
# grammar :
# method to be overrridden by inheriting class which defines the grammar
# parse_action :
# method to be overrridden by inheriting class which defines the parse
# action for the matched token
# parser :
# returns a parser by setting the parse action to the grammar
# parse :
# method to parse a string into a dictionary using the grammar and parse
# action
# """
#
# ParseException = None
#
# @classmethod
# def grammar(cls):
# """This method is overridden by the class which inherits the
# BaseParser. The method should return a grammar"""
# raise NotImplemented()
#
# @classmethod
# def parse_action(cls):
# """This method is overridden by the class which inherits the
# BaseParser. The method should create a dictionary from the parsed
# tokens"""
# raise NotImplemented()
#
# @classmethod
# def parser(cls):
# """Returns the grammar with parse action set so that once the result is
# parsed, the output is available as a dictionary"""
# return cls.grammar().setParseAction(cls.parse_action)
#
# @classmethod
# def parse(cls, string):
# """
# Parse a given string using the grammar and parse action and returns
# a dictionary
#
# Parameters
# ----------
# string : str
# string to be parsed
#
# Returns
# -------
# dict :
# dictionary after parsing the string
# """
# try:
# return cls.parser().parseString(string, parseAll=True)[0]
# except pp.ParseException:
# raise cls.ParseException()
#
# Path: css2video/parsers/property.py
# class Property(BaseParser):
# """Parse a CSS property"""
#
# ParseException = PropertyParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a CSS property"""
# name = pp.Word(pp.alphas + '-')
# value = Value.parser()
# return (
# name +
# pp.Suppress(pp.Literal(':')) +
# value +
# pp.Suppress(pp.Literal(";"))
# )
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'property_name': tokens[0].lower(), # Normalize the name
# 'property_value': tokens[1]
# }
#
# Path: css2video/constants.py
# class RuleType(object):
# """Class to define constants for rule types"""
#
# style = 'style'
# keyframes = 'keyframes'
. Output only the next line. | 'type': RuleType.style, |
Continue the code snippet: <|code_start|>
def parse_value(string):
'''Parse a value'''
return Value.parser().parseString(string)[0]
def parse_property(string):
'''Parse a CSS property'''
<|code_end|>
. Use current file imports:
from .property import Property
from .rule import Rule
from .stylesheet import StyleSheet
from .value import Value
and context (classes, functions, or code) from other files:
# Path: css2video/parsers/property.py
# class Property(BaseParser):
# """Parse a CSS property"""
#
# ParseException = PropertyParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a CSS property"""
# name = pp.Word(pp.alphas + '-')
# value = Value.parser()
# return (
# name +
# pp.Suppress(pp.Literal(':')) +
# value +
# pp.Suppress(pp.Literal(";"))
# )
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'property_name': tokens[0].lower(), # Normalize the name
# 'property_value': tokens[1]
# }
#
# Path: css2video/parsers/rule.py
# class Rule(object):
# """Parse any CSS rule"""
#
# @classmethod
# def parser(cls):
# """Grammar to parse any CSS rule"""
# return (
# Style.parser() ^
# Keyframes.parser()
# )
#
# Path: css2video/parsers/stylesheet.py
# class StyleSheet(BaseParser):
# '''Parse a stylesheet'''
#
# @classmethod
# def grammar(cls):
# '''Grammar to parse a style sheet'''
# return pp.ZeroOrMore(Rule.parser())
#
# @classmethod
# def parse_action(cls, tokens):
# '''Returns a dictionary from the parsed tokens'''
# return {
# 'rules': [rule for rule in tokens]
# }
#
# Path: css2video/parsers/value.py
# class Value(object):
# """Parse any CSS property value"""
#
# @classmethod
# def parser(cls):
# """Grammar to parse any CSS Property value"""
# return (
# Number.parser() ^
# Length.parser() ^
# Percentage.parser() ^
# Time.parser() ^
# Color.parser() ^
# Text.parser() ^
# Url.parser() ^
# Function.parser() ^
# Array.parser()
# )
. Output only the next line. | return Property.parser().parseString(string)[0] |
Here is a snippet: <|code_start|>
def parse_value(string):
'''Parse a value'''
return Value.parser().parseString(string)[0]
def parse_property(string):
'''Parse a CSS property'''
return Property.parser().parseString(string)[0]
def parse_rule(string):
'''Parse a CSS rule'''
<|code_end|>
. Write the next line using the current file imports:
from .property import Property
from .rule import Rule
from .stylesheet import StyleSheet
from .value import Value
and context from other files:
# Path: css2video/parsers/property.py
# class Property(BaseParser):
# """Parse a CSS property"""
#
# ParseException = PropertyParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a CSS property"""
# name = pp.Word(pp.alphas + '-')
# value = Value.parser()
# return (
# name +
# pp.Suppress(pp.Literal(':')) +
# value +
# pp.Suppress(pp.Literal(";"))
# )
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'property_name': tokens[0].lower(), # Normalize the name
# 'property_value': tokens[1]
# }
#
# Path: css2video/parsers/rule.py
# class Rule(object):
# """Parse any CSS rule"""
#
# @classmethod
# def parser(cls):
# """Grammar to parse any CSS rule"""
# return (
# Style.parser() ^
# Keyframes.parser()
# )
#
# Path: css2video/parsers/stylesheet.py
# class StyleSheet(BaseParser):
# '''Parse a stylesheet'''
#
# @classmethod
# def grammar(cls):
# '''Grammar to parse a style sheet'''
# return pp.ZeroOrMore(Rule.parser())
#
# @classmethod
# def parse_action(cls, tokens):
# '''Returns a dictionary from the parsed tokens'''
# return {
# 'rules': [rule for rule in tokens]
# }
#
# Path: css2video/parsers/value.py
# class Value(object):
# """Parse any CSS property value"""
#
# @classmethod
# def parser(cls):
# """Grammar to parse any CSS Property value"""
# return (
# Number.parser() ^
# Length.parser() ^
# Percentage.parser() ^
# Time.parser() ^
# Color.parser() ^
# Text.parser() ^
# Url.parser() ^
# Function.parser() ^
# Array.parser()
# )
, which may include functions, classes, or code. Output only the next line. | return Rule.parser().parseString(string)[0] |
Based on the snippet: <|code_start|>
def parse_value(string):
'''Parse a value'''
return Value.parser().parseString(string)[0]
def parse_property(string):
'''Parse a CSS property'''
return Property.parser().parseString(string)[0]
def parse_rule(string):
'''Parse a CSS rule'''
return Rule.parser().parseString(string)[0]
def parse_stylesheet(string):
'''Parse a stylesheet'''
<|code_end|>
, predict the immediate next line with the help of imports:
from .property import Property
from .rule import Rule
from .stylesheet import StyleSheet
from .value import Value
and context (classes, functions, sometimes code) from other files:
# Path: css2video/parsers/property.py
# class Property(BaseParser):
# """Parse a CSS property"""
#
# ParseException = PropertyParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a CSS property"""
# name = pp.Word(pp.alphas + '-')
# value = Value.parser()
# return (
# name +
# pp.Suppress(pp.Literal(':')) +
# value +
# pp.Suppress(pp.Literal(";"))
# )
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'property_name': tokens[0].lower(), # Normalize the name
# 'property_value': tokens[1]
# }
#
# Path: css2video/parsers/rule.py
# class Rule(object):
# """Parse any CSS rule"""
#
# @classmethod
# def parser(cls):
# """Grammar to parse any CSS rule"""
# return (
# Style.parser() ^
# Keyframes.parser()
# )
#
# Path: css2video/parsers/stylesheet.py
# class StyleSheet(BaseParser):
# '''Parse a stylesheet'''
#
# @classmethod
# def grammar(cls):
# '''Grammar to parse a style sheet'''
# return pp.ZeroOrMore(Rule.parser())
#
# @classmethod
# def parse_action(cls, tokens):
# '''Returns a dictionary from the parsed tokens'''
# return {
# 'rules': [rule for rule in tokens]
# }
#
# Path: css2video/parsers/value.py
# class Value(object):
# """Parse any CSS property value"""
#
# @classmethod
# def parser(cls):
# """Grammar to parse any CSS Property value"""
# return (
# Number.parser() ^
# Length.parser() ^
# Percentage.parser() ^
# Time.parser() ^
# Color.parser() ^
# Text.parser() ^
# Url.parser() ^
# Function.parser() ^
# Array.parser()
# )
. Output only the next line. | return StyleSheet.parser().parseString(string)[0] |
Next line prediction: <|code_start|> 'type': 'array',
'values': [
{
'type': 'length',
'value': 0,
'unit': 'px'
},
{
'type': 'length',
'value': 0,
'unit': 'px'
},
{
'type': 'length',
'value': 4,
'unit': 'px'
},
{
'type': 'color',
'red': 0,
'green': 0,
'blue': 0,
'alpha': 1
}
]
}
}
)
]
for property, expected_parsed_property in property_data:
<|code_end|>
. Use current file imports:
(import unittest
from css2video.parsers import parse_property
from css2video.parsers import parse_rule
from css2video.parsers import parse_stylesheet
from css2video.parsers import parse_value
from .utils import isEqual)
and context including class names, function names, or small code snippets from other files:
# Path: css2video/parsers/api.py
# def parse_property(string):
# '''Parse a CSS property'''
# return Property.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_rule(string):
# '''Parse a CSS rule'''
# return Rule.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_stylesheet(string):
# '''Parse a stylesheet'''
# return StyleSheet.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_value(string):
# '''Parse a value'''
# return Value.parser().parseString(string)[0]
#
# Path: tests/utils.py
# def isEqual(value1, value2):
# '''Compare any two values and returns true if they are equal'''
# if isinstance(value1, list) and isinstance(value2, list):
# is_equal = True
# for v1, v2 in zip(value1, value2):
# is_equal = is_equal and isEqual(v1, v2)
# if not is_equal:
# break
# return is_equal
#
# if isinstance(value1, dict) and isinstance(value2, dict):
# is_equal = len(value1.keys()) == len(value2.keys())
# for key1 in value1:
# is_equal = is_equal and (key1 in value2)
# if not is_equal:
# break
# is_equal = is_equal and isEqual(value1[key1], value2[key1])
# if not is_equal:
# break
# return is_equal
# return value1 == value2
. Output only the next line. | parsed_property = parse_property(property) |
Given the code snippet: <|code_start|> 'properties': [
{
'property_name': 'top',
'property_value': {
'type': 'length',
'value': 0,
'unit': 'px'
}
}
]
},
{
'keyframe_selector': 100,
'properties': [
{
'property_name': 'top',
'property_value': {
'type': 'length',
'value': 200,
'unit': 'px'
}
}
]
}
]
}
)
]
for rule, expected_parsed_rule in rule_data:
<|code_end|>
, generate the next line using the imports in this file:
import unittest
from css2video.parsers import parse_property
from css2video.parsers import parse_rule
from css2video.parsers import parse_stylesheet
from css2video.parsers import parse_value
from .utils import isEqual
and context (functions, classes, or occasionally code) from other files:
# Path: css2video/parsers/api.py
# def parse_property(string):
# '''Parse a CSS property'''
# return Property.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_rule(string):
# '''Parse a CSS rule'''
# return Rule.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_stylesheet(string):
# '''Parse a stylesheet'''
# return StyleSheet.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_value(string):
# '''Parse a value'''
# return Value.parser().parseString(string)[0]
#
# Path: tests/utils.py
# def isEqual(value1, value2):
# '''Compare any two values and returns true if they are equal'''
# if isinstance(value1, list) and isinstance(value2, list):
# is_equal = True
# for v1, v2 in zip(value1, value2):
# is_equal = is_equal and isEqual(v1, v2)
# if not is_equal:
# break
# return is_equal
#
# if isinstance(value1, dict) and isinstance(value2, dict):
# is_equal = len(value1.keys()) == len(value2.keys())
# for key1 in value1:
# is_equal = is_equal and (key1 in value2)
# if not is_equal:
# break
# is_equal = is_equal and isEqual(value1[key1], value2[key1])
# if not is_equal:
# break
# return is_equal
# return value1 == value2
. Output only the next line. | parsed_rule = parse_rule(rule) |
Continue the code snippet: <|code_start|> {
'keyframe_selector': 0,
'properties': [
{
'property_name': 'top',
'property_value': {
'type': 'length',
'value': 0,
'unit': 'px'
}
}
]
},
{
'keyframe_selector': 100,
'properties': [
{
'property_name': 'top',
'property_value': {
'type': 'length',
'value': 200,
'unit': 'px'
}
}
]
}
]
}
]
}
<|code_end|>
. Use current file imports:
import unittest
from css2video.parsers import parse_property
from css2video.parsers import parse_rule
from css2video.parsers import parse_stylesheet
from css2video.parsers import parse_value
from .utils import isEqual
and context (classes, functions, or code) from other files:
# Path: css2video/parsers/api.py
# def parse_property(string):
# '''Parse a CSS property'''
# return Property.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_rule(string):
# '''Parse a CSS rule'''
# return Rule.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_stylesheet(string):
# '''Parse a stylesheet'''
# return StyleSheet.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_value(string):
# '''Parse a value'''
# return Value.parser().parseString(string)[0]
#
# Path: tests/utils.py
# def isEqual(value1, value2):
# '''Compare any two values and returns true if they are equal'''
# if isinstance(value1, list) and isinstance(value2, list):
# is_equal = True
# for v1, v2 in zip(value1, value2):
# is_equal = is_equal and isEqual(v1, v2)
# if not is_equal:
# break
# return is_equal
#
# if isinstance(value1, dict) and isinstance(value2, dict):
# is_equal = len(value1.keys()) == len(value2.keys())
# for key1 in value1:
# is_equal = is_equal and (key1 in value2)
# if not is_equal:
# break
# is_equal = is_equal and isEqual(value1[key1], value2[key1])
# if not is_equal:
# break
# return is_equal
# return value1 == value2
. Output only the next line. | parsed_stylesheet = parse_stylesheet(stylesheet) |
Predict the next line after this snippet: <|code_start|> },
{
'type': 'time',
'value': 2
},
]
},
'20px rgba(255, 255, 255, 1)': {
'type': 'array',
'values': [
{
'type': 'length',
'value': 20,
'unit': 'px'
},
{
'type': 'color',
'red': 255,
'green': 255,
'blue': 255,
'alpha': 1
}
]
},
'"http://www.google.com"': {
'type': 'url',
'value': '"http://www.google.com"'
}
}
for value, expected_parsed_value in value_data.items():
<|code_end|>
using the current file's imports:
import unittest
from css2video.parsers import parse_property
from css2video.parsers import parse_rule
from css2video.parsers import parse_stylesheet
from css2video.parsers import parse_value
from .utils import isEqual
and any relevant context from other files:
# Path: css2video/parsers/api.py
# def parse_property(string):
# '''Parse a CSS property'''
# return Property.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_rule(string):
# '''Parse a CSS rule'''
# return Rule.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_stylesheet(string):
# '''Parse a stylesheet'''
# return StyleSheet.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_value(string):
# '''Parse a value'''
# return Value.parser().parseString(string)[0]
#
# Path: tests/utils.py
# def isEqual(value1, value2):
# '''Compare any two values and returns true if they are equal'''
# if isinstance(value1, list) and isinstance(value2, list):
# is_equal = True
# for v1, v2 in zip(value1, value2):
# is_equal = is_equal and isEqual(v1, v2)
# if not is_equal:
# break
# return is_equal
#
# if isinstance(value1, dict) and isinstance(value2, dict):
# is_equal = len(value1.keys()) == len(value2.keys())
# for key1 in value1:
# is_equal = is_equal and (key1 in value2)
# if not is_equal:
# break
# is_equal = is_equal and isEqual(value1[key1], value2[key1])
# if not is_equal:
# break
# return is_equal
# return value1 == value2
. Output only the next line. | parsed_value = parse_value(value) |
Given snippet: <|code_start|> {
'type': 'time',
'value': 2
},
]
},
'20px rgba(255, 255, 255, 1)': {
'type': 'array',
'values': [
{
'type': 'length',
'value': 20,
'unit': 'px'
},
{
'type': 'color',
'red': 255,
'green': 255,
'blue': 255,
'alpha': 1
}
]
},
'"http://www.google.com"': {
'type': 'url',
'value': '"http://www.google.com"'
}
}
for value, expected_parsed_value in value_data.items():
parsed_value = parse_value(value)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import unittest
from css2video.parsers import parse_property
from css2video.parsers import parse_rule
from css2video.parsers import parse_stylesheet
from css2video.parsers import parse_value
from .utils import isEqual
and context:
# Path: css2video/parsers/api.py
# def parse_property(string):
# '''Parse a CSS property'''
# return Property.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_rule(string):
# '''Parse a CSS rule'''
# return Rule.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_stylesheet(string):
# '''Parse a stylesheet'''
# return StyleSheet.parser().parseString(string)[0]
#
# Path: css2video/parsers/api.py
# def parse_value(string):
# '''Parse a value'''
# return Value.parser().parseString(string)[0]
#
# Path: tests/utils.py
# def isEqual(value1, value2):
# '''Compare any two values and returns true if they are equal'''
# if isinstance(value1, list) and isinstance(value2, list):
# is_equal = True
# for v1, v2 in zip(value1, value2):
# is_equal = is_equal and isEqual(v1, v2)
# if not is_equal:
# break
# return is_equal
#
# if isinstance(value1, dict) and isinstance(value2, dict):
# is_equal = len(value1.keys()) == len(value2.keys())
# for key1 in value1:
# is_equal = is_equal and (key1 in value2)
# if not is_equal:
# break
# is_equal = is_equal and isEqual(value1[key1], value2[key1])
# if not is_equal:
# break
# return is_equal
# return value1 == value2
which might include code, classes, or functions. Output only the next line. | self.assertTrue(isEqual(parsed_value, expected_parsed_value)) |
Next line prediction: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Url.parse('"http://www.google.com"')
self.assertEqual(
response,
<|code_end|>
. Use current file imports:
(import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Url, UrlParseException)
and context including class names, function names, or small code snippets from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Url(BaseParser):
# """Parse a URL value which is usually a quoted string"""
#
# ParseException = UrlParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a URL value"""
# return pp.quotedString
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.url,
# 'value': tokens[0]
# }
#
# class UrlParseException(Exception):
# """Raised when there is an exception while parsing an URL value"""
# pass
. Output only the next line. | dict(type=ValueType.url, value='"http://www.google.com"') |
Given snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Url.parse('"http://www.google.com"')
self.assertEqual(
response,
dict(type=ValueType.url, value='"http://www.google.com"')
)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Url, UrlParseException
and context:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Url(BaseParser):
# """Parse a URL value which is usually a quoted string"""
#
# ParseException = UrlParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a URL value"""
# return pp.quotedString
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.url,
# 'value': tokens[0]
# }
#
# class UrlParseException(Exception):
# """Raised when there is an exception while parsing an URL value"""
# pass
which might include code, classes, or functions. Output only the next line. | with self.assertRaises(UrlParseException): |
Here is a snippet: <|code_start|>
class StyleSheetComponent(BaseComponent):
"""A wrapper from stylesheet dictionary object"""
def __init__(self, *args, **kwargs):
super(StyleSheetComponent, self).__init__(*args, **kwargs)
@property
def style_rules(self):
"""Returns the style components"""
style_rules = filter(
lambda x: x['type'] == 'style', self.Dict.get('rules', []))
return [
StyleRuleComponent.from_dict(Dict=rule) for rule in style_rules
]
@property
def keyframes_rules(self):
keyframes_rules = filter(
lambda x: x['type'] == 'keyframes', self.Dict.get('rules', []))
return [
<|code_end|>
. Write the next line using the current file imports:
from .base import BaseComponent
from .rule import KeyframesRuleComponent
from .rule import StyleRuleComponent
and context from other files:
# Path: css2video/components/base.py
# class BaseComponent(object):
# """A base component for other CSS components
#
# Public attributes:
# - Dict: Dictionary form of the component
# """
#
# def __init__(self, Dict):
# super(BaseComponent, self).__init__()
# self.Dict = Dict
#
# @classmethod
# def from_dict(cls, Dict):
# """Creates a component from dictionary"""
# return cls(Dict=Dict)
#
# def to_dict(self):
# """Returns the dictionary form of the component"""
# return self.Dict
#
# def duplicate(self):
# """Returns a duplicate of this component"""
# return self.__class__(Dict=copy.deepcopy(self.Dict))
#
# Path: css2video/components/rule.py
# class KeyframesRuleComponent(BaseComponent):
# """A wrapper for CSS keyframes rule dictionary object"""
#
# def __init__(self, *args, **kwargs):
# super(KeyframesRuleComponent, self).__init__(*args, **kwargs)
#
# @property
# def name(self):
# """Name of animation"""
# return self.Dict.get('name')
#
# @property
# def keyframe_properties(self):
# """Keyframe properties of the animation"""
# keyframe_properties = [
# KeyframePropertiesComponent(k)
# for k in self.Dict.get('keyframes', [])
# ]
# keyframe_properties.sort(key=lambda x: x.time_offset)
# return keyframe_properties
#
# def get_property_sets(self, time_offset):
# """For a given time offset, it returns the keyframe properties
# before and after this time offset
#
# Args:
# - time_offset: time offset in percentage
#
# Returns:
# (props_1, props_2) where props_1 are properties before
# the time offset and props_2 are properties after the time offset
# """
# set1 = set2 = None
# for kfp in self.keyframe_properties:
# if kfp.time_offset <= time_offset:
# set1 = kfp
#
# for kfp in self.keyframe_properties[::-1]:
# if kfp.time_offset >= time_offset:
# set2 = kfp
# return (set1, set2)
#
# Path: css2video/components/rule.py
# class StyleRuleComponent(BaseComponent):
# """A wrapper for CSS style rule dictionary object"""
#
# def __init__(self, *args, **kwargs):
# super(StyleRuleComponent, self).__init__(*args, **kwargs)
#
# @property
# def properties(self):
# '''Returns all the properties as a dictionary'''
# return {
# p['property_name']: p['property_value']
# for p in self.Dict.get('properties', [])
# }
#
# def animation_properties(self):
# '''Returns all the animation related properties as a dictionary'''
# properties = {
# 'animation-name': '',
# 'animation-duration': 0,
# 'animation-delay': 0,
# 'animation-iteration-count': 1,
# 'animation-timing-function': 'ease'
# }
# for key in properties:
# if self.properties.get(key):
# value = self.properties.get(key)
# properties[key] = value.get('value')
# return properties
#
# def property_list(self):
# '''Returns a list of property names'''
# return [p['property_name'] for p in self.Dict.get('properties', [])]
#
# def add_property(self, name, value):
# '''Add a new property and value'''
# self.Dict['properties'].append({
# 'property_name': name,
# 'property_value': value
# })
, which may include functions, classes, or code. Output only the next line. | KeyframesRuleComponent.from_dict(Dict=rule) |
Given snippet: <|code_start|>
class StyleSheetComponent(BaseComponent):
"""A wrapper from stylesheet dictionary object"""
def __init__(self, *args, **kwargs):
super(StyleSheetComponent, self).__init__(*args, **kwargs)
@property
def style_rules(self):
"""Returns the style components"""
style_rules = filter(
lambda x: x['type'] == 'style', self.Dict.get('rules', []))
return [
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import BaseComponent
from .rule import KeyframesRuleComponent
from .rule import StyleRuleComponent
and context:
# Path: css2video/components/base.py
# class BaseComponent(object):
# """A base component for other CSS components
#
# Public attributes:
# - Dict: Dictionary form of the component
# """
#
# def __init__(self, Dict):
# super(BaseComponent, self).__init__()
# self.Dict = Dict
#
# @classmethod
# def from_dict(cls, Dict):
# """Creates a component from dictionary"""
# return cls(Dict=Dict)
#
# def to_dict(self):
# """Returns the dictionary form of the component"""
# return self.Dict
#
# def duplicate(self):
# """Returns a duplicate of this component"""
# return self.__class__(Dict=copy.deepcopy(self.Dict))
#
# Path: css2video/components/rule.py
# class KeyframesRuleComponent(BaseComponent):
# """A wrapper for CSS keyframes rule dictionary object"""
#
# def __init__(self, *args, **kwargs):
# super(KeyframesRuleComponent, self).__init__(*args, **kwargs)
#
# @property
# def name(self):
# """Name of animation"""
# return self.Dict.get('name')
#
# @property
# def keyframe_properties(self):
# """Keyframe properties of the animation"""
# keyframe_properties = [
# KeyframePropertiesComponent(k)
# for k in self.Dict.get('keyframes', [])
# ]
# keyframe_properties.sort(key=lambda x: x.time_offset)
# return keyframe_properties
#
# def get_property_sets(self, time_offset):
# """For a given time offset, it returns the keyframe properties
# before and after this time offset
#
# Args:
# - time_offset: time offset in percentage
#
# Returns:
# (props_1, props_2) where props_1 are properties before
# the time offset and props_2 are properties after the time offset
# """
# set1 = set2 = None
# for kfp in self.keyframe_properties:
# if kfp.time_offset <= time_offset:
# set1 = kfp
#
# for kfp in self.keyframe_properties[::-1]:
# if kfp.time_offset >= time_offset:
# set2 = kfp
# return (set1, set2)
#
# Path: css2video/components/rule.py
# class StyleRuleComponent(BaseComponent):
# """A wrapper for CSS style rule dictionary object"""
#
# def __init__(self, *args, **kwargs):
# super(StyleRuleComponent, self).__init__(*args, **kwargs)
#
# @property
# def properties(self):
# '''Returns all the properties as a dictionary'''
# return {
# p['property_name']: p['property_value']
# for p in self.Dict.get('properties', [])
# }
#
# def animation_properties(self):
# '''Returns all the animation related properties as a dictionary'''
# properties = {
# 'animation-name': '',
# 'animation-duration': 0,
# 'animation-delay': 0,
# 'animation-iteration-count': 1,
# 'animation-timing-function': 'ease'
# }
# for key in properties:
# if self.properties.get(key):
# value = self.properties.get(key)
# properties[key] = value.get('value')
# return properties
#
# def property_list(self):
# '''Returns a list of property names'''
# return [p['property_name'] for p in self.Dict.get('properties', [])]
#
# def add_property(self, name, value):
# '''Add a new property and value'''
# self.Dict['properties'].append({
# 'property_name': name,
# 'property_value': value
# })
which might include code, classes, or functions. Output only the next line. | StyleRuleComponent.from_dict(Dict=rule) for rule in style_rules |
Given the code snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Array.parse('20px rgba(0, 0, 0, 1)')
self.assertEqual(
response,
<|code_end|>
, generate the next line using the imports in this file:
import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Array, ArrayParseException
and context (functions, classes, or occasionally code) from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Array(BaseParser):
# """Parse an array value. The array item values can be of any type"""
#
# ParseException = ArrayParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse an array value"""
# array_types = [
# Number, Length, Percentage, Time, Color, Text, Url, Function]
# array_parser = array_types[0].parser()
# for array_type in array_types[1:]:
# array_parser ^= array_type.parser()
# return array_parser + pp.OneOrMore(array_parser)
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.array,
# 'values': [value for value in tokens]
# }
#
# class ArrayParseException(Exception):
# """Raised when there is an exception while parsing an array value"""
# pass
. Output only the next line. | dict(type=ValueType.array, values=[ |
Continue the code snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Array.parse('20px rgba(0, 0, 0, 1)')
self.assertEqual(
response,
dict(type=ValueType.array, values=[
dict(type=ValueType.length, value=20., unit='px'),
dict(type=ValueType.color, red=0, green=0, blue=0, alpha=1)
])
)
<|code_end|>
. Use current file imports:
import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Array, ArrayParseException
and context (classes, functions, or code) from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Array(BaseParser):
# """Parse an array value. The array item values can be of any type"""
#
# ParseException = ArrayParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse an array value"""
# array_types = [
# Number, Length, Percentage, Time, Color, Text, Url, Function]
# array_parser = array_types[0].parser()
# for array_type in array_types[1:]:
# array_parser ^= array_type.parser()
# return array_parser + pp.OneOrMore(array_parser)
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.array,
# 'values': [value for value in tokens]
# }
#
# class ArrayParseException(Exception):
# """Raised when there is an exception while parsing an array value"""
# pass
. Output only the next line. | with self.assertRaises(ArrayParseException): |
Next line prediction: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Length.parse('20px')
self.assertEqual(
<|code_end|>
. Use current file imports:
(import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Length, LengthParseException)
and context including class names, function names, or small code snippets from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Length(BaseParser):
# """Parse a length value that has a unit attached along with the number"""
#
# ParseException = LengthParseException
#
# UNITS = ['em', 'ex', 'px', 'cm', 'mm', 'in', 'pt', 'pc', 'deg']
#
# @classmethod
# def grammar(cls):
# """Grammar to parse the length value"""
# number = Number.grammar()
# units = pp.CaselessLiteral(cls.UNITS[0])
# for unit in cls.UNITS[1:]:
# units |= pp.Literal(unit)
# return number + units.leaveWhitespace()
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.length,
# 'value': float(tokens[0]),
# 'unit': tokens[1].lower() # normalizing the units
# }
#
# class LengthParseException(Exception):
# """Raised when there is an execption while parsing a length"""
# pass
. Output only the next line. | response, dict(type=ValueType.length, value=20., unit='px') |
Predict the next line for this snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Length.parse('20px')
self.assertEqual(
response, dict(type=ValueType.length, value=20., unit='px')
)
response = Length.parse('-40.5EM')
self.assertEqual(
response, dict(type=ValueType.length, value=-40.5, unit='em')
)
<|code_end|>
with the help of current file imports:
import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Length, LengthParseException
and context from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Length(BaseParser):
# """Parse a length value that has a unit attached along with the number"""
#
# ParseException = LengthParseException
#
# UNITS = ['em', 'ex', 'px', 'cm', 'mm', 'in', 'pt', 'pc', 'deg']
#
# @classmethod
# def grammar(cls):
# """Grammar to parse the length value"""
# number = Number.grammar()
# units = pp.CaselessLiteral(cls.UNITS[0])
# for unit in cls.UNITS[1:]:
# units |= pp.Literal(unit)
# return number + units.leaveWhitespace()
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.length,
# 'value': float(tokens[0]),
# 'unit': tokens[1].lower() # normalizing the units
# }
#
# class LengthParseException(Exception):
# """Raised when there is an execption while parsing a length"""
# pass
, which may contain function names, class names, or code. Output only the next line. | with self.assertRaises(LengthParseException): |
Given the following code snippet before the placeholder: <|code_start|>
class StyleSheet(BaseParser):
'''Parse a stylesheet'''
@classmethod
def grammar(cls):
'''Grammar to parse a style sheet'''
<|code_end|>
, predict the next line using imports from the current file:
from .base import BaseParser
from .rule import Rule
import pyparsing as pp
and context including class names, function names, and sometimes code from other files:
# Path: css2video/parsers/base.py
# class BaseParser(object):
# """
# A base class for all the parsers
#
# Attributes
# ----------
# ParseException : object
# exception to be raised when there is a parsing error
#
# Methods
# -------
# grammar :
# method to be overrridden by inheriting class which defines the grammar
# parse_action :
# method to be overrridden by inheriting class which defines the parse
# action for the matched token
# parser :
# returns a parser by setting the parse action to the grammar
# parse :
# method to parse a string into a dictionary using the grammar and parse
# action
# """
#
# ParseException = None
#
# @classmethod
# def grammar(cls):
# """This method is overridden by the class which inherits the
# BaseParser. The method should return a grammar"""
# raise NotImplemented()
#
# @classmethod
# def parse_action(cls):
# """This method is overridden by the class which inherits the
# BaseParser. The method should create a dictionary from the parsed
# tokens"""
# raise NotImplemented()
#
# @classmethod
# def parser(cls):
# """Returns the grammar with parse action set so that once the result is
# parsed, the output is available as a dictionary"""
# return cls.grammar().setParseAction(cls.parse_action)
#
# @classmethod
# def parse(cls, string):
# """
# Parse a given string using the grammar and parse action and returns
# a dictionary
#
# Parameters
# ----------
# string : str
# string to be parsed
#
# Returns
# -------
# dict :
# dictionary after parsing the string
# """
# try:
# return cls.parser().parseString(string, parseAll=True)[0]
# except pp.ParseException:
# raise cls.ParseException()
#
# Path: css2video/parsers/rule.py
# class Rule(object):
# """Parse any CSS rule"""
#
# @classmethod
# def parser(cls):
# """Grammar to parse any CSS rule"""
# return (
# Style.parser() ^
# Keyframes.parser()
# )
. Output only the next line. | return pp.ZeroOrMore(Rule.parser()) |
Predict the next line for this snippet: <|code_start|>
class PropertyParseException(Exception):
"""Raised when there is an exception while parsing a property"""
pass
class Property(BaseParser):
"""Parse a CSS property"""
ParseException = PropertyParseException
@classmethod
def grammar(cls):
"""Grammar to parse a CSS property"""
name = pp.Word(pp.alphas + '-')
<|code_end|>
with the help of current file imports:
import pyparsing as pp
from .base import BaseParser
from .value import Value
and context from other files:
# Path: css2video/parsers/base.py
# class BaseParser(object):
# """
# A base class for all the parsers
#
# Attributes
# ----------
# ParseException : object
# exception to be raised when there is a parsing error
#
# Methods
# -------
# grammar :
# method to be overrridden by inheriting class which defines the grammar
# parse_action :
# method to be overrridden by inheriting class which defines the parse
# action for the matched token
# parser :
# returns a parser by setting the parse action to the grammar
# parse :
# method to parse a string into a dictionary using the grammar and parse
# action
# """
#
# ParseException = None
#
# @classmethod
# def grammar(cls):
# """This method is overridden by the class which inherits the
# BaseParser. The method should return a grammar"""
# raise NotImplemented()
#
# @classmethod
# def parse_action(cls):
# """This method is overridden by the class which inherits the
# BaseParser. The method should create a dictionary from the parsed
# tokens"""
# raise NotImplemented()
#
# @classmethod
# def parser(cls):
# """Returns the grammar with parse action set so that once the result is
# parsed, the output is available as a dictionary"""
# return cls.grammar().setParseAction(cls.parse_action)
#
# @classmethod
# def parse(cls, string):
# """
# Parse a given string using the grammar and parse action and returns
# a dictionary
#
# Parameters
# ----------
# string : str
# string to be parsed
#
# Returns
# -------
# dict :
# dictionary after parsing the string
# """
# try:
# return cls.parser().parseString(string, parseAll=True)[0]
# except pp.ParseException:
# raise cls.ParseException()
#
# Path: css2video/parsers/value.py
# class Value(object):
# """Parse any CSS property value"""
#
# @classmethod
# def parser(cls):
# """Grammar to parse any CSS Property value"""
# return (
# Number.parser() ^
# Length.parser() ^
# Percentage.parser() ^
# Time.parser() ^
# Color.parser() ^
# Text.parser() ^
# Url.parser() ^
# Function.parser() ^
# Array.parser()
# )
, which may contain function names, class names, or code. Output only the next line. | value = Value.parser() |
Given snippet: <|code_start|>
class NumberParseException(Exception):
"""Raised when there is an exception while parsing a number"""
pass
class Number(BaseParser):
"""Parser to parse a number"""
ParseException = NumberParseException
@classmethod
def grammar(cls):
"""Returns the grammar to parse a number that may have a sign and a
decimal point"""
sign = pp.Word('+-', exact=1)
digits = pp.Word(pp.nums)
decimal = pp.Combine(pp.Word('.', exact=1) + digits)
return pp.Combine(pp.Optional(sign) + digits + pp.Optional(decimal))
@classmethod
def parse_action(cls, tokens):
"""Returns a dictionary from the parsed tokens"""
return {
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pyparsing as pp
from css2video.constants import ValueType
from .base import BaseParser
and context:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/base.py
# class BaseParser(object):
# """
# A base class for all the parsers
#
# Attributes
# ----------
# ParseException : object
# exception to be raised when there is a parsing error
#
# Methods
# -------
# grammar :
# method to be overrridden by inheriting class which defines the grammar
# parse_action :
# method to be overrridden by inheriting class which defines the parse
# action for the matched token
# parser :
# returns a parser by setting the parse action to the grammar
# parse :
# method to parse a string into a dictionary using the grammar and parse
# action
# """
#
# ParseException = None
#
# @classmethod
# def grammar(cls):
# """This method is overridden by the class which inherits the
# BaseParser. The method should return a grammar"""
# raise NotImplemented()
#
# @classmethod
# def parse_action(cls):
# """This method is overridden by the class which inherits the
# BaseParser. The method should create a dictionary from the parsed
# tokens"""
# raise NotImplemented()
#
# @classmethod
# def parser(cls):
# """Returns the grammar with parse action set so that once the result is
# parsed, the output is available as a dictionary"""
# return cls.grammar().setParseAction(cls.parse_action)
#
# @classmethod
# def parse(cls, string):
# """
# Parse a given string using the grammar and parse action and returns
# a dictionary
#
# Parameters
# ----------
# string : str
# string to be parsed
#
# Returns
# -------
# dict :
# dictionary after parsing the string
# """
# try:
# return cls.parser().parseString(string, parseAll=True)[0]
# except pp.ParseException:
# raise cls.ParseException()
which might include code, classes, or functions. Output only the next line. | 'type': ValueType.number, |
Based on the snippet: <|code_start|> 'type': 'array',
'values': [
{
'type': 'length',
'value': 0,
'unit': 'px'
},
{
'type': 'length',
'value': 0,
'unit': 'px'
},
{
'type': 'length',
'value': 4,
'unit': 'px'
},
{
'type': 'color',
'red': 0,
'green': 0,
'blue': 0,
'alpha': 1
}
]
}
}
)
]
for expected_property_string, property_dict in property_data:
<|code_end|>
, predict the immediate next line with the help of imports:
import unittest
from css2video.outputters import output_property
from css2video.outputters import output_rule
from css2video.outputters import output_stylesheet
from css2video.outputters import output_value
and context (classes, functions, sometimes code) from other files:
# Path: css2video/outputters/property.py
# def output_property(property_dict):
# '''Returns the property as a string'''
# value = output_value(property_dict['property_value'])
# return '{name}: {value};'.format(
# name=property_dict['property_name'], value=value)
#
# Path: css2video/outputters/rule.py
# def output_rule(rule_dict):
# '''Returns the rule as a string'''
# type = rule_dict.get('type')
#
# if type is None:
# raise MissingRuleType()
# if type == 'style':
# properties = '\n\t'.join(
# [output_property(p) for p in rule_dict.get('properties', [])])
# return (
# '%s {\n'
# '\t%s\n'
# '}'
# ) % (rule_dict['selector'], properties)
# if type == 'keyframes':
# keyframe_properties = '\n'.join([
# _output_keyframe_properties(p)
# for p in rule_dict.get('keyframes', [])
# ])
# return (
# '@keyframes %s {\n'
# '%s\n'
# '}'
# ) % (rule_dict['name'], keyframe_properties)
#
# Path: css2video/outputters/stylesheet.py
# def output_stylesheet(stylesheet_dict):
# '''Returns the stylesheet as a string'''
# return '\n'.join(
# [output_rule(rule) for rule in stylesheet_dict.get('rules', []) if rule['type'] == 'style'])
#
# Path: css2video/outputters/value.py
# def output_value(value_dict):
# '''Return the value as a string'''
# type = value_dict.get('type')
#
# if type is None:
# raise MissingValueType()
# if type == 'number':
# return '{value}'.format(**value_dict)
# if type == 'length':
# return '{value}{unit}'.format(**value_dict)
# if type == 'percentage':
# return '{value}%'.format(**value_dict)
# if type == 'time':
# return '{value}s'.format(**value_dict)
# if type == 'color':
# return 'rgba({red}, {green}, {blue}, {alpha})'.format(**value_dict)
# if type == 'text':
# return '{value}'.format(**value_dict)
# if type == 'url':
# return '{value}'.format(**value_dict)
# if type == 'function':
# args = ' '.join([output_value(arg) for arg in value_dict['args']])
# return '{name}({args})'.format(name=value_dict['name'], args=args)
# if type == 'array':
# args = ' '.join([output_value(arg) for arg in value_dict['values']])
# return '{args}'.format(args=args)
. Output only the next line. | property_string = output_property(property_dict) |
Next line prediction: <|code_start|> 'properties': [
{
'property_name': 'top',
'property_value': {
'type': 'length',
'value': 0,
'unit': 'px'
}
}
]
},
{
'keyframe_selector': 100,
'properties': [
{
'property_name': 'top',
'property_value': {
'type': 'length',
'value': 200,
'unit': 'px'
}
}
]
}
]
}
)
]
for expected_rule_string, rule_dict in rule_data:
<|code_end|>
. Use current file imports:
(import unittest
from css2video.outputters import output_property
from css2video.outputters import output_rule
from css2video.outputters import output_stylesheet
from css2video.outputters import output_value)
and context including class names, function names, or small code snippets from other files:
# Path: css2video/outputters/property.py
# def output_property(property_dict):
# '''Returns the property as a string'''
# value = output_value(property_dict['property_value'])
# return '{name}: {value};'.format(
# name=property_dict['property_name'], value=value)
#
# Path: css2video/outputters/rule.py
# def output_rule(rule_dict):
# '''Returns the rule as a string'''
# type = rule_dict.get('type')
#
# if type is None:
# raise MissingRuleType()
# if type == 'style':
# properties = '\n\t'.join(
# [output_property(p) for p in rule_dict.get('properties', [])])
# return (
# '%s {\n'
# '\t%s\n'
# '}'
# ) % (rule_dict['selector'], properties)
# if type == 'keyframes':
# keyframe_properties = '\n'.join([
# _output_keyframe_properties(p)
# for p in rule_dict.get('keyframes', [])
# ])
# return (
# '@keyframes %s {\n'
# '%s\n'
# '}'
# ) % (rule_dict['name'], keyframe_properties)
#
# Path: css2video/outputters/stylesheet.py
# def output_stylesheet(stylesheet_dict):
# '''Returns the stylesheet as a string'''
# return '\n'.join(
# [output_rule(rule) for rule in stylesheet_dict.get('rules', []) if rule['type'] == 'style'])
#
# Path: css2video/outputters/value.py
# def output_value(value_dict):
# '''Return the value as a string'''
# type = value_dict.get('type')
#
# if type is None:
# raise MissingValueType()
# if type == 'number':
# return '{value}'.format(**value_dict)
# if type == 'length':
# return '{value}{unit}'.format(**value_dict)
# if type == 'percentage':
# return '{value}%'.format(**value_dict)
# if type == 'time':
# return '{value}s'.format(**value_dict)
# if type == 'color':
# return 'rgba({red}, {green}, {blue}, {alpha})'.format(**value_dict)
# if type == 'text':
# return '{value}'.format(**value_dict)
# if type == 'url':
# return '{value}'.format(**value_dict)
# if type == 'function':
# args = ' '.join([output_value(arg) for arg in value_dict['args']])
# return '{name}({args})'.format(name=value_dict['name'], args=args)
# if type == 'array':
# args = ' '.join([output_value(arg) for arg in value_dict['values']])
# return '{args}'.format(args=args)
. Output only the next line. | rule_string = output_rule(rule_dict) |
Predict the next line after this snippet: <|code_start|> 'property_name': 'top',
'property_value': {
'type': 'length',
'value': 0,
'unit': 'px'
}
}
]
},
{
'keyframe_selector': 100,
'properties': [
{
'property_name': 'top',
'property_value': {
'type': 'length',
'value': 200,
'unit': 'px'
}
}
]
}
]
}
]
}
)
]
for expected_string, stylesheet_dict in stylesheet_data:
<|code_end|>
using the current file's imports:
import unittest
from css2video.outputters import output_property
from css2video.outputters import output_rule
from css2video.outputters import output_stylesheet
from css2video.outputters import output_value
and any relevant context from other files:
# Path: css2video/outputters/property.py
# def output_property(property_dict):
# '''Returns the property as a string'''
# value = output_value(property_dict['property_value'])
# return '{name}: {value};'.format(
# name=property_dict['property_name'], value=value)
#
# Path: css2video/outputters/rule.py
# def output_rule(rule_dict):
# '''Returns the rule as a string'''
# type = rule_dict.get('type')
#
# if type is None:
# raise MissingRuleType()
# if type == 'style':
# properties = '\n\t'.join(
# [output_property(p) for p in rule_dict.get('properties', [])])
# return (
# '%s {\n'
# '\t%s\n'
# '}'
# ) % (rule_dict['selector'], properties)
# if type == 'keyframes':
# keyframe_properties = '\n'.join([
# _output_keyframe_properties(p)
# for p in rule_dict.get('keyframes', [])
# ])
# return (
# '@keyframes %s {\n'
# '%s\n'
# '}'
# ) % (rule_dict['name'], keyframe_properties)
#
# Path: css2video/outputters/stylesheet.py
# def output_stylesheet(stylesheet_dict):
# '''Returns the stylesheet as a string'''
# return '\n'.join(
# [output_rule(rule) for rule in stylesheet_dict.get('rules', []) if rule['type'] == 'style'])
#
# Path: css2video/outputters/value.py
# def output_value(value_dict):
# '''Return the value as a string'''
# type = value_dict.get('type')
#
# if type is None:
# raise MissingValueType()
# if type == 'number':
# return '{value}'.format(**value_dict)
# if type == 'length':
# return '{value}{unit}'.format(**value_dict)
# if type == 'percentage':
# return '{value}%'.format(**value_dict)
# if type == 'time':
# return '{value}s'.format(**value_dict)
# if type == 'color':
# return 'rgba({red}, {green}, {blue}, {alpha})'.format(**value_dict)
# if type == 'text':
# return '{value}'.format(**value_dict)
# if type == 'url':
# return '{value}'.format(**value_dict)
# if type == 'function':
# args = ' '.join([output_value(arg) for arg in value_dict['args']])
# return '{name}({args})'.format(name=value_dict['name'], args=args)
# if type == 'array':
# args = ' '.join([output_value(arg) for arg in value_dict['values']])
# return '{args}'.format(args=args)
. Output only the next line. | string = output_stylesheet(stylesheet_dict) |
Given snippet: <|code_start|> },
{
'type': 'time',
'value': 2
},
]
},
'20px rgba(255, 255, 255, 1)': {
'type': 'array',
'values': [
{
'type': 'length',
'value': 20,
'unit': 'px'
},
{
'type': 'color',
'red': 255,
'green': 255,
'blue': 255,
'alpha': 1
}
]
},
'"http://www.google.com"': {
'type': 'url',
'value': '"http://www.google.com"'
}
}
for expected_value_string, value_dict in value_data.items():
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import unittest
from css2video.outputters import output_property
from css2video.outputters import output_rule
from css2video.outputters import output_stylesheet
from css2video.outputters import output_value
and context:
# Path: css2video/outputters/property.py
# def output_property(property_dict):
# '''Returns the property as a string'''
# value = output_value(property_dict['property_value'])
# return '{name}: {value};'.format(
# name=property_dict['property_name'], value=value)
#
# Path: css2video/outputters/rule.py
# def output_rule(rule_dict):
# '''Returns the rule as a string'''
# type = rule_dict.get('type')
#
# if type is None:
# raise MissingRuleType()
# if type == 'style':
# properties = '\n\t'.join(
# [output_property(p) for p in rule_dict.get('properties', [])])
# return (
# '%s {\n'
# '\t%s\n'
# '}'
# ) % (rule_dict['selector'], properties)
# if type == 'keyframes':
# keyframe_properties = '\n'.join([
# _output_keyframe_properties(p)
# for p in rule_dict.get('keyframes', [])
# ])
# return (
# '@keyframes %s {\n'
# '%s\n'
# '}'
# ) % (rule_dict['name'], keyframe_properties)
#
# Path: css2video/outputters/stylesheet.py
# def output_stylesheet(stylesheet_dict):
# '''Returns the stylesheet as a string'''
# return '\n'.join(
# [output_rule(rule) for rule in stylesheet_dict.get('rules', []) if rule['type'] == 'style'])
#
# Path: css2video/outputters/value.py
# def output_value(value_dict):
# '''Return the value as a string'''
# type = value_dict.get('type')
#
# if type is None:
# raise MissingValueType()
# if type == 'number':
# return '{value}'.format(**value_dict)
# if type == 'length':
# return '{value}{unit}'.format(**value_dict)
# if type == 'percentage':
# return '{value}%'.format(**value_dict)
# if type == 'time':
# return '{value}s'.format(**value_dict)
# if type == 'color':
# return 'rgba({red}, {green}, {blue}, {alpha})'.format(**value_dict)
# if type == 'text':
# return '{value}'.format(**value_dict)
# if type == 'url':
# return '{value}'.format(**value_dict)
# if type == 'function':
# args = ' '.join([output_value(arg) for arg in value_dict['args']])
# return '{name}({args})'.format(name=value_dict['name'], args=args)
# if type == 'array':
# args = ' '.join([output_value(arg) for arg in value_dict['values']])
# return '{args}'.format(args=args)
which might include code, classes, or functions. Output only the next line. | value_string = output_value(value_dict) |
Based on the snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Property.parse('margin: 20px;')
self.assertEqual(response['property_name'], 'margin')
self.assertEqual(response['property_value'], dict(
<|code_end|>
, predict the immediate next line with the help of imports:
import unittest
from css2video.constants import ValueType
from css2video.parsers.property import Property, PropertyParseException
and context (classes, functions, sometimes code) from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/property.py
# class Property(BaseParser):
# """Parse a CSS property"""
#
# ParseException = PropertyParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a CSS property"""
# name = pp.Word(pp.alphas + '-')
# value = Value.parser()
# return (
# name +
# pp.Suppress(pp.Literal(':')) +
# value +
# pp.Suppress(pp.Literal(";"))
# )
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'property_name': tokens[0].lower(), # Normalize the name
# 'property_value': tokens[1]
# }
#
# class PropertyParseException(Exception):
# """Raised when there is an exception while parsing a property"""
# pass
. Output only the next line. | type=ValueType.length, value=20., unit='px' |
Given the code snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Property.parse('margin: 20px;')
self.assertEqual(response['property_name'], 'margin')
self.assertEqual(response['property_value'], dict(
type=ValueType.length, value=20., unit='px'
))
response = Property.parse(' background-color : #FFF ;')
self.assertEqual(response['property_name'], 'background-color')
self.assertEqual(response['property_value'], dict(
type=ValueType.color, red=255, green=255, blue=255, alpha=1
))
<|code_end|>
, generate the next line using the imports in this file:
import unittest
from css2video.constants import ValueType
from css2video.parsers.property import Property, PropertyParseException
and context (functions, classes, or occasionally code) from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/property.py
# class Property(BaseParser):
# """Parse a CSS property"""
#
# ParseException = PropertyParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a CSS property"""
# name = pp.Word(pp.alphas + '-')
# value = Value.parser()
# return (
# name +
# pp.Suppress(pp.Literal(':')) +
# value +
# pp.Suppress(pp.Literal(";"))
# )
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'property_name': tokens[0].lower(), # Normalize the name
# 'property_value': tokens[1]
# }
#
# class PropertyParseException(Exception):
# """Raised when there is an exception while parsing a property"""
# pass
. Output only the next line. | with self.assertRaises(PropertyParseException): |
Next line prediction: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Time.parse('20s')
self.assertEqual(
<|code_end|>
. Use current file imports:
(import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Time, TimeParseException)
and context including class names, function names, or small code snippets from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Time(BaseParser):
# """Parse a time value which is in seconds"""
#
# ParseException = TimeParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a time value"""
# number = Number.grammar()
# seconds = pp.CaselessLiteral('s').leaveWhitespace()
# return number + seconds
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.time,
# 'value': float(tokens[0])
# }
#
# class TimeParseException(Exception):
# """Raised when there is an execption while parsing a time value"""
# pass
. Output only the next line. | response, dict(type=ValueType.time, value=20.) |
Using the snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Time.parse('20s')
self.assertEqual(
response, dict(type=ValueType.time, value=20.)
)
response = Time.parse('-40.5S')
self.assertEqual(
response, dict(type=ValueType.time, value=-40.5)
)
<|code_end|>
, determine the next line of code. You have imports:
import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Time, TimeParseException
and context (class names, function names, or code) available:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Time(BaseParser):
# """Parse a time value which is in seconds"""
#
# ParseException = TimeParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a time value"""
# number = Number.grammar()
# seconds = pp.CaselessLiteral('s').leaveWhitespace()
# return number + seconds
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.time,
# 'value': float(tokens[0])
# }
#
# class TimeParseException(Exception):
# """Raised when there is an execption while parsing a time value"""
# pass
. Output only the next line. | with self.assertRaises(TimeParseException): |
Given the code snippet: <|code_start|>
class MissingRuleType(Exception):
'''Exception raised when the type of rule is not specified'''
pass
def _output_keyframe_properties(keyframe_dict):
'''Returns the keyframe properties'''
properties = '\n\t'.join(
<|code_end|>
, generate the next line using the imports in this file:
from .property import output_property
and context (functions, classes, or occasionally code) from other files:
# Path: css2video/outputters/property.py
# def output_property(property_dict):
# '''Returns the property as a string'''
# value = output_value(property_dict['property_value'])
# return '{name}: {value};'.format(
# name=property_dict['property_name'], value=value)
. Output only the next line. | [output_property(p) for p in keyframe_dict.get('properties', [])]) |
Given the code snippet: <|code_start|>"""
Use this example file to render your own HTML CSS to MPEG video.
"""
directory = os.path.dirname(__file__)
html_path = os.path.join(directory, 'test.html')
css_path = os.path.join(directory, 'test.css')
output_path = os.path.join(directory, 'test.mp4')
<|code_end|>
, generate the next line using the imports in this file:
import os
from css2video.renderers import render_animation
and context (functions, classes, or occasionally code) from other files:
# Path: css2video/renderers/render.py
# def render_animation(
# html_path, css_path, output_path, duration, framerate=30, width=800,
# height=600, image_renderer='CUTYCAPT', video_renderer='FFMPEG'):
#
# with open(css_path, 'r') as fd:
# css = fd.read()
#
# html_path = os.path.abspath(html_path)
# output_path = os.path.abspath(output_path)
#
# stylesheet_dict = StyleSheet.parse(css)
# total_frames = framerate * duration
# duration_per_frame = float(duration) / total_frames
#
# temp_dir = tempfile.mkdtemp()
#
# for frame in tqdm(range(total_frames)):
# time = frame * duration_per_frame
# filename = _get_frame_image_name(
# frame=frame, total_frames=total_frames)
#
# temp_stylesheet_dict = interpolate_stylesheet(
# stylesheet_dict=stylesheet_dict, time=time)
# temp_css = output_stylesheet(stylesheet_dict=temp_stylesheet_dict)
# temp_css_path = os.path.join(temp_dir, 'temp.css')
# with open(temp_css_path, 'w') as fd:
# fd.write(temp_css)
#
# temp_output_path = os.path.join(temp_dir, filename)
#
# render_image(
# html_path=html_path, css_path=temp_css_path,
# output_path=temp_output_path, width=width, height=height,
# renderer=image_renderer
# )
#
# input_image_sequence = os.path.join(
# temp_dir, _get_image_sequence(total_frames=total_frames))
# render_video(
# image_sequence=input_image_sequence, output_path=output_path,
# framerate=framerate, renderer=video_renderer
# )
# shutil.rmtree(temp_dir)
. Output only the next line. | render_animation( |
Predict the next line for this snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Function.parse('url("background.png")')
self.assertEqual(
response,
<|code_end|>
with the help of current file imports:
import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Function, FunctionParseException
and context from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Function(BaseParser):
# """Parse a function value with optional arguments passed"""
#
# ParseException = FunctionParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a function value"""
# name = pp.Word(pp.alphas)
# args = cls.args_parser()
#
# return (
# name +
# pp.Suppress(pp.Literal('(')) +
# args +
# pp.Suppress(pp.Literal(')'))
# )
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.function,
# 'name': tokens[0],
# 'args': tokens[1:]
# }
#
# @classmethod
# def args_parser(cls):
# """Returns the arguments of the function which can be a Number, Length,
# Percentage, Time, Color, Text or URL"""
# arg_types = [Number, Length, Percentage, Time, Color, Text, Url]
# arg_parser = arg_types[0].parser()
# for arg_type in arg_types[1:]:
# arg_parser ^= arg_type.parser()
# return pp.OneOrMore(arg_parser)
#
# class FunctionParseException(Exception):
# """Raised when there is an while parsing a function value"""
# pass
, which may contain function names, class names, or code. Output only the next line. | dict(type=ValueType.function, name='url', args=[ |
Here is a snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Function.parse('url("background.png")')
self.assertEqual(
response,
dict(type=ValueType.function, name='url', args=[
dict(type=ValueType.url, value='"background.png"')
])
)
response = Function.parse('translate(0 20px)')
self.assertEqual(
response,
dict(type=ValueType.function, name='translate', args=[
dict(type=ValueType.number, value=0.),
dict(type=ValueType.length, value=20., unit='px')
])
)
<|code_end|>
. Write the next line using the current file imports:
import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Function, FunctionParseException
and context from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Function(BaseParser):
# """Parse a function value with optional arguments passed"""
#
# ParseException = FunctionParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse a function value"""
# name = pp.Word(pp.alphas)
# args = cls.args_parser()
#
# return (
# name +
# pp.Suppress(pp.Literal('(')) +
# args +
# pp.Suppress(pp.Literal(')'))
# )
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.function,
# 'name': tokens[0],
# 'args': tokens[1:]
# }
#
# @classmethod
# def args_parser(cls):
# """Returns the arguments of the function which can be a Number, Length,
# Percentage, Time, Color, Text or URL"""
# arg_types = [Number, Length, Percentage, Time, Color, Text, Url]
# arg_parser = arg_types[0].parser()
# for arg_type in arg_types[1:]:
# arg_parser ^= arg_type.parser()
# return pp.OneOrMore(arg_parser)
#
# class FunctionParseException(Exception):
# """Raised when there is an while parsing a function value"""
# pass
, which may include functions, classes, or code. Output only the next line. | with self.assertRaises(FunctionParseException): |
Given the code snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Percentage.parse('20%')
self.assertEqual(
<|code_end|>
, generate the next line using the imports in this file:
import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Percentage, PercentageParseException
and context (functions, classes, or occasionally code) from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Percentage(BaseParser):
# """Parse a percentage value"""
#
# ParseException = PercentageParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse the percentage value"""
# number = Number.grammar()
# percentage = pp.Literal('%').leaveWhitespace()
# return number + percentage
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.percentage,
# 'value': float(tokens[0]),
# }
#
# class PercentageParseException(Exception):
# """Raised when there is an exception while parsing a percentage value"""
# pass
. Output only the next line. | response, dict(type=ValueType.percentage, value=20.) |
Based on the snippet: <|code_start|>
class TestCase(unittest.TestCase):
def test_parser(self):
response = Percentage.parse('20%')
self.assertEqual(
response, dict(type=ValueType.percentage, value=20.)
)
response = Percentage.parse('-40.5%')
self.assertEqual(
response, dict(type=ValueType.percentage, value=-40.5)
)
<|code_end|>
, predict the immediate next line with the help of imports:
import unittest
from css2video.constants import ValueType
from css2video.parsers.value import Percentage, PercentageParseException
and context (classes, functions, sometimes code) from other files:
# Path: css2video/constants.py
# class ValueType(object):
# """Class to define constants for value types"""
#
# number = 'number'
# length = 'length'
# percentage = 'percentage'
# time = 'time'
# color = 'color'
# text = 'text'
# url = 'url'
# function = 'function'
# array = 'array'
#
# Path: css2video/parsers/value.py
# class Percentage(BaseParser):
# """Parse a percentage value"""
#
# ParseException = PercentageParseException
#
# @classmethod
# def grammar(cls):
# """Grammar to parse the percentage value"""
# number = Number.grammar()
# percentage = pp.Literal('%').leaveWhitespace()
# return number + percentage
#
# @classmethod
# def parse_action(cls, tokens):
# """Returns a dictionary from the parsed tokens"""
# return {
# 'type': ValueType.percentage,
# 'value': float(tokens[0]),
# }
#
# class PercentageParseException(Exception):
# """Raised when there is an exception while parsing a percentage value"""
# pass
. Output only the next line. | with self.assertRaises(PercentageParseException): |
Predict the next line for this snippet: <|code_start|>
def render_image(
html_path, css_path, output_path, width=800, height=600,
renderer='CUTYCAPT'):
"""Render HTML CSS as an image"""
if renderer == 'CUTYCAPT':
<|code_end|>
with the help of current file imports:
from .cutycapt import CutyCaptRenderer
and context from other files:
# Path: css2video/renderers/image/cutycapt.py
# class CutyCaptRenderer(BaseImageRenderer):
# """Renderer which uses to CutyCapt to convert HTML, CSS to image"""
#
# def __init__(self, *args, **kwargs):
# super(CutyCaptRenderer, self).__init__(*args, **kwargs)
#
# def render(self):
# """Render the HTML and CSS as an image"""
# command_args = {
# 'url': 'file:%s' % self.html_path,
# 'user-style-path': self.css_path,
# 'out': self.output_path,
# 'min-width': int(self.width),
# 'min-height': int(self.height)
# }
# args = ' '.join(
# ['--%s=%s' % (key, value) for key, value in command_args.items()])
# xvfb_command = (
# 'xvfb-run --server-args="-screen 0, {width}x{height}x24"'.format(
# width=self.width, height=self.height
# )
# )
# command = '{xvfb} cutycapt {args}'.format(args=args, xvfb=xvfb_command)
#
# process = subprocess.Popen(
# shlex.split(command),
# stdout=subprocess.PIPE,
# stderr=subprocess.PIPE
# )
# okay, errors = process.communicate()
# # If we run without sleeping, it skips a few frames
# time.sleep(1)
, which may contain function names, class names, or code. Output only the next line. | renderer = CutyCaptRenderer( |
Continue the code snippet: <|code_start|>
class ChangePasswordForm(forms.Form):
oldpassword = forms.CharField()
newpassword = forms.CharField()
retypepassword = forms.CharField()
class UserForm(forms.ModelForm):
class Meta:
<|code_end|>
. Use current file imports:
from django import forms
from micro_admin.models import User, career
and context (classes, functions, or code) from other files:
# Path: micro_admin/models.py
# class User(AbstractBaseUser, PermissionsMixin):
# username = models.CharField(max_length=30, unique=True)
# email = models.EmailField(verbose_name='email address', max_length=255, unique=True, db_index=True,)
# user_roles = models.CharField(choices=USER_ROLES, max_length=10)
# is_employee = models.BooleanField(default=False)
# date_of_birth = models.DateField(default='1970-01-01')
# is_active = models.BooleanField(default=True)
# is_admin = models.BooleanField(default=False)
# is_staff = models.BooleanField(_('staff status'), default=False)
# date_joined = models.DateTimeField(default=timezone.now)
# is_special = models.BooleanField(default=False)
# first_name = models.CharField(max_length=100, default='')
# last_name = models.CharField(max_length=100, default='')
# gender = models.CharField(choices=GENDER_TYPES, max_length=10)
# fb_profile = models.URLField(default='')
# tw_profile = models.URLField(default='')
# ln_profile = models.URLField(default='')
# google_plus_url = models.URLField(default='')
# about = models.CharField(max_length=2000, default='', null=True, blank=True)
# state = models.CharField(max_length=50)
# city = models.CharField(max_length=50)
# area = models.CharField(max_length=150)
# address = models.TextField(max_length=1000, default='')
# mobile = models.BigIntegerField(default='0')
# website = models.URLField(default='', null=True)
# phones = models.TextField(max_length=100, default='', null=True)
# pincode = models.TextField(max_length=50, default='', null=True)
# min_published_blogs = models.IntegerField(default=0)
# max_published_blogs = models.IntegerField(default=0)
#
# objects = UserManager()
#
# USERNAME_FIELD = 'email'
# REQUIRED_FIELDS = ['username']
#
# def get_full_name(self):
# # The user is identified by their email address
# return self.first_name + ' ' + self.last_name
#
# def get_short_name(self):
# # The user is identified by their email address
# return self.first_name
#
# def __unicode__(self):
# return self.first_name + ' (' + self.email + ')'
#
# def total_posts(self):
# return Post.objects.filter(user=self).count()
#
# def drafted_posts(self):
# return Post.objects.filter(user=self, status="D").count()
#
# def is_site_admin(self):
# if self.user_roles == "Admin" or self.is_superuser:
# return True
# return False
#
# class Meta:
# permissions = (
# ("blog_moderator", "Can enable or disable blog posts"),
# ("blogger", "Can write blog posts"),
# )
#
# def get_week_posts(self, value):
# if value:
# value = value.split('-')
# previous_date = datetime.strptime(value[0].strip(), "%Y/%m/%d").strftime("%Y-%m-%d")
# current_date = datetime.strptime(value[1].strip(), "%Y/%m/%d").strftime("%Y-%m-%d")
# else:
# current_date = datetime.strptime(str(datetime.now().date()), "%Y-%m-%d").strftime("%Y-%m-%d")
# previous_date = datetime.strptime(str(datetime.now().date() - timedelta(days=7)), "%Y-%m-%d").strftime("%Y-%m-%d")
# post = Post.objects.filter(user=self, created_on__range=(previous_date, current_date))
# return post.filter(status='P').count(), post.filter(status='D').count(), post.filter(status='R').count(), post.filter(status='T').count()
#
# class career(models.Model):
# title = models.CharField(max_length=100)
# slug = models.SlugField()
# experience = models.CharField(max_length=100)
# skills = models.CharField(max_length=100)
# description = models.TextField()
# featured_image = models.CharField(max_length=100, blank=True, null=True)
# num_of_opening = models.IntegerField(default=True)
# posted_on = models.DateField(auto_now=True)
# created_on = models.DateTimeField(auto_now_add=True)
# is_active = models.BooleanField(default=True)
# url = models.URLField(default='')
#
# def save(self, *args, **kwargs):
# self.slug = slugify(self.title)
# super(career, self).save(*args, **kwargs)
#
# def __unicode__(self):
# return self.title
. Output only the next line. | model = User |
Based on the snippet: <|code_start|>
class ChangePasswordForm(forms.Form):
oldpassword = forms.CharField()
newpassword = forms.CharField()
retypepassword = forms.CharField()
class UserForm(forms.ModelForm):
class Meta:
model = User
exclude = [
'username',
'date_joined',
'gender',
'website',
'last_login',
'area',
'fb_profile',
'tw_profile',
'ln_profile',
'google_plus_url',
"max_published_blogs",
"min_published_blogs",
]
class CareerForm(forms.ModelForm):
class Meta:
<|code_end|>
, predict the immediate next line with the help of imports:
from django import forms
from micro_admin.models import User, career
and context (classes, functions, sometimes code) from other files:
# Path: micro_admin/models.py
# class User(AbstractBaseUser, PermissionsMixin):
# username = models.CharField(max_length=30, unique=True)
# email = models.EmailField(verbose_name='email address', max_length=255, unique=True, db_index=True,)
# user_roles = models.CharField(choices=USER_ROLES, max_length=10)
# is_employee = models.BooleanField(default=False)
# date_of_birth = models.DateField(default='1970-01-01')
# is_active = models.BooleanField(default=True)
# is_admin = models.BooleanField(default=False)
# is_staff = models.BooleanField(_('staff status'), default=False)
# date_joined = models.DateTimeField(default=timezone.now)
# is_special = models.BooleanField(default=False)
# first_name = models.CharField(max_length=100, default='')
# last_name = models.CharField(max_length=100, default='')
# gender = models.CharField(choices=GENDER_TYPES, max_length=10)
# fb_profile = models.URLField(default='')
# tw_profile = models.URLField(default='')
# ln_profile = models.URLField(default='')
# google_plus_url = models.URLField(default='')
# about = models.CharField(max_length=2000, default='', null=True, blank=True)
# state = models.CharField(max_length=50)
# city = models.CharField(max_length=50)
# area = models.CharField(max_length=150)
# address = models.TextField(max_length=1000, default='')
# mobile = models.BigIntegerField(default='0')
# website = models.URLField(default='', null=True)
# phones = models.TextField(max_length=100, default='', null=True)
# pincode = models.TextField(max_length=50, default='', null=True)
# min_published_blogs = models.IntegerField(default=0)
# max_published_blogs = models.IntegerField(default=0)
#
# objects = UserManager()
#
# USERNAME_FIELD = 'email'
# REQUIRED_FIELDS = ['username']
#
# def get_full_name(self):
# # The user is identified by their email address
# return self.first_name + ' ' + self.last_name
#
# def get_short_name(self):
# # The user is identified by their email address
# return self.first_name
#
# def __unicode__(self):
# return self.first_name + ' (' + self.email + ')'
#
# def total_posts(self):
# return Post.objects.filter(user=self).count()
#
# def drafted_posts(self):
# return Post.objects.filter(user=self, status="D").count()
#
# def is_site_admin(self):
# if self.user_roles == "Admin" or self.is_superuser:
# return True
# return False
#
# class Meta:
# permissions = (
# ("blog_moderator", "Can enable or disable blog posts"),
# ("blogger", "Can write blog posts"),
# )
#
# def get_week_posts(self, value):
# if value:
# value = value.split('-')
# previous_date = datetime.strptime(value[0].strip(), "%Y/%m/%d").strftime("%Y-%m-%d")
# current_date = datetime.strptime(value[1].strip(), "%Y/%m/%d").strftime("%Y-%m-%d")
# else:
# current_date = datetime.strptime(str(datetime.now().date()), "%Y-%m-%d").strftime("%Y-%m-%d")
# previous_date = datetime.strptime(str(datetime.now().date() - timedelta(days=7)), "%Y-%m-%d").strftime("%Y-%m-%d")
# post = Post.objects.filter(user=self, created_on__range=(previous_date, current_date))
# return post.filter(status='P').count(), post.filter(status='D').count(), post.filter(status='R').count(), post.filter(status='T').count()
#
# class career(models.Model):
# title = models.CharField(max_length=100)
# slug = models.SlugField()
# experience = models.CharField(max_length=100)
# skills = models.CharField(max_length=100)
# description = models.TextField()
# featured_image = models.CharField(max_length=100, blank=True, null=True)
# num_of_opening = models.IntegerField(default=True)
# posted_on = models.DateField(auto_now=True)
# created_on = models.DateTimeField(auto_now_add=True)
# is_active = models.BooleanField(default=True)
# url = models.URLField(default='')
#
# def save(self, *args, **kwargs):
# self.slug = slugify(self.title)
# super(career, self).save(*args, **kwargs)
#
# def __unicode__(self):
# return self.title
. Output only the next line. | model = career |
Predict the next line after this snippet: <|code_start|>
register = template.Library()
@register.assignment_tag(takes_context=True)
def get_archives(context):
archives = []
dates = []
<|code_end|>
using the current file's imports:
from django import template
from micro_blog.models import Post, Country
from django.core.urlresolvers import reverse
from django.conf import settings
import datetime
import re
import datetime
and any relevant context from other files:
# Path: micro_blog/models.py
# class Post(models.Model):
# STATUS_CHOICE = (
# ('D', 'Draft'),
# ('P', 'Published'),
# ('T', 'Rejected'),
# ('R', 'Review'),
# )
#
# title = models.CharField(max_length=100)
# created_on = models.DateTimeField(auto_now_add=True)
# updated_on = models.DateField(auto_now=True)
# user = models.ForeignKey(settings.AUTH_USER_MODEL)
# content = models.TextField()
# excerpt = models.CharField(max_length=500, default="")
# category = models.ForeignKey(Category, related_name='blog_posts')
# tags = models.ManyToManyField(Tags, related_name='rel_posts', blank=True)
# status = models.CharField(max_length=2, choices=STATUS_CHOICE, blank=True)
# published_on = models.DateField(blank=True, null=True)
# meta_description = models.TextField(max_length=500, default='')
# old_slugs = models.TextField()
#
# def __unicode__(self):
# return self.title
#
# def create_blog_slug(self, slugs):
# for each_slug in list(set(slugs)):
# blog_slugs = self.slugs.filter(slug=each_slug)
# if not blog_slugs:
# actual_slug = get_blog_slug(each_slug)
# Post_Slugs.objects.create(
# blog=self, slug=actual_slug, is_active=False
# )
#
# def check_and_activate_slug(self):
# # Check whether active slug is their for blog-post or not
# blog_slugs = self.slugs.all().order_by("id")
# if not blog_slugs.filter(is_active=True):
# active_slug = blog_slugs.last()
# active_slug.is_active = True
# active_slug.save()
#
# @property
# def slug(self):
# blog_slug = self.slugs.filter(is_active=True).first()
# if blog_slug:
# return str(blog_slug.slug)
# return ""
#
# @property
# def author(self):
# return self.user.first_name + ' ' + self.user.last_name
#
# def save(self, *args, **kwargs):
# if self.status == 'P':
# if not self.published_on:
# self.published_on = datetime.datetime.today()
# super(Post, self).save(*args, **kwargs)
#
# @property
# def get_url(self):
# return settings.SITE_BLOG_URL + self.slug
#
# def is_editable_by(self, user):
# if self.user == user or user.is_superuser:
# return True
# return False
#
# def is_deletable_by(self, user):
# if self.user == user or user.is_superuser:
# return True
# return False
#
# def get_content(self):
# table = html.fromstring(self.content)
# content = ''
# for item in table:
# if item.text:
# content += item.text.strip()
# return content[:350]
#
# class Country(models.Model):
# name = models.CharField(max_length=50, unique=True)
# code = models.CharField(max_length=50)
# slug = models.CharField(max_length=50, unique=True)
#
# def __str__(self):
# return self.name
. Output only the next line. | for each_object in Post.objects.filter(status='P').order_by( |
Predict the next line for this snippet: <|code_start|> return post.is_editable_by(user)
@register.filter
def is_deletable_by(post, user):
return post.is_deletable_by(user)
@register.filter
def get_class_name(value):
return value.__class__.__name__
@register.filter
def get_object_list_class(object_list, class_name):
for c in object_list:
if c.__class__.__name__ == class_name:
return True
return False
@register.filter
def get_slugs(value):
if value:
return value.split(',')
return ''
@register.simple_tag
def get_countries():
<|code_end|>
with the help of current file imports:
from django import template
from micro_blog.models import Post, Country
from django.core.urlresolvers import reverse
from django.conf import settings
import datetime
import re
import datetime
and context from other files:
# Path: micro_blog/models.py
# class Post(models.Model):
# STATUS_CHOICE = (
# ('D', 'Draft'),
# ('P', 'Published'),
# ('T', 'Rejected'),
# ('R', 'Review'),
# )
#
# title = models.CharField(max_length=100)
# created_on = models.DateTimeField(auto_now_add=True)
# updated_on = models.DateField(auto_now=True)
# user = models.ForeignKey(settings.AUTH_USER_MODEL)
# content = models.TextField()
# excerpt = models.CharField(max_length=500, default="")
# category = models.ForeignKey(Category, related_name='blog_posts')
# tags = models.ManyToManyField(Tags, related_name='rel_posts', blank=True)
# status = models.CharField(max_length=2, choices=STATUS_CHOICE, blank=True)
# published_on = models.DateField(blank=True, null=True)
# meta_description = models.TextField(max_length=500, default='')
# old_slugs = models.TextField()
#
# def __unicode__(self):
# return self.title
#
# def create_blog_slug(self, slugs):
# for each_slug in list(set(slugs)):
# blog_slugs = self.slugs.filter(slug=each_slug)
# if not blog_slugs:
# actual_slug = get_blog_slug(each_slug)
# Post_Slugs.objects.create(
# blog=self, slug=actual_slug, is_active=False
# )
#
# def check_and_activate_slug(self):
# # Check whether active slug is their for blog-post or not
# blog_slugs = self.slugs.all().order_by("id")
# if not blog_slugs.filter(is_active=True):
# active_slug = blog_slugs.last()
# active_slug.is_active = True
# active_slug.save()
#
# @property
# def slug(self):
# blog_slug = self.slugs.filter(is_active=True).first()
# if blog_slug:
# return str(blog_slug.slug)
# return ""
#
# @property
# def author(self):
# return self.user.first_name + ' ' + self.user.last_name
#
# def save(self, *args, **kwargs):
# if self.status == 'P':
# if not self.published_on:
# self.published_on = datetime.datetime.today()
# super(Post, self).save(*args, **kwargs)
#
# @property
# def get_url(self):
# return settings.SITE_BLOG_URL + self.slug
#
# def is_editable_by(self, user):
# if self.user == user or user.is_superuser:
# return True
# return False
#
# def is_deletable_by(self, user):
# if self.user == user or user.is_superuser:
# return True
# return False
#
# def get_content(self):
# table = html.fromstring(self.content)
# content = ''
# for item in table:
# if item.text:
# content += item.text.strip()
# return content[:350]
#
# class Country(models.Model):
# name = models.CharField(max_length=50, unique=True)
# code = models.CharField(max_length=50)
# slug = models.CharField(max_length=50, unique=True)
#
# def __str__(self):
# return self.name
, which may contain function names, class names, or code. Output only the next line. | return Country.objects.filter().order_by('id') |
Here is a snippet: <|code_start|>
def country_patterns(*urls, prefix_default_country=True):
"""
Adds the country code prefix to every URL pattern within this
function. This may only be used in the root URLconf, not in an included
URLconf.
"""
if not settings.USE_COUNTRY_URL:
return list(urls)
<|code_end|>
. Write the next line using the current file imports:
from django.conf import settings
from .resolvers import CountryRegexURLResolver
from django.core.urlresolvers import get_resolver
and context from other files:
# Path: microsite/resolvers.py
# class CountryRegexURLResolver(RegexURLResolver):
# """
# A URL resolver that always matches the active language code as URL prefix.
#
# Rather than taking a regex argument, we just override the ``regex``
# function to always return the active language-code as regex.
# """
# def __init__(
# self, urlconf_name, default_kwargs=None, app_name=None, namespace=None,
# prefix_default_country=False,
# ):
# super().__init__(None, urlconf_name, default_kwargs, app_name, namespace)
# self.prefix_default_country = prefix_default_country
#
# @property
# def regex(self):
# country_code = get_country_from_thread()
# if country_code not in self._regex_dict:
# if country_code == settings.COUNTRY_CODE and not self.prefix_default_country:
# regex_string = ''
# else:
# regex_string = '^%s/' % country_code
# self._regex_dict[country_code] = re.compile(regex_string)
# return self._regex_dict[country_code]
, which may include functions, classes, or code. Output only the next line. | return [CountryRegexURLResolver(list(urls), prefix_default_country=prefix_default_country)] |
Given the code snippet: <|code_start|>
class BlogpostForm(forms.ModelForm):
meta_description = forms.CharField(max_length=500, required=False)
class Meta:
<|code_end|>
, generate the next line using the imports in this file:
from django import forms
from micro_blog.models import Post, Category
and context (functions, classes, or occasionally code) from other files:
# Path: micro_blog/models.py
# class Post(models.Model):
# STATUS_CHOICE = (
# ('D', 'Draft'),
# ('P', 'Published'),
# ('T', 'Rejected'),
# ('R', 'Review'),
# )
#
# title = models.CharField(max_length=100)
# created_on = models.DateTimeField(auto_now_add=True)
# updated_on = models.DateField(auto_now=True)
# user = models.ForeignKey(settings.AUTH_USER_MODEL)
# content = models.TextField()
# excerpt = models.CharField(max_length=500, default="")
# category = models.ForeignKey(Category, related_name='blog_posts')
# tags = models.ManyToManyField(Tags, related_name='rel_posts', blank=True)
# status = models.CharField(max_length=2, choices=STATUS_CHOICE, blank=True)
# published_on = models.DateField(blank=True, null=True)
# meta_description = models.TextField(max_length=500, default='')
# old_slugs = models.TextField()
#
# def __unicode__(self):
# return self.title
#
# def create_blog_slug(self, slugs):
# for each_slug in list(set(slugs)):
# blog_slugs = self.slugs.filter(slug=each_slug)
# if not blog_slugs:
# actual_slug = get_blog_slug(each_slug)
# Post_Slugs.objects.create(
# blog=self, slug=actual_slug, is_active=False
# )
#
# def check_and_activate_slug(self):
# # Check whether active slug is their for blog-post or not
# blog_slugs = self.slugs.all().order_by("id")
# if not blog_slugs.filter(is_active=True):
# active_slug = blog_slugs.last()
# active_slug.is_active = True
# active_slug.save()
#
# @property
# def slug(self):
# blog_slug = self.slugs.filter(is_active=True).first()
# if blog_slug:
# return str(blog_slug.slug)
# return ""
#
# @property
# def author(self):
# return self.user.first_name + ' ' + self.user.last_name
#
# def save(self, *args, **kwargs):
# if self.status == 'P':
# if not self.published_on:
# self.published_on = datetime.datetime.today()
# super(Post, self).save(*args, **kwargs)
#
# @property
# def get_url(self):
# return settings.SITE_BLOG_URL + self.slug
#
# def is_editable_by(self, user):
# if self.user == user or user.is_superuser:
# return True
# return False
#
# def is_deletable_by(self, user):
# if self.user == user or user.is_superuser:
# return True
# return False
#
# def get_content(self):
# table = html.fromstring(self.content)
# content = ''
# for item in table:
# if item.text:
# content += item.text.strip()
# return content[:350]
#
# class Category(models.Model):
# name = models.CharField(max_length=50, unique=True)
# slug = models.CharField(max_length=50, unique=True)
# description = models.CharField(max_length=500)
# is_display = models.BooleanField(default=False)
# min_published_blogs = models.IntegerField()
# max_published_blogs = models.IntegerField()
#
# def save(self, *args, **kwargs):
# self.slug = slugify(self.name)
# super(Category, self).save(*args, **kwargs)
#
# def __unicode__(self):
# return self.name
#
# def __str__(self):
# return self.name
#
# @property
# def get_url(self):
# return settings.SITE_BLOG_URL + "category/" + self.slug
#
# def get_blog_posts(self):
# return Post.objects.filter(category=self, status='P')
#
# def no_of_blog_posts(self):
# return Post.objects.filter(category=self).count()
. Output only the next line. | model = Post |
Continue the code snippet: <|code_start|>
class BlogpostForm(forms.ModelForm):
meta_description = forms.CharField(max_length=500, required=False)
class Meta:
model = Post
exclude = ('tags', 'user', 'published_on', 'old_slugs')
class BlogCategoryForm(forms.ModelForm):
class Meta:
<|code_end|>
. Use current file imports:
from django import forms
from micro_blog.models import Post, Category
and context (classes, functions, or code) from other files:
# Path: micro_blog/models.py
# class Post(models.Model):
# STATUS_CHOICE = (
# ('D', 'Draft'),
# ('P', 'Published'),
# ('T', 'Rejected'),
# ('R', 'Review'),
# )
#
# title = models.CharField(max_length=100)
# created_on = models.DateTimeField(auto_now_add=True)
# updated_on = models.DateField(auto_now=True)
# user = models.ForeignKey(settings.AUTH_USER_MODEL)
# content = models.TextField()
# excerpt = models.CharField(max_length=500, default="")
# category = models.ForeignKey(Category, related_name='blog_posts')
# tags = models.ManyToManyField(Tags, related_name='rel_posts', blank=True)
# status = models.CharField(max_length=2, choices=STATUS_CHOICE, blank=True)
# published_on = models.DateField(blank=True, null=True)
# meta_description = models.TextField(max_length=500, default='')
# old_slugs = models.TextField()
#
# def __unicode__(self):
# return self.title
#
# def create_blog_slug(self, slugs):
# for each_slug in list(set(slugs)):
# blog_slugs = self.slugs.filter(slug=each_slug)
# if not blog_slugs:
# actual_slug = get_blog_slug(each_slug)
# Post_Slugs.objects.create(
# blog=self, slug=actual_slug, is_active=False
# )
#
# def check_and_activate_slug(self):
# # Check whether active slug is their for blog-post or not
# blog_slugs = self.slugs.all().order_by("id")
# if not blog_slugs.filter(is_active=True):
# active_slug = blog_slugs.last()
# active_slug.is_active = True
# active_slug.save()
#
# @property
# def slug(self):
# blog_slug = self.slugs.filter(is_active=True).first()
# if blog_slug:
# return str(blog_slug.slug)
# return ""
#
# @property
# def author(self):
# return self.user.first_name + ' ' + self.user.last_name
#
# def save(self, *args, **kwargs):
# if self.status == 'P':
# if not self.published_on:
# self.published_on = datetime.datetime.today()
# super(Post, self).save(*args, **kwargs)
#
# @property
# def get_url(self):
# return settings.SITE_BLOG_URL + self.slug
#
# def is_editable_by(self, user):
# if self.user == user or user.is_superuser:
# return True
# return False
#
# def is_deletable_by(self, user):
# if self.user == user or user.is_superuser:
# return True
# return False
#
# def get_content(self):
# table = html.fromstring(self.content)
# content = ''
# for item in table:
# if item.text:
# content += item.text.strip()
# return content[:350]
#
# class Category(models.Model):
# name = models.CharField(max_length=50, unique=True)
# slug = models.CharField(max_length=50, unique=True)
# description = models.CharField(max_length=500)
# is_display = models.BooleanField(default=False)
# min_published_blogs = models.IntegerField()
# max_published_blogs = models.IntegerField()
#
# def save(self, *args, **kwargs):
# self.slug = slugify(self.name)
# super(Category, self).save(*args, **kwargs)
#
# def __unicode__(self):
# return self.name
#
# def __str__(self):
# return self.name
#
# @property
# def get_url(self):
# return settings.SITE_BLOG_URL + "category/" + self.slug
#
# def get_blog_posts(self):
# return Post.objects.filter(category=self, status='P')
#
# def no_of_blog_posts(self):
# return Post.objects.filter(category=self).count()
. Output only the next line. | model = Category |
Next line prediction: <|code_start|>"""Log in to Django without providing a password."""
class PasswordlessAuthBackend(ModelBackend):
"""Custom authentication in djnago without providing a password."""
def authenticate(self, username=None):
try:
<|code_end|>
. Use current file imports:
(from django.contrib.auth.backends import ModelBackend
from micro_admin.models import User)
and context including class names, function names, or small code snippets from other files:
# Path: micro_admin/models.py
# class User(AbstractBaseUser, PermissionsMixin):
# username = models.CharField(max_length=30, unique=True)
# email = models.EmailField(verbose_name='email address', max_length=255, unique=True, db_index=True,)
# user_roles = models.CharField(choices=USER_ROLES, max_length=10)
# is_employee = models.BooleanField(default=False)
# date_of_birth = models.DateField(default='1970-01-01')
# is_active = models.BooleanField(default=True)
# is_admin = models.BooleanField(default=False)
# is_staff = models.BooleanField(_('staff status'), default=False)
# date_joined = models.DateTimeField(default=timezone.now)
# is_special = models.BooleanField(default=False)
# first_name = models.CharField(max_length=100, default='')
# last_name = models.CharField(max_length=100, default='')
# gender = models.CharField(choices=GENDER_TYPES, max_length=10)
# fb_profile = models.URLField(default='')
# tw_profile = models.URLField(default='')
# ln_profile = models.URLField(default='')
# google_plus_url = models.URLField(default='')
# about = models.CharField(max_length=2000, default='', null=True, blank=True)
# state = models.CharField(max_length=50)
# city = models.CharField(max_length=50)
# area = models.CharField(max_length=150)
# address = models.TextField(max_length=1000, default='')
# mobile = models.BigIntegerField(default='0')
# website = models.URLField(default='', null=True)
# phones = models.TextField(max_length=100, default='', null=True)
# pincode = models.TextField(max_length=50, default='', null=True)
# min_published_blogs = models.IntegerField(default=0)
# max_published_blogs = models.IntegerField(default=0)
#
# objects = UserManager()
#
# USERNAME_FIELD = 'email'
# REQUIRED_FIELDS = ['username']
#
# def get_full_name(self):
# # The user is identified by their email address
# return self.first_name + ' ' + self.last_name
#
# def get_short_name(self):
# # The user is identified by their email address
# return self.first_name
#
# def __unicode__(self):
# return self.first_name + ' (' + self.email + ')'
#
# def total_posts(self):
# return Post.objects.filter(user=self).count()
#
# def drafted_posts(self):
# return Post.objects.filter(user=self, status="D").count()
#
# def is_site_admin(self):
# if self.user_roles == "Admin" or self.is_superuser:
# return True
# return False
#
# class Meta:
# permissions = (
# ("blog_moderator", "Can enable or disable blog posts"),
# ("blogger", "Can write blog posts"),
# )
#
# def get_week_posts(self, value):
# if value:
# value = value.split('-')
# previous_date = datetime.strptime(value[0].strip(), "%Y/%m/%d").strftime("%Y-%m-%d")
# current_date = datetime.strptime(value[1].strip(), "%Y/%m/%d").strftime("%Y-%m-%d")
# else:
# current_date = datetime.strptime(str(datetime.now().date()), "%Y-%m-%d").strftime("%Y-%m-%d")
# previous_date = datetime.strptime(str(datetime.now().date() - timedelta(days=7)), "%Y-%m-%d").strftime("%Y-%m-%d")
# post = Post.objects.filter(user=self, created_on__range=(previous_date, current_date))
# return post.filter(status='P').count(), post.filter(status='D').count(), post.filter(status='R').count(), post.filter(status='T').count()
. Output only the next line. | return User.objects.get(email=username) |
Predict the next line after this snippet: <|code_start|>
class PageForm(forms.ModelForm):
contact_info = forms.CharField(max_length=5000, required=False)
class Meta:
<|code_end|>
using the current file's imports:
from django import forms
from pages.models import Page, Menu, Contact
from micro_blog.models import Subscribers, Category
import json
and any relevant context from other files:
# Path: pages/models.py
# class Page(models.Model):
# title = models.CharField(max_length=500)
# country = models.ForeignKey(Country, blank=True, null=True)
# is_default = models.BooleanField(default=False)
# parent = models.ForeignKey('self', blank=True, null=True, related_name='children')
# content = models.TextField()
# slug = models.SlugField()
# is_active = models.BooleanField(default=False)
# meta_data = models.TextField()
# category = models.ManyToManyField(Category)
# contact_info = JSONField(default={})
#
# # def save(self, *args, **kwargs):
# # tempslug = slugify(self.title)
# # if self.id:
# # existed_page = Page.objects.get(pk=self.id)
# # if existed_page.title != self.title:
# # self.slug = create_slug(tempslug)
# # else:
# # self.slug = create_slug(tempslug)
#
# # super(Page, self).save(*args, **kwargs)
# def get_contact_info(self):
# if self.contact_info:
# return json.dumps(self.contact_info)
# else:
# return ''
#
# def all_categories(self):
# categories = Category.objects.all()
# if self.category.all().count() == categories.count():
# return True
# else:
# return False
#
# def related_pages(self):
# menu = Menu.objects.filter(url=self.slug)
# menus = Menu.objects.filter(parent=menu[0].parent, status='on')
# return menus
#
# def __unicode__(self):
# return self.title
#
# class Menu(models.Model):
# parent = models.ForeignKey('self', blank=True, null=True)
# title = models.CharField(max_length=255)
# country = models.ForeignKey(Country, blank=True, null=True)
# url = models.URLField(max_length=255, blank=True, null=True)
# created = models.DateTimeField(auto_now=True)
# updated = models.DateTimeField(auto_now=True)
# status = models.CharField(max_length=5, default="off", blank=True)
# lvl = models.IntegerField()
#
# def menu_state(self):
# if self.status == 'on':
# return True
# else:
# return False
#
# def __unicode__(self):
# return self.title
#
# def has_children(self):
# if self.menu_set.exists():
# return True
# return False
#
# def is_child(self):
# if self.parent:
# return True
# return False
#
# def get_active_children(self):
# return self.menu_set.filter(status='on').order_by('lvl')
#
# class Contact(models.Model):
#
# ENQUERY_TYPES = (
# ('general', 'Request For Services'),
# ('partnership', 'Partnership Queries'),
# ('media', 'Media Queries'),
# ('general queries', 'General Queries'),
# ('feedback', 'Website Feedback'),
# ('others', 'Others'),
# )
#
# domain = models.CharField(max_length=100, null=True, blank=True)
# domain_url = models.URLField(max_length=200, null=True, blank=True)
# country = models.CharField(max_length=100)
# enquery_type = models.CharField(max_length=100, choices=ENQUERY_TYPES)
#
# # def __unicode__(self):
# # return self.contact_info.full_name
#
# Path: micro_blog/models.py
# class Subscribers(models.Model):
# email = models.EmailField(max_length=255)
# created = models.DateField(auto_now_add=True)
# blog_post = models.BooleanField(default=True)
# category = models.ForeignKey(Category, blank=True, null=True)
#
# def __str__(self):
# return self.email
#
# class Category(models.Model):
# name = models.CharField(max_length=50, unique=True)
# slug = models.CharField(max_length=50, unique=True)
# description = models.CharField(max_length=500)
# is_display = models.BooleanField(default=False)
# min_published_blogs = models.IntegerField()
# max_published_blogs = models.IntegerField()
#
# def save(self, *args, **kwargs):
# self.slug = slugify(self.name)
# super(Category, self).save(*args, **kwargs)
#
# def __unicode__(self):
# return self.name
#
# def __str__(self):
# return self.name
#
# @property
# def get_url(self):
# return settings.SITE_BLOG_URL + "category/" + self.slug
#
# def get_blog_posts(self):
# return Post.objects.filter(category=self, status='P')
#
# def no_of_blog_posts(self):
# return Post.objects.filter(category=self).count()
. Output only the next line. | model = Page |
Based on the snippet: <|code_start|>
def __init__(self, *args, **kwargs):
super(PageForm, self).__init__(*args, **kwargs)
def clean_contact_info(self):
if self.cleaned_data['contact_info']:
valid = False
print (json.loads(str(self.cleaned_data['contact_info'])))
try:
if json.loads(str(self.cleaned_data['contact_info'])):
valid = True
except:
valid = False
if valid:
return self.cleaned_data['contact_info']
else:
raise forms.ValidationError('Enter A Valid Json')
def save(self, commit=True):
instance = super(PageForm, self).save(commit=False)
instance.country_id = self.cleaned_data['country']
if commit:
instance.save()
return instance
class MenuForm(forms.ModelForm):
class Meta:
<|code_end|>
, predict the immediate next line with the help of imports:
from django import forms
from pages.models import Page, Menu, Contact
from micro_blog.models import Subscribers, Category
import json
and context (classes, functions, sometimes code) from other files:
# Path: pages/models.py
# class Page(models.Model):
# title = models.CharField(max_length=500)
# country = models.ForeignKey(Country, blank=True, null=True)
# is_default = models.BooleanField(default=False)
# parent = models.ForeignKey('self', blank=True, null=True, related_name='children')
# content = models.TextField()
# slug = models.SlugField()
# is_active = models.BooleanField(default=False)
# meta_data = models.TextField()
# category = models.ManyToManyField(Category)
# contact_info = JSONField(default={})
#
# # def save(self, *args, **kwargs):
# # tempslug = slugify(self.title)
# # if self.id:
# # existed_page = Page.objects.get(pk=self.id)
# # if existed_page.title != self.title:
# # self.slug = create_slug(tempslug)
# # else:
# # self.slug = create_slug(tempslug)
#
# # super(Page, self).save(*args, **kwargs)
# def get_contact_info(self):
# if self.contact_info:
# return json.dumps(self.contact_info)
# else:
# return ''
#
# def all_categories(self):
# categories = Category.objects.all()
# if self.category.all().count() == categories.count():
# return True
# else:
# return False
#
# def related_pages(self):
# menu = Menu.objects.filter(url=self.slug)
# menus = Menu.objects.filter(parent=menu[0].parent, status='on')
# return menus
#
# def __unicode__(self):
# return self.title
#
# class Menu(models.Model):
# parent = models.ForeignKey('self', blank=True, null=True)
# title = models.CharField(max_length=255)
# country = models.ForeignKey(Country, blank=True, null=True)
# url = models.URLField(max_length=255, blank=True, null=True)
# created = models.DateTimeField(auto_now=True)
# updated = models.DateTimeField(auto_now=True)
# status = models.CharField(max_length=5, default="off", blank=True)
# lvl = models.IntegerField()
#
# def menu_state(self):
# if self.status == 'on':
# return True
# else:
# return False
#
# def __unicode__(self):
# return self.title
#
# def has_children(self):
# if self.menu_set.exists():
# return True
# return False
#
# def is_child(self):
# if self.parent:
# return True
# return False
#
# def get_active_children(self):
# return self.menu_set.filter(status='on').order_by('lvl')
#
# class Contact(models.Model):
#
# ENQUERY_TYPES = (
# ('general', 'Request For Services'),
# ('partnership', 'Partnership Queries'),
# ('media', 'Media Queries'),
# ('general queries', 'General Queries'),
# ('feedback', 'Website Feedback'),
# ('others', 'Others'),
# )
#
# domain = models.CharField(max_length=100, null=True, blank=True)
# domain_url = models.URLField(max_length=200, null=True, blank=True)
# country = models.CharField(max_length=100)
# enquery_type = models.CharField(max_length=100, choices=ENQUERY_TYPES)
#
# # def __unicode__(self):
# # return self.contact_info.full_name
#
# Path: micro_blog/models.py
# class Subscribers(models.Model):
# email = models.EmailField(max_length=255)
# created = models.DateField(auto_now_add=True)
# blog_post = models.BooleanField(default=True)
# category = models.ForeignKey(Category, blank=True, null=True)
#
# def __str__(self):
# return self.email
#
# class Category(models.Model):
# name = models.CharField(max_length=50, unique=True)
# slug = models.CharField(max_length=50, unique=True)
# description = models.CharField(max_length=500)
# is_display = models.BooleanField(default=False)
# min_published_blogs = models.IntegerField()
# max_published_blogs = models.IntegerField()
#
# def save(self, *args, **kwargs):
# self.slug = slugify(self.name)
# super(Category, self).save(*args, **kwargs)
#
# def __unicode__(self):
# return self.name
#
# def __str__(self):
# return self.name
#
# @property
# def get_url(self):
# return settings.SITE_BLOG_URL + "category/" + self.slug
#
# def get_blog_posts(self):
# return Post.objects.filter(category=self, status='P')
#
# def no_of_blog_posts(self):
# return Post.objects.filter(category=self).count()
. Output only the next line. | model = Menu |
Predict the next line for this snippet: <|code_start|> except:
valid = False
if valid:
return self.cleaned_data['contact_info']
else:
raise forms.ValidationError('Enter A Valid Json')
def save(self, commit=True):
instance = super(PageForm, self).save(commit=False)
instance.country_id = self.cleaned_data['country']
if commit:
instance.save()
return instance
class MenuForm(forms.ModelForm):
class Meta:
model = Menu
exclude = ('lvl', 'url')
class ContactForm(forms.ModelForm):
email = forms.EmailField()
full_name = forms.CharField(max_length=200)
message = forms.CharField(max_length=200)
country = forms.CharField(max_length=200, required=False)
enquery_type = forms.CharField(max_length=200, required=False)
class Meta:
<|code_end|>
with the help of current file imports:
from django import forms
from pages.models import Page, Menu, Contact
from micro_blog.models import Subscribers, Category
import json
and context from other files:
# Path: pages/models.py
# class Page(models.Model):
# title = models.CharField(max_length=500)
# country = models.ForeignKey(Country, blank=True, null=True)
# is_default = models.BooleanField(default=False)
# parent = models.ForeignKey('self', blank=True, null=True, related_name='children')
# content = models.TextField()
# slug = models.SlugField()
# is_active = models.BooleanField(default=False)
# meta_data = models.TextField()
# category = models.ManyToManyField(Category)
# contact_info = JSONField(default={})
#
# # def save(self, *args, **kwargs):
# # tempslug = slugify(self.title)
# # if self.id:
# # existed_page = Page.objects.get(pk=self.id)
# # if existed_page.title != self.title:
# # self.slug = create_slug(tempslug)
# # else:
# # self.slug = create_slug(tempslug)
#
# # super(Page, self).save(*args, **kwargs)
# def get_contact_info(self):
# if self.contact_info:
# return json.dumps(self.contact_info)
# else:
# return ''
#
# def all_categories(self):
# categories = Category.objects.all()
# if self.category.all().count() == categories.count():
# return True
# else:
# return False
#
# def related_pages(self):
# menu = Menu.objects.filter(url=self.slug)
# menus = Menu.objects.filter(parent=menu[0].parent, status='on')
# return menus
#
# def __unicode__(self):
# return self.title
#
# class Menu(models.Model):
# parent = models.ForeignKey('self', blank=True, null=True)
# title = models.CharField(max_length=255)
# country = models.ForeignKey(Country, blank=True, null=True)
# url = models.URLField(max_length=255, blank=True, null=True)
# created = models.DateTimeField(auto_now=True)
# updated = models.DateTimeField(auto_now=True)
# status = models.CharField(max_length=5, default="off", blank=True)
# lvl = models.IntegerField()
#
# def menu_state(self):
# if self.status == 'on':
# return True
# else:
# return False
#
# def __unicode__(self):
# return self.title
#
# def has_children(self):
# if self.menu_set.exists():
# return True
# return False
#
# def is_child(self):
# if self.parent:
# return True
# return False
#
# def get_active_children(self):
# return self.menu_set.filter(status='on').order_by('lvl')
#
# class Contact(models.Model):
#
# ENQUERY_TYPES = (
# ('general', 'Request For Services'),
# ('partnership', 'Partnership Queries'),
# ('media', 'Media Queries'),
# ('general queries', 'General Queries'),
# ('feedback', 'Website Feedback'),
# ('others', 'Others'),
# )
#
# domain = models.CharField(max_length=100, null=True, blank=True)
# domain_url = models.URLField(max_length=200, null=True, blank=True)
# country = models.CharField(max_length=100)
# enquery_type = models.CharField(max_length=100, choices=ENQUERY_TYPES)
#
# # def __unicode__(self):
# # return self.contact_info.full_name
#
# Path: micro_blog/models.py
# class Subscribers(models.Model):
# email = models.EmailField(max_length=255)
# created = models.DateField(auto_now_add=True)
# blog_post = models.BooleanField(default=True)
# category = models.ForeignKey(Category, blank=True, null=True)
#
# def __str__(self):
# return self.email
#
# class Category(models.Model):
# name = models.CharField(max_length=50, unique=True)
# slug = models.CharField(max_length=50, unique=True)
# description = models.CharField(max_length=500)
# is_display = models.BooleanField(default=False)
# min_published_blogs = models.IntegerField()
# max_published_blogs = models.IntegerField()
#
# def save(self, *args, **kwargs):
# self.slug = slugify(self.name)
# super(Category, self).save(*args, **kwargs)
#
# def __unicode__(self):
# return self.name
#
# def __str__(self):
# return self.name
#
# @property
# def get_url(self):
# return settings.SITE_BLOG_URL + "category/" + self.slug
#
# def get_blog_posts(self):
# return Post.objects.filter(category=self, status='P')
#
# def no_of_blog_posts(self):
# return Post.objects.filter(category=self).count()
, which may contain function names, class names, or code. Output only the next line. | model = Contact |
Continue the code snippet: <|code_start|>
class MenuForm(forms.ModelForm):
class Meta:
model = Menu
exclude = ('lvl', 'url')
class ContactForm(forms.ModelForm):
email = forms.EmailField()
full_name = forms.CharField(max_length=200)
message = forms.CharField(max_length=200)
country = forms.CharField(max_length=200, required=False)
enquery_type = forms.CharField(max_length=200, required=False)
class Meta:
model = Contact
exclude = ('full_name', 'message', 'email', 'phone', 'contact_info', 'country', 'enquery_type')
def __init__(self, *args, **kwargs):
super(ContactForm, self).__init__(*args, **kwargs)
# if 'country' in self.data.keys():
# self.fields['country'].required = True
if 'enquery_type' in self.data.keys():
self.fields['enquery_type'].required = True
class SubscribeForm(forms.ModelForm):
class Meta:
<|code_end|>
. Use current file imports:
from django import forms
from pages.models import Page, Menu, Contact
from micro_blog.models import Subscribers, Category
import json
and context (classes, functions, or code) from other files:
# Path: pages/models.py
# class Page(models.Model):
# title = models.CharField(max_length=500)
# country = models.ForeignKey(Country, blank=True, null=True)
# is_default = models.BooleanField(default=False)
# parent = models.ForeignKey('self', blank=True, null=True, related_name='children')
# content = models.TextField()
# slug = models.SlugField()
# is_active = models.BooleanField(default=False)
# meta_data = models.TextField()
# category = models.ManyToManyField(Category)
# contact_info = JSONField(default={})
#
# # def save(self, *args, **kwargs):
# # tempslug = slugify(self.title)
# # if self.id:
# # existed_page = Page.objects.get(pk=self.id)
# # if existed_page.title != self.title:
# # self.slug = create_slug(tempslug)
# # else:
# # self.slug = create_slug(tempslug)
#
# # super(Page, self).save(*args, **kwargs)
# def get_contact_info(self):
# if self.contact_info:
# return json.dumps(self.contact_info)
# else:
# return ''
#
# def all_categories(self):
# categories = Category.objects.all()
# if self.category.all().count() == categories.count():
# return True
# else:
# return False
#
# def related_pages(self):
# menu = Menu.objects.filter(url=self.slug)
# menus = Menu.objects.filter(parent=menu[0].parent, status='on')
# return menus
#
# def __unicode__(self):
# return self.title
#
# class Menu(models.Model):
# parent = models.ForeignKey('self', blank=True, null=True)
# title = models.CharField(max_length=255)
# country = models.ForeignKey(Country, blank=True, null=True)
# url = models.URLField(max_length=255, blank=True, null=True)
# created = models.DateTimeField(auto_now=True)
# updated = models.DateTimeField(auto_now=True)
# status = models.CharField(max_length=5, default="off", blank=True)
# lvl = models.IntegerField()
#
# def menu_state(self):
# if self.status == 'on':
# return True
# else:
# return False
#
# def __unicode__(self):
# return self.title
#
# def has_children(self):
# if self.menu_set.exists():
# return True
# return False
#
# def is_child(self):
# if self.parent:
# return True
# return False
#
# def get_active_children(self):
# return self.menu_set.filter(status='on').order_by('lvl')
#
# class Contact(models.Model):
#
# ENQUERY_TYPES = (
# ('general', 'Request For Services'),
# ('partnership', 'Partnership Queries'),
# ('media', 'Media Queries'),
# ('general queries', 'General Queries'),
# ('feedback', 'Website Feedback'),
# ('others', 'Others'),
# )
#
# domain = models.CharField(max_length=100, null=True, blank=True)
# domain_url = models.URLField(max_length=200, null=True, blank=True)
# country = models.CharField(max_length=100)
# enquery_type = models.CharField(max_length=100, choices=ENQUERY_TYPES)
#
# # def __unicode__(self):
# # return self.contact_info.full_name
#
# Path: micro_blog/models.py
# class Subscribers(models.Model):
# email = models.EmailField(max_length=255)
# created = models.DateField(auto_now_add=True)
# blog_post = models.BooleanField(default=True)
# category = models.ForeignKey(Category, blank=True, null=True)
#
# def __str__(self):
# return self.email
#
# class Category(models.Model):
# name = models.CharField(max_length=50, unique=True)
# slug = models.CharField(max_length=50, unique=True)
# description = models.CharField(max_length=500)
# is_display = models.BooleanField(default=False)
# min_published_blogs = models.IntegerField()
# max_published_blogs = models.IntegerField()
#
# def save(self, *args, **kwargs):
# self.slug = slugify(self.name)
# super(Category, self).save(*args, **kwargs)
#
# def __unicode__(self):
# return self.name
#
# def __str__(self):
# return self.name
#
# @property
# def get_url(self):
# return settings.SITE_BLOG_URL + "category/" + self.slug
#
# def get_blog_posts(self):
# return Post.objects.filter(category=self, status='P')
#
# def no_of_blog_posts(self):
# return Post.objects.filter(category=self).count()
. Output only the next line. | model = Subscribers |
Here is a snippet: <|code_start|> full_name = forms.CharField(max_length=200)
message = forms.CharField(max_length=200)
country = forms.CharField(max_length=200, required=False)
enquery_type = forms.CharField(max_length=200, required=False)
class Meta:
model = Contact
exclude = ('full_name', 'message', 'email', 'phone', 'contact_info', 'country', 'enquery_type')
def __init__(self, *args, **kwargs):
super(ContactForm, self).__init__(*args, **kwargs)
# if 'country' in self.data.keys():
# self.fields['country'].required = True
if 'enquery_type' in self.data.keys():
self.fields['enquery_type'].required = True
class SubscribeForm(forms.ModelForm):
class Meta:
model = Subscribers
fields = ('email',)
def __init__(self, *args, **kwargs):
super(SubscribeForm, self).__init__(*args, **kwargs)
def clean_email(self):
if str(self.data['is_blog']) == 'True':
if len(self.data['is_category']) > 0:
<|code_end|>
. Write the next line using the current file imports:
from django import forms
from pages.models import Page, Menu, Contact
from micro_blog.models import Subscribers, Category
import json
and context from other files:
# Path: pages/models.py
# class Page(models.Model):
# title = models.CharField(max_length=500)
# country = models.ForeignKey(Country, blank=True, null=True)
# is_default = models.BooleanField(default=False)
# parent = models.ForeignKey('self', blank=True, null=True, related_name='children')
# content = models.TextField()
# slug = models.SlugField()
# is_active = models.BooleanField(default=False)
# meta_data = models.TextField()
# category = models.ManyToManyField(Category)
# contact_info = JSONField(default={})
#
# # def save(self, *args, **kwargs):
# # tempslug = slugify(self.title)
# # if self.id:
# # existed_page = Page.objects.get(pk=self.id)
# # if existed_page.title != self.title:
# # self.slug = create_slug(tempslug)
# # else:
# # self.slug = create_slug(tempslug)
#
# # super(Page, self).save(*args, **kwargs)
# def get_contact_info(self):
# if self.contact_info:
# return json.dumps(self.contact_info)
# else:
# return ''
#
# def all_categories(self):
# categories = Category.objects.all()
# if self.category.all().count() == categories.count():
# return True
# else:
# return False
#
# def related_pages(self):
# menu = Menu.objects.filter(url=self.slug)
# menus = Menu.objects.filter(parent=menu[0].parent, status='on')
# return menus
#
# def __unicode__(self):
# return self.title
#
# class Menu(models.Model):
# parent = models.ForeignKey('self', blank=True, null=True)
# title = models.CharField(max_length=255)
# country = models.ForeignKey(Country, blank=True, null=True)
# url = models.URLField(max_length=255, blank=True, null=True)
# created = models.DateTimeField(auto_now=True)
# updated = models.DateTimeField(auto_now=True)
# status = models.CharField(max_length=5, default="off", blank=True)
# lvl = models.IntegerField()
#
# def menu_state(self):
# if self.status == 'on':
# return True
# else:
# return False
#
# def __unicode__(self):
# return self.title
#
# def has_children(self):
# if self.menu_set.exists():
# return True
# return False
#
# def is_child(self):
# if self.parent:
# return True
# return False
#
# def get_active_children(self):
# return self.menu_set.filter(status='on').order_by('lvl')
#
# class Contact(models.Model):
#
# ENQUERY_TYPES = (
# ('general', 'Request For Services'),
# ('partnership', 'Partnership Queries'),
# ('media', 'Media Queries'),
# ('general queries', 'General Queries'),
# ('feedback', 'Website Feedback'),
# ('others', 'Others'),
# )
#
# domain = models.CharField(max_length=100, null=True, blank=True)
# domain_url = models.URLField(max_length=200, null=True, blank=True)
# country = models.CharField(max_length=100)
# enquery_type = models.CharField(max_length=100, choices=ENQUERY_TYPES)
#
# # def __unicode__(self):
# # return self.contact_info.full_name
#
# Path: micro_blog/models.py
# class Subscribers(models.Model):
# email = models.EmailField(max_length=255)
# created = models.DateField(auto_now_add=True)
# blog_post = models.BooleanField(default=True)
# category = models.ForeignKey(Category, blank=True, null=True)
#
# def __str__(self):
# return self.email
#
# class Category(models.Model):
# name = models.CharField(max_length=50, unique=True)
# slug = models.CharField(max_length=50, unique=True)
# description = models.CharField(max_length=500)
# is_display = models.BooleanField(default=False)
# min_published_blogs = models.IntegerField()
# max_published_blogs = models.IntegerField()
#
# def save(self, *args, **kwargs):
# self.slug = slugify(self.name)
# super(Category, self).save(*args, **kwargs)
#
# def __unicode__(self):
# return self.name
#
# def __str__(self):
# return self.name
#
# @property
# def get_url(self):
# return settings.SITE_BLOG_URL + "category/" + self.slug
#
# def get_blog_posts(self):
# return Post.objects.filter(category=self, status='P')
#
# def no_of_blog_posts(self):
# return Post.objects.filter(category=self).count()
, which may include functions, classes, or code. Output only the next line. | category = Category.objects.get(id=self.data['is_category']) |
Given snippet: <|code_start|> google_plus_url = models.URLField(default='')
about = models.CharField(max_length=2000, default='', null=True, blank=True)
state = models.CharField(max_length=50)
city = models.CharField(max_length=50)
area = models.CharField(max_length=150)
address = models.TextField(max_length=1000, default='')
mobile = models.BigIntegerField(default='0')
website = models.URLField(default='', null=True)
phones = models.TextField(max_length=100, default='', null=True)
pincode = models.TextField(max_length=50, default='', null=True)
min_published_blogs = models.IntegerField(default=0)
max_published_blogs = models.IntegerField(default=0)
objects = UserManager()
USERNAME_FIELD = 'email'
REQUIRED_FIELDS = ['username']
def get_full_name(self):
# The user is identified by their email address
return self.first_name + ' ' + self.last_name
def get_short_name(self):
# The user is identified by their email address
return self.first_name
def __unicode__(self):
return self.first_name + ' (' + self.email + ')'
def total_posts(self):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.db import models
from django.utils.translation import ugettext_lazy as _
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, UserManager
from micro_blog.models import Post
from django.template.defaultfilters import slugify
from django.utils import timezone
from datetime import datetime
from datetime import timedelta
and context:
# Path: micro_blog/models.py
# class Post(models.Model):
# STATUS_CHOICE = (
# ('D', 'Draft'),
# ('P', 'Published'),
# ('T', 'Rejected'),
# ('R', 'Review'),
# )
#
# title = models.CharField(max_length=100)
# created_on = models.DateTimeField(auto_now_add=True)
# updated_on = models.DateField(auto_now=True)
# user = models.ForeignKey(settings.AUTH_USER_MODEL)
# content = models.TextField()
# excerpt = models.CharField(max_length=500, default="")
# category = models.ForeignKey(Category, related_name='blog_posts')
# tags = models.ManyToManyField(Tags, related_name='rel_posts', blank=True)
# status = models.CharField(max_length=2, choices=STATUS_CHOICE, blank=True)
# published_on = models.DateField(blank=True, null=True)
# meta_description = models.TextField(max_length=500, default='')
# old_slugs = models.TextField()
#
# def __unicode__(self):
# return self.title
#
# def create_blog_slug(self, slugs):
# for each_slug in list(set(slugs)):
# blog_slugs = self.slugs.filter(slug=each_slug)
# if not blog_slugs:
# actual_slug = get_blog_slug(each_slug)
# Post_Slugs.objects.create(
# blog=self, slug=actual_slug, is_active=False
# )
#
# def check_and_activate_slug(self):
# # Check whether active slug is their for blog-post or not
# blog_slugs = self.slugs.all().order_by("id")
# if not blog_slugs.filter(is_active=True):
# active_slug = blog_slugs.last()
# active_slug.is_active = True
# active_slug.save()
#
# @property
# def slug(self):
# blog_slug = self.slugs.filter(is_active=True).first()
# if blog_slug:
# return str(blog_slug.slug)
# return ""
#
# @property
# def author(self):
# return self.user.first_name + ' ' + self.user.last_name
#
# def save(self, *args, **kwargs):
# if self.status == 'P':
# if not self.published_on:
# self.published_on = datetime.datetime.today()
# super(Post, self).save(*args, **kwargs)
#
# @property
# def get_url(self):
# return settings.SITE_BLOG_URL + self.slug
#
# def is_editable_by(self, user):
# if self.user == user or user.is_superuser:
# return True
# return False
#
# def is_deletable_by(self, user):
# if self.user == user or user.is_superuser:
# return True
# return False
#
# def get_content(self):
# table = html.fromstring(self.content)
# content = ''
# for item in table:
# if item.text:
# content += item.text.strip()
# return content[:350]
which might include code, classes, or functions. Output only the next line. | return Post.objects.filter(user=self).count() |
Predict the next line for this snippet: <|code_start|>
class Page(models.Model):
title = models.CharField(max_length=500)
country = models.ForeignKey(Country, blank=True, null=True)
is_default = models.BooleanField(default=False)
parent = models.ForeignKey('self', blank=True, null=True, related_name='children')
content = models.TextField()
slug = models.SlugField()
is_active = models.BooleanField(default=False)
meta_data = models.TextField()
<|code_end|>
with the help of current file imports:
from django.db import models
from django.core.exceptions import ObjectDoesNotExist
from micro_blog.models import Category, Country
from django.contrib.postgres.fields import ArrayField, JSONField
import json
and context from other files:
# Path: micro_blog/models.py
# class Category(models.Model):
# name = models.CharField(max_length=50, unique=True)
# slug = models.CharField(max_length=50, unique=True)
# description = models.CharField(max_length=500)
# is_display = models.BooleanField(default=False)
# min_published_blogs = models.IntegerField()
# max_published_blogs = models.IntegerField()
#
# def save(self, *args, **kwargs):
# self.slug = slugify(self.name)
# super(Category, self).save(*args, **kwargs)
#
# def __unicode__(self):
# return self.name
#
# def __str__(self):
# return self.name
#
# @property
# def get_url(self):
# return settings.SITE_BLOG_URL + "category/" + self.slug
#
# def get_blog_posts(self):
# return Post.objects.filter(category=self, status='P')
#
# def no_of_blog_posts(self):
# return Post.objects.filter(category=self).count()
#
# class Country(models.Model):
# name = models.CharField(max_length=50, unique=True)
# code = models.CharField(max_length=50)
# slug = models.CharField(max_length=50, unique=True)
#
# def __str__(self):
# return self.name
, which may contain function names, class names, or code. Output only the next line. | category = models.ManyToManyField(Category) |
Continue the code snippet: <|code_start|>
try:
except ImportError: # pragma: no cover
raise unittest.SkipTest("vlen-bytes not available")
greetings_bytes = [g.encode('utf-8') for g in greetings]
arrays = [
np.array([b'foo', b'bar', b'baz'] * 300, dtype=object),
np.array(greetings_bytes * 100, dtype=object),
np.array([b'foo', b'bar', b'baz'] * 300, dtype=object).reshape(90, 10),
np.array(greetings_bytes * 1000, dtype=object).reshape(len(greetings_bytes), 100, 10,
order='F'),
]
def test_encode_decode():
for arr in arrays:
codec = VLenBytes()
check_encode_decode_array(arr, codec)
def test_config():
codec = VLenBytes()
<|code_end|>
. Use current file imports:
import unittest
import numpy as np
import pytest
from numcodecs.vlen import VLenBytes
from numcodecs.tests.common import (check_config, check_repr, check_encode_decode_array,
check_backwards_compatibility, greetings,
assert_array_items_equal)
and context (classes, functions, or code) from other files:
# Path: numcodecs/tests/common.py
# def compare_arrays(arr, res, precision=None):
# def check_encode_decode(arr, codec, precision=None):
# def check_encode_decode_partial(arr, codec, precision=None):
# def assert_array_items_equal(res, arr):
# def check_encode_decode_array(arr, codec):
# def check_config(codec):
# def check_repr(stmt):
# def check_backwards_compatibility(codec_id, arrays, codecs, precision=None, prefix=None):
# def check_err_decode_object_buffer(compressor):
# def check_err_encode_object_buffer(compressor):
# def check_max_buffer_size(codec):
. Output only the next line. | check_config(codec) |
Based on the snippet: <|code_start|>
try:
except ImportError: # pragma: no cover
raise unittest.SkipTest("vlen-bytes not available")
greetings_bytes = [g.encode('utf-8') for g in greetings]
arrays = [
np.array([b'foo', b'bar', b'baz'] * 300, dtype=object),
np.array(greetings_bytes * 100, dtype=object),
np.array([b'foo', b'bar', b'baz'] * 300, dtype=object).reshape(90, 10),
np.array(greetings_bytes * 1000, dtype=object).reshape(len(greetings_bytes), 100, 10,
order='F'),
]
def test_encode_decode():
for arr in arrays:
codec = VLenBytes()
check_encode_decode_array(arr, codec)
def test_config():
codec = VLenBytes()
check_config(codec)
def test_repr():
<|code_end|>
, predict the immediate next line with the help of imports:
import unittest
import numpy as np
import pytest
from numcodecs.vlen import VLenBytes
from numcodecs.tests.common import (check_config, check_repr, check_encode_decode_array,
check_backwards_compatibility, greetings,
assert_array_items_equal)
and context (classes, functions, sometimes code) from other files:
# Path: numcodecs/tests/common.py
# def compare_arrays(arr, res, precision=None):
# def check_encode_decode(arr, codec, precision=None):
# def check_encode_decode_partial(arr, codec, precision=None):
# def assert_array_items_equal(res, arr):
# def check_encode_decode_array(arr, codec):
# def check_config(codec):
# def check_repr(stmt):
# def check_backwards_compatibility(codec_id, arrays, codecs, precision=None, prefix=None):
# def check_err_decode_object_buffer(compressor):
# def check_err_encode_object_buffer(compressor):
# def check_max_buffer_size(codec):
. Output only the next line. | check_repr("VLenBytes()") |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.