Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Based on the snippet: <|code_start|>
class Parser:
def __init__(self, schema, named_schemas, action_function):
self.schema = schema
self.named_schemas = named_schemas
self.action_function = action_function
self.stack = self.parse()
def parse(self):
symbol = self._parse(self.schema)
root = Root([symbol])
root.production.insert(0, root)
return [root, symbol]
def _parse(self, schema, default=NO_DEFAULT):
record_type = extract_record_type(schema)
if record_type == "record":
production = []
production.append(RecordStart(default=default))
for field in schema["fields"]:
production.insert(0, FieldStart(field["name"]))
production.insert(
0, self._parse(field["type"], field.get("default", NO_DEFAULT))
)
production.insert(0, FieldEnd())
<|code_end|>
, predict the immediate next line with the help of imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context (classes, functions, sometimes code) from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | production.insert(0, RecordEnd()) |
Here is a snippet: <|code_start|>
class Parser:
def __init__(self, schema, named_schemas, action_function):
self.schema = schema
self.named_schemas = named_schemas
self.action_function = action_function
self.stack = self.parse()
def parse(self):
symbol = self._parse(self.schema)
root = Root([symbol])
root.production.insert(0, root)
return [root, symbol]
def _parse(self, schema, default=NO_DEFAULT):
record_type = extract_record_type(schema)
if record_type == "record":
production = []
production.append(RecordStart(default=default))
for field in schema["fields"]:
<|code_end|>
. Write the next line using the current file imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
, which may include functions, classes, or code. Output only the next line. | production.insert(0, FieldStart(field["name"])) |
Here is a snippet: <|code_start|>
class Parser:
def __init__(self, schema, named_schemas, action_function):
self.schema = schema
self.named_schemas = named_schemas
self.action_function = action_function
self.stack = self.parse()
def parse(self):
symbol = self._parse(self.schema)
root = Root([symbol])
root.production.insert(0, root)
return [root, symbol]
def _parse(self, schema, default=NO_DEFAULT):
record_type = extract_record_type(schema)
if record_type == "record":
production = []
production.append(RecordStart(default=default))
for field in schema["fields"]:
production.insert(0, FieldStart(field["name"]))
production.insert(
0, self._parse(field["type"], field.get("default", NO_DEFAULT))
)
<|code_end|>
. Write the next line using the current file imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
, which may include functions, classes, or code. Output only the next line. | production.insert(0, FieldEnd()) |
Here is a snippet: <|code_start|> elif record_type == "map":
repeat = Repeater(
MapEnd(),
# ItemEnd(), # TODO: Maybe need this?
self._parse(schema["values"]),
MapKeyMarker(),
String(),
)
return Sequence(repeat, MapStart(default=default))
elif record_type == "array":
repeat = Repeater(
ArrayEnd(),
ItemEnd(),
self._parse(schema["items"]),
)
return Sequence(repeat, ArrayStart(default=default))
elif record_type == "enum":
return Sequence(EnumLabels(schema["symbols"]), Enum(default=default))
elif record_type == "null":
return Null()
elif record_type == "boolean":
return Boolean(default=default)
elif record_type == "string":
return String(default=default)
elif record_type == "bytes":
return Bytes(default=default)
elif record_type == "int":
<|code_end|>
. Write the next line using the current file imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
, which may include functions, classes, or code. Output only the next line. | return Int(default=default) |
Given snippet: <|code_start|> labels.append(
candidate_schema.get("name", candidate_schema.get("type"))
)
else:
labels.append(candidate_schema)
return Sequence(Alternative(symbols, labels, default=default), Union())
elif record_type == "map":
repeat = Repeater(
MapEnd(),
# ItemEnd(), # TODO: Maybe need this?
self._parse(schema["values"]),
MapKeyMarker(),
String(),
)
return Sequence(repeat, MapStart(default=default))
elif record_type == "array":
repeat = Repeater(
ArrayEnd(),
ItemEnd(),
self._parse(schema["items"]),
)
return Sequence(repeat, ArrayStart(default=default))
elif record_type == "enum":
return Sequence(EnumLabels(schema["symbols"]), Enum(default=default))
elif record_type == "null":
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
which might include code, classes, or functions. Output only the next line. | return Null() |
Continue the code snippet: <|code_start|> production.insert(0, FieldStart(field["name"]))
production.insert(
0, self._parse(field["type"], field.get("default", NO_DEFAULT))
)
production.insert(0, FieldEnd())
production.insert(0, RecordEnd())
seq = Sequence(*production)
return seq
elif record_type == "union":
symbols = []
labels = []
for candidate_schema in schema:
symbols.append(self._parse(candidate_schema))
if isinstance(candidate_schema, dict):
labels.append(
candidate_schema.get("name", candidate_schema.get("type"))
)
else:
labels.append(candidate_schema)
return Sequence(Alternative(symbols, labels, default=default), Union())
elif record_type == "map":
repeat = Repeater(
MapEnd(),
# ItemEnd(), # TODO: Maybe need this?
self._parse(schema["values"]),
MapKeyMarker(),
<|code_end|>
. Use current file imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context (classes, functions, or code) from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | String(), |
Next line prediction: <|code_start|> def _parse(self, schema, default=NO_DEFAULT):
record_type = extract_record_type(schema)
if record_type == "record":
production = []
production.append(RecordStart(default=default))
for field in schema["fields"]:
production.insert(0, FieldStart(field["name"]))
production.insert(
0, self._parse(field["type"], field.get("default", NO_DEFAULT))
)
production.insert(0, FieldEnd())
production.insert(0, RecordEnd())
seq = Sequence(*production)
return seq
elif record_type == "union":
symbols = []
labels = []
for candidate_schema in schema:
symbols.append(self._parse(candidate_schema))
if isinstance(candidate_schema, dict):
labels.append(
candidate_schema.get("name", candidate_schema.get("type"))
)
else:
labels.append(candidate_schema)
<|code_end|>
. Use current file imports:
(from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type)
and context including class names, function names, or small code snippets from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | return Sequence(Alternative(symbols, labels, default=default), Union()) |
Given the code snippet: <|code_start|> def _parse(self, schema, default=NO_DEFAULT):
record_type = extract_record_type(schema)
if record_type == "record":
production = []
production.append(RecordStart(default=default))
for field in schema["fields"]:
production.insert(0, FieldStart(field["name"]))
production.insert(
0, self._parse(field["type"], field.get("default", NO_DEFAULT))
)
production.insert(0, FieldEnd())
production.insert(0, RecordEnd())
seq = Sequence(*production)
return seq
elif record_type == "union":
symbols = []
labels = []
for candidate_schema in schema:
symbols.append(self._parse(candidate_schema))
if isinstance(candidate_schema, dict):
labels.append(
candidate_schema.get("name", candidate_schema.get("type"))
)
else:
labels.append(candidate_schema)
<|code_end|>
, generate the next line using the imports in this file:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context (functions, classes, or occasionally code) from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | return Sequence(Alternative(symbols, labels, default=default), Union()) |
Given the code snippet: <|code_start|> MapEnd(),
# ItemEnd(), # TODO: Maybe need this?
self._parse(schema["values"]),
MapKeyMarker(),
String(),
)
return Sequence(repeat, MapStart(default=default))
elif record_type == "array":
repeat = Repeater(
ArrayEnd(),
ItemEnd(),
self._parse(schema["items"]),
)
return Sequence(repeat, ArrayStart(default=default))
elif record_type == "enum":
return Sequence(EnumLabels(schema["symbols"]), Enum(default=default))
elif record_type == "null":
return Null()
elif record_type == "boolean":
return Boolean(default=default)
elif record_type == "string":
return String(default=default)
elif record_type == "bytes":
return Bytes(default=default)
elif record_type == "int":
return Int(default=default)
elif record_type == "long":
<|code_end|>
, generate the next line using the imports in this file:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context (functions, classes, or occasionally code) from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | return Long(default=default) |
Based on the snippet: <|code_start|> self._parse(schema["values"]),
MapKeyMarker(),
String(),
)
return Sequence(repeat, MapStart(default=default))
elif record_type == "array":
repeat = Repeater(
ArrayEnd(),
ItemEnd(),
self._parse(schema["items"]),
)
return Sequence(repeat, ArrayStart(default=default))
elif record_type == "enum":
return Sequence(EnumLabels(schema["symbols"]), Enum(default=default))
elif record_type == "null":
return Null()
elif record_type == "boolean":
return Boolean(default=default)
elif record_type == "string":
return String(default=default)
elif record_type == "bytes":
return Bytes(default=default)
elif record_type == "int":
return Int(default=default)
elif record_type == "long":
return Long(default=default)
elif record_type == "float":
<|code_end|>
, predict the immediate next line with the help of imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context (classes, functions, sometimes code) from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | return Float(default=default) |
Given the following code snippet before the placeholder: <|code_start|> String(),
)
return Sequence(repeat, MapStart(default=default))
elif record_type == "array":
repeat = Repeater(
ArrayEnd(),
ItemEnd(),
self._parse(schema["items"]),
)
return Sequence(repeat, ArrayStart(default=default))
elif record_type == "enum":
return Sequence(EnumLabels(schema["symbols"]), Enum(default=default))
elif record_type == "null":
return Null()
elif record_type == "boolean":
return Boolean(default=default)
elif record_type == "string":
return String(default=default)
elif record_type == "bytes":
return Bytes(default=default)
elif record_type == "int":
return Int(default=default)
elif record_type == "long":
return Long(default=default)
elif record_type == "float":
return Float(default=default)
elif record_type == "double":
<|code_end|>
, predict the next line using imports from the current file:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context including class names, function names, and sometimes code from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | return Double(default=default) |
Next line prediction: <|code_start|> return Sequence(Alternative(symbols, labels, default=default), Union())
elif record_type == "map":
repeat = Repeater(
MapEnd(),
# ItemEnd(), # TODO: Maybe need this?
self._parse(schema["values"]),
MapKeyMarker(),
String(),
)
return Sequence(repeat, MapStart(default=default))
elif record_type == "array":
repeat = Repeater(
ArrayEnd(),
ItemEnd(),
self._parse(schema["items"]),
)
return Sequence(repeat, ArrayStart(default=default))
elif record_type == "enum":
return Sequence(EnumLabels(schema["symbols"]), Enum(default=default))
elif record_type == "null":
return Null()
elif record_type == "boolean":
return Boolean(default=default)
elif record_type == "string":
return String(default=default)
elif record_type == "bytes":
<|code_end|>
. Use current file imports:
(from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type)
and context including class names, function names, or small code snippets from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | return Bytes(default=default) |
Using the snippet: <|code_start|> production = []
production.append(RecordStart(default=default))
for field in schema["fields"]:
production.insert(0, FieldStart(field["name"]))
production.insert(
0, self._parse(field["type"], field.get("default", NO_DEFAULT))
)
production.insert(0, FieldEnd())
production.insert(0, RecordEnd())
seq = Sequence(*production)
return seq
elif record_type == "union":
symbols = []
labels = []
for candidate_schema in schema:
symbols.append(self._parse(candidate_schema))
if isinstance(candidate_schema, dict):
labels.append(
candidate_schema.get("name", candidate_schema.get("type"))
)
else:
labels.append(candidate_schema)
return Sequence(Alternative(symbols, labels, default=default), Union())
elif record_type == "map":
repeat = Repeater(
<|code_end|>
, determine the next line of code. You have imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context (class names, function names, or code) available:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | MapEnd(), |
Given snippet: <|code_start|> 0, self._parse(field["type"], field.get("default", NO_DEFAULT))
)
production.insert(0, FieldEnd())
production.insert(0, RecordEnd())
seq = Sequence(*production)
return seq
elif record_type == "union":
symbols = []
labels = []
for candidate_schema in schema:
symbols.append(self._parse(candidate_schema))
if isinstance(candidate_schema, dict):
labels.append(
candidate_schema.get("name", candidate_schema.get("type"))
)
else:
labels.append(candidate_schema)
return Sequence(Alternative(symbols, labels, default=default), Union())
elif record_type == "map":
repeat = Repeater(
MapEnd(),
# ItemEnd(), # TODO: Maybe need this?
self._parse(schema["values"]),
MapKeyMarker(),
String(),
)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
which might include code, classes, or functions. Output only the next line. | return Sequence(repeat, MapStart(default=default)) |
Predict the next line after this snippet: <|code_start|> for field in schema["fields"]:
production.insert(0, FieldStart(field["name"]))
production.insert(
0, self._parse(field["type"], field.get("default", NO_DEFAULT))
)
production.insert(0, FieldEnd())
production.insert(0, RecordEnd())
seq = Sequence(*production)
return seq
elif record_type == "union":
symbols = []
labels = []
for candidate_schema in schema:
symbols.append(self._parse(candidate_schema))
if isinstance(candidate_schema, dict):
labels.append(
candidate_schema.get("name", candidate_schema.get("type"))
)
else:
labels.append(candidate_schema)
return Sequence(Alternative(symbols, labels, default=default), Union())
elif record_type == "map":
repeat = Repeater(
MapEnd(),
# ItemEnd(), # TODO: Maybe need this?
self._parse(schema["values"]),
<|code_end|>
using the current file's imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and any relevant context from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | MapKeyMarker(), |
Given the following code snippet before the placeholder: <|code_start|> for candidate_schema in schema:
symbols.append(self._parse(candidate_schema))
if isinstance(candidate_schema, dict):
labels.append(
candidate_schema.get("name", candidate_schema.get("type"))
)
else:
labels.append(candidate_schema)
return Sequence(Alternative(symbols, labels, default=default), Union())
elif record_type == "map":
repeat = Repeater(
MapEnd(),
# ItemEnd(), # TODO: Maybe need this?
self._parse(schema["values"]),
MapKeyMarker(),
String(),
)
return Sequence(repeat, MapStart(default=default))
elif record_type == "array":
repeat = Repeater(
ArrayEnd(),
ItemEnd(),
self._parse(schema["items"]),
)
return Sequence(repeat, ArrayStart(default=default))
elif record_type == "enum":
<|code_end|>
, predict the next line using imports from the current file:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context including class names, function names, and sometimes code from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | return Sequence(EnumLabels(schema["symbols"]), Enum(default=default)) |
Given snippet: <|code_start|> for candidate_schema in schema:
symbols.append(self._parse(candidate_schema))
if isinstance(candidate_schema, dict):
labels.append(
candidate_schema.get("name", candidate_schema.get("type"))
)
else:
labels.append(candidate_schema)
return Sequence(Alternative(symbols, labels, default=default), Union())
elif record_type == "map":
repeat = Repeater(
MapEnd(),
# ItemEnd(), # TODO: Maybe need this?
self._parse(schema["values"]),
MapKeyMarker(),
String(),
)
return Sequence(repeat, MapStart(default=default))
elif record_type == "array":
repeat = Repeater(
ArrayEnd(),
ItemEnd(),
self._parse(schema["items"]),
)
return Sequence(repeat, ArrayStart(default=default))
elif record_type == "enum":
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
which might include code, classes, or functions. Output only the next line. | return Sequence(EnumLabels(schema["symbols"]), Enum(default=default)) |
Predict the next line after this snippet: <|code_start|> return Sequence(repeat, MapStart(default=default))
elif record_type == "array":
repeat = Repeater(
ArrayEnd(),
ItemEnd(),
self._parse(schema["items"]),
)
return Sequence(repeat, ArrayStart(default=default))
elif record_type == "enum":
return Sequence(EnumLabels(schema["symbols"]), Enum(default=default))
elif record_type == "null":
return Null()
elif record_type == "boolean":
return Boolean(default=default)
elif record_type == "string":
return String(default=default)
elif record_type == "bytes":
return Bytes(default=default)
elif record_type == "int":
return Int(default=default)
elif record_type == "long":
return Long(default=default)
elif record_type == "float":
return Float(default=default)
elif record_type == "double":
return Double(default=default)
elif record_type == "fixed":
<|code_end|>
using the current file's imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and any relevant context from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | return Fixed(default=default) |
Based on the snippet: <|code_start|> elif record_type == "union":
symbols = []
labels = []
for candidate_schema in schema:
symbols.append(self._parse(candidate_schema))
if isinstance(candidate_schema, dict):
labels.append(
candidate_schema.get("name", candidate_schema.get("type"))
)
else:
labels.append(candidate_schema)
return Sequence(Alternative(symbols, labels, default=default), Union())
elif record_type == "map":
repeat = Repeater(
MapEnd(),
# ItemEnd(), # TODO: Maybe need this?
self._parse(schema["values"]),
MapKeyMarker(),
String(),
)
return Sequence(repeat, MapStart(default=default))
elif record_type == "array":
repeat = Repeater(
ArrayEnd(),
ItemEnd(),
self._parse(schema["items"]),
)
<|code_end|>
, predict the immediate next line with the help of imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context (classes, functions, sometimes code) from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | return Sequence(repeat, ArrayStart(default=default)) |
Predict the next line for this snippet: <|code_start|>
seq = Sequence(*production)
return seq
elif record_type == "union":
symbols = []
labels = []
for candidate_schema in schema:
symbols.append(self._parse(candidate_schema))
if isinstance(candidate_schema, dict):
labels.append(
candidate_schema.get("name", candidate_schema.get("type"))
)
else:
labels.append(candidate_schema)
return Sequence(Alternative(symbols, labels, default=default), Union())
elif record_type == "map":
repeat = Repeater(
MapEnd(),
# ItemEnd(), # TODO: Maybe need this?
self._parse(schema["values"]),
MapKeyMarker(),
String(),
)
return Sequence(repeat, MapStart(default=default))
elif record_type == "array":
repeat = Repeater(
<|code_end|>
with the help of current file imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
, which may contain function names, class names, or code. Output only the next line. | ArrayEnd(), |
Given the following code snippet before the placeholder: <|code_start|> seq = Sequence(*production)
return seq
elif record_type == "union":
symbols = []
labels = []
for candidate_schema in schema:
symbols.append(self._parse(candidate_schema))
if isinstance(candidate_schema, dict):
labels.append(
candidate_schema.get("name", candidate_schema.get("type"))
)
else:
labels.append(candidate_schema)
return Sequence(Alternative(symbols, labels, default=default), Union())
elif record_type == "map":
repeat = Repeater(
MapEnd(),
# ItemEnd(), # TODO: Maybe need this?
self._parse(schema["values"]),
MapKeyMarker(),
String(),
)
return Sequence(repeat, MapStart(default=default))
elif record_type == "array":
repeat = Repeater(
ArrayEnd(),
<|code_end|>
, predict the next line using imports from the current file:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context including class names, function names, and sometimes code from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | ItemEnd(), |
Based on the snippet: <|code_start|>
class Parser:
def __init__(self, schema, named_schemas, action_function):
self.schema = schema
self.named_schemas = named_schemas
self.action_function = action_function
self.stack = self.parse()
def parse(self):
symbol = self._parse(self.schema)
root = Root([symbol])
root.production.insert(0, root)
return [root, symbol]
<|code_end|>
, predict the immediate next line with the help of imports:
from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type
and context (classes, functions, sometimes code) from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | def _parse(self, schema, default=NO_DEFAULT): |
Next line prediction: <|code_start|>
class Parser:
def __init__(self, schema, named_schemas, action_function):
self.schema = schema
self.named_schemas = named_schemas
self.action_function = action_function
self.stack = self.parse()
def parse(self):
symbol = self._parse(self.schema)
root = Root([symbol])
root.production.insert(0, root)
return [root, symbol]
def _parse(self, schema, default=NO_DEFAULT):
<|code_end|>
. Use current file imports:
(from .symbols import (
Root,
Terminal,
Boolean,
Sequence,
Repeater,
Action,
RecordStart,
RecordEnd,
FieldStart,
FieldEnd,
Int,
Null,
String,
Alternative,
Union,
Long,
Float,
Double,
Bytes,
MapEnd,
MapStart,
MapKeyMarker,
Enum,
EnumLabels,
Fixed,
ArrayStart,
ArrayEnd,
ItemEnd,
NO_DEFAULT,
)
from ..schema import extract_record_type)
and context including class names, function names, or small code snippets from other files:
# Path: fastavro/io/symbols.py
# class _NoDefault:
# class Symbol:
# class Root(Symbol):
# class Terminal(Symbol):
# class Sequence(Symbol):
# class Repeater(Symbol):
# class Alternative(Symbol):
# class Action(Symbol):
# class EnumLabels(Action):
# class UnionEnd(Action):
# class RecordStart(Action):
# class RecordEnd(Action):
# class FieldStart(Action):
# class FieldEnd(Action):
# NO_DEFAULT = _NoDefault()
# def __init__(self, production=None, default=NO_DEFAULT):
# def get_default(self):
# def __eq__(self, other):
# def __ne__(self, other):
# def __init__(self, *symbols, default=NO_DEFAULT):
# def __init__(self, end, *symbols, default=NO_DEFAULT):
# def __init__(self, symbols, labels, default=NO_DEFAULT):
# def get_symbol(self, index):
# def get_label(self, index):
# def __init__(self, labels):
# def __init__(self, field_name):
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | record_type = extract_record_type(schema) |
Given the following code snippet before the placeholder: <|code_start|> return tmp.getvalue()
def prepare_uuid(data, schema):
"""Converts uuid.UUID to
string formatted UUID xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
"""
if isinstance(data, uuid.UUID):
return str(data)
else:
return data
def prepare_time_millis(data, schema):
"""Convert datetime.time to int timestamp with milliseconds"""
if isinstance(data, datetime.time):
return int(
data.hour * MLS_PER_HOUR
+ data.minute * MLS_PER_MINUTE
+ data.second * MLS_PER_SECOND
+ int(data.microsecond / 1000)
)
else:
return data
def prepare_time_micros(data, schema):
"""Convert datetime.time to int timestamp with microseconds"""
if isinstance(data, datetime.time):
return int(
<|code_end|>
, predict the next line using imports from the current file:
import datetime
import decimal
import os
import time
import uuid
from io import BytesIO
from typing import Dict, Union
from .const import (
MCS_PER_HOUR,
MCS_PER_MINUTE,
MCS_PER_SECOND,
MLS_PER_HOUR,
MLS_PER_MINUTE,
MLS_PER_SECOND,
DAYS_SHIFT,
)
and context including class names, function names, and sometimes code from other files:
# Path: fastavro/const.py
# MCS_PER_HOUR = MCS_PER_MINUTE * 60
#
# MCS_PER_MINUTE = MCS_PER_SECOND * 60
#
# MCS_PER_SECOND = 1000000
#
# MLS_PER_HOUR = MLS_PER_MINUTE * 60
#
# MLS_PER_MINUTE = MLS_PER_SECOND * 60
#
# MLS_PER_SECOND = 1000
#
# DAYS_SHIFT = datetime.date(1970, 1, 1).toordinal()
. Output only the next line. | data.hour * MCS_PER_HOUR |
Here is a snippet: <|code_start|>
def prepare_uuid(data, schema):
"""Converts uuid.UUID to
string formatted UUID xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
"""
if isinstance(data, uuid.UUID):
return str(data)
else:
return data
def prepare_time_millis(data, schema):
"""Convert datetime.time to int timestamp with milliseconds"""
if isinstance(data, datetime.time):
return int(
data.hour * MLS_PER_HOUR
+ data.minute * MLS_PER_MINUTE
+ data.second * MLS_PER_SECOND
+ int(data.microsecond / 1000)
)
else:
return data
def prepare_time_micros(data, schema):
"""Convert datetime.time to int timestamp with microseconds"""
if isinstance(data, datetime.time):
return int(
data.hour * MCS_PER_HOUR
<|code_end|>
. Write the next line using the current file imports:
import datetime
import decimal
import os
import time
import uuid
from io import BytesIO
from typing import Dict, Union
from .const import (
MCS_PER_HOUR,
MCS_PER_MINUTE,
MCS_PER_SECOND,
MLS_PER_HOUR,
MLS_PER_MINUTE,
MLS_PER_SECOND,
DAYS_SHIFT,
)
and context from other files:
# Path: fastavro/const.py
# MCS_PER_HOUR = MCS_PER_MINUTE * 60
#
# MCS_PER_MINUTE = MCS_PER_SECOND * 60
#
# MCS_PER_SECOND = 1000000
#
# MLS_PER_HOUR = MLS_PER_MINUTE * 60
#
# MLS_PER_MINUTE = MLS_PER_SECOND * 60
#
# MLS_PER_SECOND = 1000
#
# DAYS_SHIFT = datetime.date(1970, 1, 1).toordinal()
, which may include functions, classes, or code. Output only the next line. | + data.minute * MCS_PER_MINUTE |
Continue the code snippet: <|code_start|> )
else:
return data
def prepare_local_timestamp_millis(
data: Union[datetime.datetime, int], schema: Dict
) -> int:
"""Converts datetime.datetime object to int timestamp with milliseconds.
The local-timestamp-millis logical type represents a timestamp in a local
timezone, regardless of what specific time zone is considered local, with a
precision of one millisecond.
"""
if isinstance(data, datetime.datetime):
delta = data.replace(tzinfo=datetime.timezone.utc) - epoch
return (delta.days * 24 * 3600 + delta.seconds) * MLS_PER_SECOND + int(
delta.microseconds / 1000
)
else:
return data
def prepare_timestamp_micros(data, schema):
"""Converts datetime.datetime to int timestamp with microseconds"""
if isinstance(data, datetime.datetime):
if data.tzinfo is not None:
delta = data - epoch
return (
delta.days * 24 * 3600 + delta.seconds
<|code_end|>
. Use current file imports:
import datetime
import decimal
import os
import time
import uuid
from io import BytesIO
from typing import Dict, Union
from .const import (
MCS_PER_HOUR,
MCS_PER_MINUTE,
MCS_PER_SECOND,
MLS_PER_HOUR,
MLS_PER_MINUTE,
MLS_PER_SECOND,
DAYS_SHIFT,
)
and context (classes, functions, or code) from other files:
# Path: fastavro/const.py
# MCS_PER_HOUR = MCS_PER_MINUTE * 60
#
# MCS_PER_MINUTE = MCS_PER_SECOND * 60
#
# MCS_PER_SECOND = 1000000
#
# MLS_PER_HOUR = MLS_PER_MINUTE * 60
#
# MLS_PER_MINUTE = MLS_PER_SECOND * 60
#
# MLS_PER_SECOND = 1000
#
# DAYS_SHIFT = datetime.date(1970, 1, 1).toordinal()
. Output only the next line. | ) * MCS_PER_SECOND + delta.microseconds |
Based on the snippet: <|code_start|> if sign:
unscaled_datum = (1 << bits_req) - unscaled_datum
unscaled_datum = mask | unscaled_datum
for index in range(size - 1, -1, -1):
bits_to_write = unscaled_datum >> (8 * index)
tmp.write(bytes([bits_to_write & 0xFF]))
else:
for i in range(offset_bits // 8):
tmp.write(bytes([0]))
for index in range(bytes_req - 1, -1, -1):
bits_to_write = unscaled_datum >> (8 * index)
tmp.write(bytes([bits_to_write & 0xFF]))
return tmp.getvalue()
def prepare_uuid(data, schema):
"""Converts uuid.UUID to
string formatted UUID xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
"""
if isinstance(data, uuid.UUID):
return str(data)
else:
return data
def prepare_time_millis(data, schema):
"""Convert datetime.time to int timestamp with milliseconds"""
if isinstance(data, datetime.time):
return int(
<|code_end|>
, predict the immediate next line with the help of imports:
import datetime
import decimal
import os
import time
import uuid
from io import BytesIO
from typing import Dict, Union
from .const import (
MCS_PER_HOUR,
MCS_PER_MINUTE,
MCS_PER_SECOND,
MLS_PER_HOUR,
MLS_PER_MINUTE,
MLS_PER_SECOND,
DAYS_SHIFT,
)
and context (classes, functions, sometimes code) from other files:
# Path: fastavro/const.py
# MCS_PER_HOUR = MCS_PER_MINUTE * 60
#
# MCS_PER_MINUTE = MCS_PER_SECOND * 60
#
# MCS_PER_SECOND = 1000000
#
# MLS_PER_HOUR = MLS_PER_MINUTE * 60
#
# MLS_PER_MINUTE = MLS_PER_SECOND * 60
#
# MLS_PER_SECOND = 1000
#
# DAYS_SHIFT = datetime.date(1970, 1, 1).toordinal()
. Output only the next line. | data.hour * MLS_PER_HOUR |
Given the code snippet: <|code_start|> unscaled_datum = (1 << bits_req) - unscaled_datum
unscaled_datum = mask | unscaled_datum
for index in range(size - 1, -1, -1):
bits_to_write = unscaled_datum >> (8 * index)
tmp.write(bytes([bits_to_write & 0xFF]))
else:
for i in range(offset_bits // 8):
tmp.write(bytes([0]))
for index in range(bytes_req - 1, -1, -1):
bits_to_write = unscaled_datum >> (8 * index)
tmp.write(bytes([bits_to_write & 0xFF]))
return tmp.getvalue()
def prepare_uuid(data, schema):
"""Converts uuid.UUID to
string formatted UUID xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
"""
if isinstance(data, uuid.UUID):
return str(data)
else:
return data
def prepare_time_millis(data, schema):
"""Convert datetime.time to int timestamp with milliseconds"""
if isinstance(data, datetime.time):
return int(
data.hour * MLS_PER_HOUR
<|code_end|>
, generate the next line using the imports in this file:
import datetime
import decimal
import os
import time
import uuid
from io import BytesIO
from typing import Dict, Union
from .const import (
MCS_PER_HOUR,
MCS_PER_MINUTE,
MCS_PER_SECOND,
MLS_PER_HOUR,
MLS_PER_MINUTE,
MLS_PER_SECOND,
DAYS_SHIFT,
)
and context (functions, classes, or occasionally code) from other files:
# Path: fastavro/const.py
# MCS_PER_HOUR = MCS_PER_MINUTE * 60
#
# MCS_PER_MINUTE = MCS_PER_SECOND * 60
#
# MCS_PER_SECOND = 1000000
#
# MLS_PER_HOUR = MLS_PER_MINUTE * 60
#
# MLS_PER_MINUTE = MLS_PER_SECOND * 60
#
# MLS_PER_SECOND = 1000
#
# DAYS_SHIFT = datetime.date(1970, 1, 1).toordinal()
. Output only the next line. | + data.minute * MLS_PER_MINUTE |
Next line prediction: <|code_start|># cython: auto_cpdef=True
is_windows = os.name == "nt"
epoch = datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc)
epoch_naive = datetime.datetime(1970, 1, 1)
def prepare_timestamp_millis(data, schema):
"""Converts datetime.datetime object to int timestamp with milliseconds"""
if isinstance(data, datetime.datetime):
if data.tzinfo is not None:
delta = data - epoch
<|code_end|>
. Use current file imports:
(import datetime
import decimal
import os
import time
import uuid
from io import BytesIO
from typing import Dict, Union
from .const import (
MCS_PER_HOUR,
MCS_PER_MINUTE,
MCS_PER_SECOND,
MLS_PER_HOUR,
MLS_PER_MINUTE,
MLS_PER_SECOND,
DAYS_SHIFT,
))
and context including class names, function names, or small code snippets from other files:
# Path: fastavro/const.py
# MCS_PER_HOUR = MCS_PER_MINUTE * 60
#
# MCS_PER_MINUTE = MCS_PER_SECOND * 60
#
# MCS_PER_SECOND = 1000000
#
# MLS_PER_HOUR = MLS_PER_MINUTE * 60
#
# MLS_PER_MINUTE = MLS_PER_SECOND * 60
#
# MLS_PER_SECOND = 1000
#
# DAYS_SHIFT = datetime.date(1970, 1, 1).toordinal()
. Output only the next line. | return (delta.days * 24 * 3600 + delta.seconds) * MLS_PER_SECOND + int( |
Given the code snippet: <|code_start|> ) * MCS_PER_SECOND + delta.microseconds
else:
return (
int(time.mktime(data.timetuple())) * MCS_PER_SECOND + data.microsecond
)
else:
return data
def prepare_local_timestamp_micros(
data: Union[datetime.datetime, int], schema: Dict
) -> int:
"""Converts datetime.datetime to int timestamp with microseconds
The local-timestamp-micros logical type represents a timestamp in a local
timezone, regardless of what specific time zone is considered local, with a
precision of one microsecond.
"""
if isinstance(data, datetime.datetime):
delta = data.replace(tzinfo=datetime.timezone.utc) - epoch
return (
delta.days * 24 * 3600 + delta.seconds
) * MCS_PER_SECOND + delta.microseconds
else:
return data
def prepare_date(data, schema):
"""Converts datetime.date to int timestamp"""
if isinstance(data, datetime.date):
<|code_end|>
, generate the next line using the imports in this file:
import datetime
import decimal
import os
import time
import uuid
from io import BytesIO
from typing import Dict, Union
from .const import (
MCS_PER_HOUR,
MCS_PER_MINUTE,
MCS_PER_SECOND,
MLS_PER_HOUR,
MLS_PER_MINUTE,
MLS_PER_SECOND,
DAYS_SHIFT,
)
and context (functions, classes, or occasionally code) from other files:
# Path: fastavro/const.py
# MCS_PER_HOUR = MCS_PER_MINUTE * 60
#
# MCS_PER_MINUTE = MCS_PER_SECOND * 60
#
# MCS_PER_SECOND = 1000000
#
# MLS_PER_HOUR = MLS_PER_MINUTE * 60
#
# MLS_PER_MINUTE = MLS_PER_SECOND * 60
#
# MLS_PER_SECOND = 1000
#
# DAYS_SHIFT = datetime.date(1970, 1, 1).toordinal()
. Output only the next line. | return data.toordinal() - DAYS_SHIFT |
Based on the snippet: <|code_start|> "namespace": "namespace",
"type": "fixed",
"size": 8,
"logicalType": "decimal",
"precision": 18,
"scale": 6,
}
def test_fixed_decimal_binary():
binary = serialize(schema_fixed_decimal_leftmost, b"\xFF\xFF\xFF\xFF\xFF\xd5F\x80")
data2 = deserialize(schema_fixed_decimal_leftmost, binary)
assert Decimal("-2.80") == data2
def test_clean_json_list():
values = [
datetime.datetime.now(),
datetime.date.today(),
uuid4(),
Decimal("1.23"),
bytes(b"\x00\x01\x61\xff"),
]
str_values = [
values[0].isoformat(),
values[1].isoformat(),
str(values[2]),
str(values[3]),
values[4].decode("iso-8859-1"),
]
<|code_end|>
, predict the immediate next line with the help of imports:
import fastavro
import json
import pytest
import datetime
import sys
import os
import numpy as np
import pandas as pd
from fastavro.__main__ import CleanJSONEncoder
from decimal import Decimal
from io import BytesIO
from uuid import uuid4
from datetime import timezone, timedelta
from .conftest import assert_naive_datetime_equal_to_tz_datetime
and context (classes, functions, sometimes code) from other files:
# Path: fastavro/__main__.py
# class CleanJSONEncoder(json.JSONEncoder):
# def default(self, obj):
# if isinstance(obj, (datetime.date, datetime.datetime)):
# return obj.isoformat()
# elif isinstance(obj, (Decimal, UUID)):
# return str(obj)
# elif isinstance(obj, bytes):
# return obj.decode("iso-8859-1")
# else:
# return json.JSONEncoder.default(self, obj)
#
# Path: tests/conftest.py
# def assert_naive_datetime_equal_to_tz_datetime(naive_datetime, tz_datetime):
# # mktime appears to ignore microseconds, so do this manually
# microseconds = int(time.mktime(naive_datetime.timetuple())) * 1000 * 1000
# microseconds += naive_datetime.microsecond
# aware_datetime = datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(
# microseconds=microseconds
# )
# assert aware_datetime == tz_datetime
. Output only the next line. | assert json.dumps(values, cls=CleanJSONEncoder) == json.dumps(str_values) |
Given snippet: <|code_start|>}
def serialize(schema, data):
bytes_writer = BytesIO()
fastavro.schemaless_writer(bytes_writer, schema, data)
return bytes_writer.getvalue()
def deserialize(schema, binary):
bytes_writer = BytesIO()
bytes_writer.write(binary)
bytes_writer.seek(0)
res = fastavro.schemaless_reader(bytes_writer, schema)
return res
def test_logical_types():
data1 = {
"date": datetime.date.today(),
"timestamp-millis": datetime.datetime.now(),
"timestamp-micros": datetime.datetime.now(),
"uuid": uuid4(),
"time-millis": datetime.datetime.now().time(),
"time-micros": datetime.datetime.now().time(),
}
binary = serialize(schema, data1)
data2 = deserialize(schema, binary)
assert data1["date"] == data2["date"]
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import fastavro
import json
import pytest
import datetime
import sys
import os
import numpy as np
import pandas as pd
from fastavro.__main__ import CleanJSONEncoder
from decimal import Decimal
from io import BytesIO
from uuid import uuid4
from datetime import timezone, timedelta
from .conftest import assert_naive_datetime_equal_to_tz_datetime
and context:
# Path: fastavro/__main__.py
# class CleanJSONEncoder(json.JSONEncoder):
# def default(self, obj):
# if isinstance(obj, (datetime.date, datetime.datetime)):
# return obj.isoformat()
# elif isinstance(obj, (Decimal, UUID)):
# return str(obj)
# elif isinstance(obj, bytes):
# return obj.decode("iso-8859-1")
# else:
# return json.JSONEncoder.default(self, obj)
#
# Path: tests/conftest.py
# def assert_naive_datetime_equal_to_tz_datetime(naive_datetime, tz_datetime):
# # mktime appears to ignore microseconds, so do this manually
# microseconds = int(time.mktime(naive_datetime.timetuple())) * 1000 * 1000
# microseconds += naive_datetime.microsecond
# aware_datetime = datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(
# microseconds=microseconds
# )
# assert aware_datetime == tz_datetime
which might include code, classes, or functions. Output only the next line. | assert_naive_datetime_equal_to_tz_datetime( |
Continue the code snippet: <|code_start|>
class FlatDictRepository(AbstractSchemaRepository):
def __init__(self, path):
self.path = path
self.file_ext = "avsc"
def load(self, name):
file_path = path.join(self.path, f"{name}.{self.file_ext}")
try:
with open(file_path) as schema_file:
return json.load(schema_file)
except IOError as error:
<|code_end|>
. Use current file imports:
import json
from os import path
from .base import AbstractSchemaRepository, SchemaRepositoryError
and context (classes, functions, or code) from other files:
# Path: fastavro/repository/base.py
# class AbstractSchemaRepository(ABC):
# @abstractmethod
# def load(self, name):
# pass
#
# class SchemaRepositoryError(Exception):
# pass
. Output only the next line. | raise SchemaRepositoryError( |
Next line prediction: <|code_start|>
def test_appendable_raises_valuerror(tmpdir):
"""_is_appendable() raises ValueError when file is only 'a' mode."""
test_file = str(tmpdir.join("test.avro"))
with open(test_file, "a") as new_file:
new_file.write("this phrase forwards cursor position beyond zero")
with pytest.raises(ValueError, match=r"you must use the 'a\+' mode"):
<|code_end|>
. Use current file imports:
(import sys
import pytest
from fastavro._write_common import _is_appendable)
and context including class names, function names, or small code snippets from other files:
# Path: fastavro/_write_common.py
# def _is_appendable(file_like):
# if file_like.seekable() and file_like.tell() != 0:
# if "<stdout>" == getattr(file_like, "name", ""):
# # In OSX, sys.stdout is seekable and has a non-zero tell() but
# # we wouldn't want to append to a stdout. In the python REPL,
# # sys.stdout is named `<stdout>`
# return False
# if file_like.readable():
# return True
# else:
# raise ValueError(
# "When appending to an avro file you must use the "
# + "'a+' mode, not just 'a'"
# )
# else:
# return False
. Output only the next line. | _is_appendable(new_file) |
Predict the next line after this snippet: <|code_start|> load_schema_dir = join(abspath(dirname(__file__)), "load_schema_test_14")
schema_path = join(load_schema_dir, "A.avsc")
loaded_schema = fastavro.schema.load_schema(schema_path, _write_hint=False)
expected_schema = "string"
assert loaded_schema == expected_schema
def test_load_schema_union_names():
"""https://github.com/fastavro/fastavro/issues/527"""
load_schema_dir = join(abspath(dirname(__file__)), "load_schema_test_15")
schema_path = join(load_schema_dir, "A.avsc")
loaded_schema = fastavro.schema.load_schema(schema_path, _write_hint=False)
expected_schema = [
{
"name": "B",
"type": "record",
"fields": [{"name": "foo", "type": "string"}],
},
{
"name": "C",
"type": "record",
"fields": [{"name": "bar", "type": "string"}],
},
]
assert loaded_schema == expected_schema
def test_load_schema_accepts_custom_repository():
<|code_end|>
using the current file's imports:
from os.path import join, abspath, dirname
from fastavro.repository import AbstractSchemaRepository
from fastavro.schema import (
SchemaParseException,
UnknownType,
parse_schema,
fullname,
expand_schema,
)
import pytest
import fastavro
and any relevant context from other files:
# Path: fastavro/repository/base.py
# class AbstractSchemaRepository(ABC):
# @abstractmethod
# def load(self, name):
# pass
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | class LocalSchemaRepository(AbstractSchemaRepository): |
Given snippet: <|code_start|>
with pytest.raises(SchemaParseException):
fastavro.parse_schema(fixed_schema)
enum_schema = {"type": "enum", "symbols": ["FOO"]}
with pytest.raises(SchemaParseException):
fastavro.parse_schema(enum_schema)
# Should parse with name
for schema in (record_schema, error_schema, fixed_schema, enum_schema):
schema["name"] = "test_named_types_have_names"
fastavro.parse_schema(schema)
def test_parse_schema():
schema = {
"type": "record",
"name": "test_parse_schema",
"fields": [{"name": "field", "type": "string"}],
}
parsed_schema = parse_schema(schema)
assert "__fastavro_parsed" in parsed_schema
parsed_schema_again = parse_schema(parsed_schema)
assert parsed_schema_again == parsed_schema
def test_unknown_type():
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from os.path import join, abspath, dirname
from fastavro.repository import AbstractSchemaRepository
from fastavro.schema import (
SchemaParseException,
UnknownType,
parse_schema,
fullname,
expand_schema,
)
import pytest
import fastavro
and context:
# Path: fastavro/repository/base.py
# class AbstractSchemaRepository(ABC):
# @abstractmethod
# def load(self, name):
# pass
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
which might include code, classes, or functions. Output only the next line. | with pytest.raises(UnknownType): |
Using the snippet: <|code_start|>
def test_named_types_have_names():
record_schema = {"type": "record", "fields": [{"name": "field", "type": "string"}]}
with pytest.raises(SchemaParseException):
<|code_end|>
, determine the next line of code. You have imports:
from os.path import join, abspath, dirname
from fastavro.repository import AbstractSchemaRepository
from fastavro.schema import (
SchemaParseException,
UnknownType,
parse_schema,
fullname,
expand_schema,
)
import pytest
import fastavro
and context (class names, function names, or code) available:
# Path: fastavro/repository/base.py
# class AbstractSchemaRepository(ABC):
# @abstractmethod
# def load(self, name):
# pass
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | fastavro.parse_schema(record_schema) |
Next line prediction: <|code_start|> },
{
"name": "field2",
"type": {"type": "fixed", "name": "ThatName", "size": 8},
},
],
}
with pytest.raises(SchemaParseException, match="redefined named type: ThatName"):
parse_schema(schema)
def test_doc_left_in_parse_schema():
schema = {
"type": "record",
"name": "test_doc_left_in_parse_schema",
"doc": "blah",
"fields": [{"name": "field1", "type": "string", "default": ""}],
}
assert schema == parse_schema(schema, _write_hint=False)
def test_schema_fullname_api():
schema = {
"type": "record",
"namespace": "namespace",
"name": "test_schema_fullname_api",
"fields": [],
}
<|code_end|>
. Use current file imports:
(from os.path import join, abspath, dirname
from fastavro.repository import AbstractSchemaRepository
from fastavro.schema import (
SchemaParseException,
UnknownType,
parse_schema,
fullname,
expand_schema,
)
import pytest
import fastavro)
and context including class names, function names, or small code snippets from other files:
# Path: fastavro/repository/base.py
# class AbstractSchemaRepository(ABC):
# @abstractmethod
# def load(self, name):
# pass
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | assert fullname(schema) == "namespace.test_schema_fullname_api" |
Continue the code snippet: <|code_start|> "name": "Dependency",
"namespace": "com.namespace.dependencies",
"type": "record",
"fields": [{"name": "sub_field_1", "type": "string"}],
}
outer_schema = {
"name": "MasterSchema",
"namespace": "com.namespace.master",
"type": "record",
"fields": [
{"name": "field_1", "type": "com.namespace.dependencies.Dependency"}
],
}
combined = {
"name": "com.namespace.master.MasterSchema",
"type": "record",
"fields": [
{
"name": "field_1",
"type": {
"name": "com.namespace.dependencies.Dependency",
"type": "record",
"fields": [{"name": "sub_field_1", "type": "string"}],
},
}
],
}
<|code_end|>
. Use current file imports:
from os.path import join, abspath, dirname
from fastavro.repository import AbstractSchemaRepository
from fastavro.schema import (
SchemaParseException,
UnknownType,
parse_schema,
fullname,
expand_schema,
)
import pytest
import fastavro
and context (classes, functions, or code) from other files:
# Path: fastavro/repository/base.py
# class AbstractSchemaRepository(ABC):
# @abstractmethod
# def load(self, name):
# pass
#
# Path: fastavro/schema.py
# FINGERPRINT_ALGORITHMS = _schema.FINGERPRINT_ALGORITHMS
. Output only the next line. | parsed = expand_schema([sub_schema, outer_schema]) |
Predict the next line after this snippet: <|code_start|>
def deserialize(schema, binary):
bytes_writer = BytesIO()
bytes_writer.write(binary)
bytes_writer.seek(0)
res = fastavro.schemaless_reader(bytes_writer, schema)
return res
def test_complex_schema():
data1 = {
"union_uuid": uuid4(),
"array_string": ["a", "b", "c"],
"multi_union_time": datetime.datetime.now(),
"array_bytes_decimal": [Decimal("123.456")],
"array_fixed_decimal": [Decimal("123.456")],
"array_record": [{"f1": "1", "f2": Decimal("123.456")}],
}
binary = serialize(schema, data1)
data2 = deserialize(schema, binary)
assert len(data1) == len(data2)
for field in [
"array_string",
"array_bytes_decimal",
"array_fixed_decimal",
"array_record",
]:
assert data1[field] == data2[field]
<|code_end|>
using the current file's imports:
import array
import datetime
import fastavro
from decimal import Decimal
from io import BytesIO
from uuid import uuid4
from .conftest import assert_naive_datetime_equal_to_tz_datetime
and any relevant context from other files:
# Path: tests/conftest.py
# def assert_naive_datetime_equal_to_tz_datetime(naive_datetime, tz_datetime):
# # mktime appears to ignore microseconds, so do this manually
# microseconds = int(time.mktime(naive_datetime.timetuple())) * 1000 * 1000
# microseconds += naive_datetime.microsecond
# aware_datetime = datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(
# microseconds=microseconds
# )
# assert aware_datetime == tz_datetime
. Output only the next line. | assert_naive_datetime_equal_to_tz_datetime( |
Predict the next line for this snippet: <|code_start|>
def test_load_returns_parsed_value():
repo_dir = join(abspath(dirname(__file__)), "flat_dict_test")
repo = FlatDictRepository(repo_dir)
result = repo.load("Valid")
expected = {
"name": "Valid",
"type": "record",
"fields": [{"name": "foo", "type": "string"}],
}
assert expected == result
def test_load_raises_error_if_file_does_not_exist():
repo_dir = join(abspath(dirname(__file__)), "flat_dict_test")
repo = FlatDictRepository(repo_dir)
<|code_end|>
with the help of current file imports:
from os.path import join, abspath, dirname
from fastavro.repository.base import SchemaRepositoryError
from fastavro.repository.flat_dict import FlatDictRepository
import pytest
and context from other files:
# Path: fastavro/repository/base.py
# class SchemaRepositoryError(Exception):
# pass
#
# Path: fastavro/repository/flat_dict.py
# class FlatDictRepository(AbstractSchemaRepository):
# def __init__(self, path):
# self.path = path
# self.file_ext = "avsc"
#
# def load(self, name):
# file_path = path.join(self.path, f"{name}.{self.file_ext}")
# try:
# with open(file_path) as schema_file:
# return json.load(schema_file)
# except IOError as error:
# raise SchemaRepositoryError(
# f"Failed to load '{name}' schema",
# ) from error
# except json.decoder.JSONDecodeError as error:
# raise SchemaRepositoryError(
# f"Failed to parse '{name}' schema",
# ) from error
, which may contain function names, class names, or code. Output only the next line. | with pytest.raises(SchemaRepositoryError) as err: |
Here is a snippet: <|code_start|>
def test_timestamp_millis_tz_input(timestamp_data, read_data):
original = timestamp_data["timestamp-millis"]
assert original.tzinfo is not None
read = read_data["timestamp-millis"]
assert read.tzinfo is not None
assert original == read
read_in_test_tz = read.astimezone(tst)
assert original == read_in_test_tz
def test_timestamp_micros_naive_input(timestamp_data_naive, read_data_naive):
original = timestamp_data_naive["timestamp-micros"]
assert original.tzinfo is None
read = read_data_naive["timestamp-micros"]
assert read.tzinfo is not None
assert_naive_datetime_equal_to_tz_datetime(original, read)
def test_timestamp_millis_naive_input(timestamp_data_naive, read_data_naive):
original = timestamp_data_naive["timestamp-millis"]
assert original.tzinfo is None
read = read_data_naive["timestamp-millis"]
assert read.tzinfo is not None
assert_naive_datetime_equal_to_tz_datetime(original, read)
def test_prepare_timestamp_micros():
# seconds from epoch == 1234567890
reference_time = datetime.datetime(2009, 2, 13, 23, 31, 30, tzinfo=timezone.utc)
<|code_end|>
. Write the next line using the current file imports:
import datetime
import fastavro
import pytest
from io import BytesIO
from fastavro.const import MCS_PER_SECOND, MLS_PER_SECOND
from fastavro._logical_writers_py import prepare_timestamp_micros
from fastavro._logical_writers_py import prepare_timestamp_millis
from .conftest import assert_naive_datetime_equal_to_tz_datetime
from datetime import timezone
and context from other files:
# Path: fastavro/const.py
# MCS_PER_SECOND = 1000000
#
# MLS_PER_SECOND = 1000
#
# Path: fastavro/_logical_writers_py.py
# def prepare_timestamp_micros(data, schema):
# """Converts datetime.datetime to int timestamp with microseconds"""
# if isinstance(data, datetime.datetime):
# if data.tzinfo is not None:
# delta = data - epoch
# return (
# delta.days * 24 * 3600 + delta.seconds
# ) * MCS_PER_SECOND + delta.microseconds
#
# # On Windows, mktime does not support pre-epoch, see e.g.
# # https://stackoverflow.com/questions/2518706/python-mktime-overflow-error
# if is_windows:
# delta = data - epoch_naive
# return (
# delta.days * 24 * 3600 + delta.seconds
# ) * MCS_PER_SECOND + delta.microseconds
# else:
# return (
# int(time.mktime(data.timetuple())) * MCS_PER_SECOND + data.microsecond
# )
# else:
# return data
#
# Path: fastavro/_logical_writers_py.py
# def prepare_timestamp_millis(data, schema):
# """Converts datetime.datetime object to int timestamp with milliseconds"""
# if isinstance(data, datetime.datetime):
# if data.tzinfo is not None:
# delta = data - epoch
# return (delta.days * 24 * 3600 + delta.seconds) * MLS_PER_SECOND + int(
# delta.microseconds / 1000
# )
#
# # On Windows, mktime does not support pre-epoch, see e.g.
# # https://stackoverflow.com/questions/2518706/python-mktime-overflow-error
# if is_windows:
# delta = data - epoch_naive
# return (delta.days * 24 * 3600 + delta.seconds) * MLS_PER_SECOND + int(
# delta.microseconds / 1000
# )
# else:
# return int(time.mktime(data.timetuple())) * MLS_PER_SECOND + int(
# data.microsecond / 1000
# )
# else:
# return data
#
# Path: tests/conftest.py
# def assert_naive_datetime_equal_to_tz_datetime(naive_datetime, tz_datetime):
# # mktime appears to ignore microseconds, so do this manually
# microseconds = int(time.mktime(naive_datetime.timetuple())) * 1000 * 1000
# microseconds += naive_datetime.microsecond
# aware_datetime = datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(
# microseconds=microseconds
# )
# assert aware_datetime == tz_datetime
, which may include functions, classes, or code. Output only the next line. | mcs_from_epoch = 1234567890 * MCS_PER_SECOND |
Predict the next line for this snippet: <|code_start|>def test_timestamp_micros_naive_input(timestamp_data_naive, read_data_naive):
original = timestamp_data_naive["timestamp-micros"]
assert original.tzinfo is None
read = read_data_naive["timestamp-micros"]
assert read.tzinfo is not None
assert_naive_datetime_equal_to_tz_datetime(original, read)
def test_timestamp_millis_naive_input(timestamp_data_naive, read_data_naive):
original = timestamp_data_naive["timestamp-millis"]
assert original.tzinfo is None
read = read_data_naive["timestamp-millis"]
assert read.tzinfo is not None
assert_naive_datetime_equal_to_tz_datetime(original, read)
def test_prepare_timestamp_micros():
# seconds from epoch == 1234567890
reference_time = datetime.datetime(2009, 2, 13, 23, 31, 30, tzinfo=timezone.utc)
mcs_from_epoch = 1234567890 * MCS_PER_SECOND
assert prepare_timestamp_micros(reference_time, schema) == mcs_from_epoch
timestamp_tst = reference_time.astimezone(tst)
assert prepare_timestamp_micros(reference_time, schema) == prepare_timestamp_micros(
timestamp_tst, schema
)
def test_prepare_timestamp_millis():
# seconds from epoch == 1234567890
reference_time = datetime.datetime(2009, 2, 13, 23, 31, 30, tzinfo=timezone.utc)
<|code_end|>
with the help of current file imports:
import datetime
import fastavro
import pytest
from io import BytesIO
from fastavro.const import MCS_PER_SECOND, MLS_PER_SECOND
from fastavro._logical_writers_py import prepare_timestamp_micros
from fastavro._logical_writers_py import prepare_timestamp_millis
from .conftest import assert_naive_datetime_equal_to_tz_datetime
from datetime import timezone
and context from other files:
# Path: fastavro/const.py
# MCS_PER_SECOND = 1000000
#
# MLS_PER_SECOND = 1000
#
# Path: fastavro/_logical_writers_py.py
# def prepare_timestamp_micros(data, schema):
# """Converts datetime.datetime to int timestamp with microseconds"""
# if isinstance(data, datetime.datetime):
# if data.tzinfo is not None:
# delta = data - epoch
# return (
# delta.days * 24 * 3600 + delta.seconds
# ) * MCS_PER_SECOND + delta.microseconds
#
# # On Windows, mktime does not support pre-epoch, see e.g.
# # https://stackoverflow.com/questions/2518706/python-mktime-overflow-error
# if is_windows:
# delta = data - epoch_naive
# return (
# delta.days * 24 * 3600 + delta.seconds
# ) * MCS_PER_SECOND + delta.microseconds
# else:
# return (
# int(time.mktime(data.timetuple())) * MCS_PER_SECOND + data.microsecond
# )
# else:
# return data
#
# Path: fastavro/_logical_writers_py.py
# def prepare_timestamp_millis(data, schema):
# """Converts datetime.datetime object to int timestamp with milliseconds"""
# if isinstance(data, datetime.datetime):
# if data.tzinfo is not None:
# delta = data - epoch
# return (delta.days * 24 * 3600 + delta.seconds) * MLS_PER_SECOND + int(
# delta.microseconds / 1000
# )
#
# # On Windows, mktime does not support pre-epoch, see e.g.
# # https://stackoverflow.com/questions/2518706/python-mktime-overflow-error
# if is_windows:
# delta = data - epoch_naive
# return (delta.days * 24 * 3600 + delta.seconds) * MLS_PER_SECOND + int(
# delta.microseconds / 1000
# )
# else:
# return int(time.mktime(data.timetuple())) * MLS_PER_SECOND + int(
# data.microsecond / 1000
# )
# else:
# return data
#
# Path: tests/conftest.py
# def assert_naive_datetime_equal_to_tz_datetime(naive_datetime, tz_datetime):
# # mktime appears to ignore microseconds, so do this manually
# microseconds = int(time.mktime(naive_datetime.timetuple())) * 1000 * 1000
# microseconds += naive_datetime.microsecond
# aware_datetime = datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(
# microseconds=microseconds
# )
# assert aware_datetime == tz_datetime
, which may contain function names, class names, or code. Output only the next line. | mcs_from_epoch = 1234567890 * MLS_PER_SECOND |
Here is a snippet: <|code_start|>def test_timestamp_millis_tz_input(timestamp_data, read_data):
original = timestamp_data["timestamp-millis"]
assert original.tzinfo is not None
read = read_data["timestamp-millis"]
assert read.tzinfo is not None
assert original == read
read_in_test_tz = read.astimezone(tst)
assert original == read_in_test_tz
def test_timestamp_micros_naive_input(timestamp_data_naive, read_data_naive):
original = timestamp_data_naive["timestamp-micros"]
assert original.tzinfo is None
read = read_data_naive["timestamp-micros"]
assert read.tzinfo is not None
assert_naive_datetime_equal_to_tz_datetime(original, read)
def test_timestamp_millis_naive_input(timestamp_data_naive, read_data_naive):
original = timestamp_data_naive["timestamp-millis"]
assert original.tzinfo is None
read = read_data_naive["timestamp-millis"]
assert read.tzinfo is not None
assert_naive_datetime_equal_to_tz_datetime(original, read)
def test_prepare_timestamp_micros():
# seconds from epoch == 1234567890
reference_time = datetime.datetime(2009, 2, 13, 23, 31, 30, tzinfo=timezone.utc)
mcs_from_epoch = 1234567890 * MCS_PER_SECOND
<|code_end|>
. Write the next line using the current file imports:
import datetime
import fastavro
import pytest
from io import BytesIO
from fastavro.const import MCS_PER_SECOND, MLS_PER_SECOND
from fastavro._logical_writers_py import prepare_timestamp_micros
from fastavro._logical_writers_py import prepare_timestamp_millis
from .conftest import assert_naive_datetime_equal_to_tz_datetime
from datetime import timezone
and context from other files:
# Path: fastavro/const.py
# MCS_PER_SECOND = 1000000
#
# MLS_PER_SECOND = 1000
#
# Path: fastavro/_logical_writers_py.py
# def prepare_timestamp_micros(data, schema):
# """Converts datetime.datetime to int timestamp with microseconds"""
# if isinstance(data, datetime.datetime):
# if data.tzinfo is not None:
# delta = data - epoch
# return (
# delta.days * 24 * 3600 + delta.seconds
# ) * MCS_PER_SECOND + delta.microseconds
#
# # On Windows, mktime does not support pre-epoch, see e.g.
# # https://stackoverflow.com/questions/2518706/python-mktime-overflow-error
# if is_windows:
# delta = data - epoch_naive
# return (
# delta.days * 24 * 3600 + delta.seconds
# ) * MCS_PER_SECOND + delta.microseconds
# else:
# return (
# int(time.mktime(data.timetuple())) * MCS_PER_SECOND + data.microsecond
# )
# else:
# return data
#
# Path: fastavro/_logical_writers_py.py
# def prepare_timestamp_millis(data, schema):
# """Converts datetime.datetime object to int timestamp with milliseconds"""
# if isinstance(data, datetime.datetime):
# if data.tzinfo is not None:
# delta = data - epoch
# return (delta.days * 24 * 3600 + delta.seconds) * MLS_PER_SECOND + int(
# delta.microseconds / 1000
# )
#
# # On Windows, mktime does not support pre-epoch, see e.g.
# # https://stackoverflow.com/questions/2518706/python-mktime-overflow-error
# if is_windows:
# delta = data - epoch_naive
# return (delta.days * 24 * 3600 + delta.seconds) * MLS_PER_SECOND + int(
# delta.microseconds / 1000
# )
# else:
# return int(time.mktime(data.timetuple())) * MLS_PER_SECOND + int(
# data.microsecond / 1000
# )
# else:
# return data
#
# Path: tests/conftest.py
# def assert_naive_datetime_equal_to_tz_datetime(naive_datetime, tz_datetime):
# # mktime appears to ignore microseconds, so do this manually
# microseconds = int(time.mktime(naive_datetime.timetuple())) * 1000 * 1000
# microseconds += naive_datetime.microsecond
# aware_datetime = datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(
# microseconds=microseconds
# )
# assert aware_datetime == tz_datetime
, which may include functions, classes, or code. Output only the next line. | assert prepare_timestamp_micros(reference_time, schema) == mcs_from_epoch |
Predict the next line after this snippet: <|code_start|> original = timestamp_data_naive["timestamp-micros"]
assert original.tzinfo is None
read = read_data_naive["timestamp-micros"]
assert read.tzinfo is not None
assert_naive_datetime_equal_to_tz_datetime(original, read)
def test_timestamp_millis_naive_input(timestamp_data_naive, read_data_naive):
original = timestamp_data_naive["timestamp-millis"]
assert original.tzinfo is None
read = read_data_naive["timestamp-millis"]
assert read.tzinfo is not None
assert_naive_datetime_equal_to_tz_datetime(original, read)
def test_prepare_timestamp_micros():
# seconds from epoch == 1234567890
reference_time = datetime.datetime(2009, 2, 13, 23, 31, 30, tzinfo=timezone.utc)
mcs_from_epoch = 1234567890 * MCS_PER_SECOND
assert prepare_timestamp_micros(reference_time, schema) == mcs_from_epoch
timestamp_tst = reference_time.astimezone(tst)
assert prepare_timestamp_micros(reference_time, schema) == prepare_timestamp_micros(
timestamp_tst, schema
)
def test_prepare_timestamp_millis():
# seconds from epoch == 1234567890
reference_time = datetime.datetime(2009, 2, 13, 23, 31, 30, tzinfo=timezone.utc)
mcs_from_epoch = 1234567890 * MLS_PER_SECOND
<|code_end|>
using the current file's imports:
import datetime
import fastavro
import pytest
from io import BytesIO
from fastavro.const import MCS_PER_SECOND, MLS_PER_SECOND
from fastavro._logical_writers_py import prepare_timestamp_micros
from fastavro._logical_writers_py import prepare_timestamp_millis
from .conftest import assert_naive_datetime_equal_to_tz_datetime
from datetime import timezone
and any relevant context from other files:
# Path: fastavro/const.py
# MCS_PER_SECOND = 1000000
#
# MLS_PER_SECOND = 1000
#
# Path: fastavro/_logical_writers_py.py
# def prepare_timestamp_micros(data, schema):
# """Converts datetime.datetime to int timestamp with microseconds"""
# if isinstance(data, datetime.datetime):
# if data.tzinfo is not None:
# delta = data - epoch
# return (
# delta.days * 24 * 3600 + delta.seconds
# ) * MCS_PER_SECOND + delta.microseconds
#
# # On Windows, mktime does not support pre-epoch, see e.g.
# # https://stackoverflow.com/questions/2518706/python-mktime-overflow-error
# if is_windows:
# delta = data - epoch_naive
# return (
# delta.days * 24 * 3600 + delta.seconds
# ) * MCS_PER_SECOND + delta.microseconds
# else:
# return (
# int(time.mktime(data.timetuple())) * MCS_PER_SECOND + data.microsecond
# )
# else:
# return data
#
# Path: fastavro/_logical_writers_py.py
# def prepare_timestamp_millis(data, schema):
# """Converts datetime.datetime object to int timestamp with milliseconds"""
# if isinstance(data, datetime.datetime):
# if data.tzinfo is not None:
# delta = data - epoch
# return (delta.days * 24 * 3600 + delta.seconds) * MLS_PER_SECOND + int(
# delta.microseconds / 1000
# )
#
# # On Windows, mktime does not support pre-epoch, see e.g.
# # https://stackoverflow.com/questions/2518706/python-mktime-overflow-error
# if is_windows:
# delta = data - epoch_naive
# return (delta.days * 24 * 3600 + delta.seconds) * MLS_PER_SECOND + int(
# delta.microseconds / 1000
# )
# else:
# return int(time.mktime(data.timetuple())) * MLS_PER_SECOND + int(
# data.microsecond / 1000
# )
# else:
# return data
#
# Path: tests/conftest.py
# def assert_naive_datetime_equal_to_tz_datetime(naive_datetime, tz_datetime):
# # mktime appears to ignore microseconds, so do this manually
# microseconds = int(time.mktime(naive_datetime.timetuple())) * 1000 * 1000
# microseconds += naive_datetime.microsecond
# aware_datetime = datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(
# microseconds=microseconds
# )
# assert aware_datetime == tz_datetime
. Output only the next line. | assert prepare_timestamp_millis(reference_time, schema) == mcs_from_epoch |
Given snippet: <|code_start|>def read_data_naive(timestamp_data_naive):
binary = serialize(schema, timestamp_data_naive)
return deserialize(schema, binary)
def test_timestamp_micros_tz_input(timestamp_data, read_data):
original = timestamp_data["timestamp-micros"]
assert original.tzinfo is not None
read = read_data["timestamp-micros"]
assert read.tzinfo is not None
assert original == read
read_in_test_tz = read.astimezone(tst)
assert original == read_in_test_tz
def test_timestamp_millis_tz_input(timestamp_data, read_data):
original = timestamp_data["timestamp-millis"]
assert original.tzinfo is not None
read = read_data["timestamp-millis"]
assert read.tzinfo is not None
assert original == read
read_in_test_tz = read.astimezone(tst)
assert original == read_in_test_tz
def test_timestamp_micros_naive_input(timestamp_data_naive, read_data_naive):
original = timestamp_data_naive["timestamp-micros"]
assert original.tzinfo is None
read = read_data_naive["timestamp-micros"]
assert read.tzinfo is not None
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import datetime
import fastavro
import pytest
from io import BytesIO
from fastavro.const import MCS_PER_SECOND, MLS_PER_SECOND
from fastavro._logical_writers_py import prepare_timestamp_micros
from fastavro._logical_writers_py import prepare_timestamp_millis
from .conftest import assert_naive_datetime_equal_to_tz_datetime
from datetime import timezone
and context:
# Path: fastavro/const.py
# MCS_PER_SECOND = 1000000
#
# MLS_PER_SECOND = 1000
#
# Path: fastavro/_logical_writers_py.py
# def prepare_timestamp_micros(data, schema):
# """Converts datetime.datetime to int timestamp with microseconds"""
# if isinstance(data, datetime.datetime):
# if data.tzinfo is not None:
# delta = data - epoch
# return (
# delta.days * 24 * 3600 + delta.seconds
# ) * MCS_PER_SECOND + delta.microseconds
#
# # On Windows, mktime does not support pre-epoch, see e.g.
# # https://stackoverflow.com/questions/2518706/python-mktime-overflow-error
# if is_windows:
# delta = data - epoch_naive
# return (
# delta.days * 24 * 3600 + delta.seconds
# ) * MCS_PER_SECOND + delta.microseconds
# else:
# return (
# int(time.mktime(data.timetuple())) * MCS_PER_SECOND + data.microsecond
# )
# else:
# return data
#
# Path: fastavro/_logical_writers_py.py
# def prepare_timestamp_millis(data, schema):
# """Converts datetime.datetime object to int timestamp with milliseconds"""
# if isinstance(data, datetime.datetime):
# if data.tzinfo is not None:
# delta = data - epoch
# return (delta.days * 24 * 3600 + delta.seconds) * MLS_PER_SECOND + int(
# delta.microseconds / 1000
# )
#
# # On Windows, mktime does not support pre-epoch, see e.g.
# # https://stackoverflow.com/questions/2518706/python-mktime-overflow-error
# if is_windows:
# delta = data - epoch_naive
# return (delta.days * 24 * 3600 + delta.seconds) * MLS_PER_SECOND + int(
# delta.microseconds / 1000
# )
# else:
# return int(time.mktime(data.timetuple())) * MLS_PER_SECOND + int(
# data.microsecond / 1000
# )
# else:
# return data
#
# Path: tests/conftest.py
# def assert_naive_datetime_equal_to_tz_datetime(naive_datetime, tz_datetime):
# # mktime appears to ignore microseconds, so do this manually
# microseconds = int(time.mktime(naive_datetime.timetuple())) * 1000 * 1000
# microseconds += naive_datetime.microsecond
# aware_datetime = datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(
# microseconds=microseconds
# )
# assert aware_datetime == tz_datetime
which might include code, classes, or functions. Output only the next line. | assert_naive_datetime_equal_to_tz_datetime(original, read) |
Here is a snippet: <|code_start|>sys.path += ["../"]
class test_fluidsynth(unittest.TestCase):
def setUp(self):
<|code_end|>
. Write the next line using the current file imports:
import sys
import unittest
import time
from mingus.midi import fluidsynth
from mingus.containers import *
from mingus.midi.SequencerObserver import SequencerObserver
and context from other files:
# Path: mingus/midi/fluidsynth.py
# class FluidSynthSequencer(Sequencer):
# def init(self):
# def __del__(self):
# def start_audio_output(self, driver=None):
# def load_sound_font(self, sf2):
# def play_event(self, note, channel, velocity):
# def stop_event(self, note, channel):
# def cc_event(self, channel, control, value):
# def instr_event(self, channel, instr, bank):
# def init(sf2, driver = None):
# def play_Note(note, channel = 1, velocity = 100):
# def stop_Note(note, channel = 1):
# def play_NoteContainer(nc, channel = 1, velocity = 100):
# def stop_NoteContainer(nc, channel = 1):
# def play_Bar(bar, channel = 1, bpm = 120):
# def play_Bars(bars, channels, bpm = 120):
# def play_Track(track, channel = 1, bpm = 120):
# def play_Tracks(tracks, channels, bpm = 120):
# def play_Composition(composition, channels = None, bpm = 120):
# def control_change(channel, control, value):
# def set_instrument(channel, midi_instr):
# def stop_everything():
# def modulation(channel, value):
# def pan(channel, value):
# def main_volume(channel, value):
# def set_instrument(channel, instr, bank = 0):
, which may include functions, classes, or code. Output only the next line. | fluidsynth.init("/home/bspaans/workspace/fluidsynth/ChoriumRevA.SF2") |
Using the snippet: <|code_start|> Enter High tom
"""
SF2 = "soundfont.sf2"
# The 'pads' represent places you can hit. These are the topleft coordinates
PAD_PLACEMENT = [(190, 20), (330, 20), (470, 20), (330, 160), # high, mid, low, snare
(190, 300), (20, 20), (470, 160), (20, 160), (20, 300)] # bass, crash, ride, open, close
FADEOUT = 0.125 # coloration fadout time (1 tick = 0.001)
def load_img(name):
"""Load image and return an image object"""
fullname = name
try:
image = pygame.image.load(fullname)
if image.get_alpha() is None:
image= image.convert()
else:
image = image.convert_alpha()
except pygame.error, message:
print "Error: couldn't load image: ", fullname
raise SystemExit, message
return image, image.get_rect()
<|code_end|>
, determine the next line of code. You have imports:
import pygame
from pygame.locals import *
from mingus.containers import *
from mingus.midi import fluidsynth
from os import sys
and context (class names, function names, or code) available:
# Path: mingus/midi/fluidsynth.py
# class FluidSynthSequencer(Sequencer):
# def init(self):
# def __del__(self):
# def start_audio_output(self, driver=None):
# def load_sound_font(self, sf2):
# def play_event(self, note, channel, velocity):
# def stop_event(self, note, channel):
# def cc_event(self, channel, control, value):
# def instr_event(self, channel, instr, bank):
# def init(sf2, driver = None):
# def play_Note(note, channel = 1, velocity = 100):
# def stop_Note(note, channel = 1):
# def play_NoteContainer(nc, channel = 1, velocity = 100):
# def stop_NoteContainer(nc, channel = 1):
# def play_Bar(bar, channel = 1, bpm = 120):
# def play_Bars(bars, channels, bpm = 120):
# def play_Track(track, channel = 1, bpm = 120):
# def play_Tracks(tracks, channels, bpm = 120):
# def play_Composition(composition, channels = None, bpm = 120):
# def control_change(channel, control, value):
# def set_instrument(channel, midi_instr):
# def stop_everything():
# def modulation(channel, value):
# def pan(channel, value):
# def main_volume(channel, value):
# def set_instrument(channel, instr, bank = 0):
. Output only the next line. | if not fluidsynth.init(SF2): |
Next line prediction: <|code_start|> "Amaj13" : ["A", "C#", "E", "G#", "B", "F#"],
"A13" : ["A", "C#", "E", "G", "B", "F#"],
"Am13" : ["A", "C", "E", "G", "B", "F#"],
# Altered chords
"A7b9" : ["A", "C#", "E", "G", "Bb"],
"A7#9" : ["A", "C#", "E", "G", "B#"],
"A7b5" : ["A", "C#", "Eb", "G"],
"A6/7" : ["A", "C#", "E", "F#", "G"],
"A67" : ["A", "C#", "E", "F#", "G"],
# Special
"A5" : ["A", "E"],
"Ahendrix" : ["A", "C#", "E", "G", "C"],
"N.C." : [],
"NC" : [],
# Poly chords
"Dm|G" : ["G", "B", "D", "F", "A"],
"Dm7|G" : ["G", "B", "D", "F", "A", "C"],
"Am7|G7" : ["G", "B", "D", "F", "A", "C", "E", "G"],
}
map(lambda x: self.assertEqual(answers[x], chords.from_shorthand(x),\
"The shorthand of %s is not %s, expecting %s" % (x, chords.from_shorthand(x), answers[x])),\
answers.keys())
def test_malformed_from_shorthand(self):
for x in ["Bollocks", "Asd", "Bbasd@#45"]:
<|code_end|>
. Use current file imports:
(import sys
import mingus.core.chords as chords
import unittest
from mingus.core.mt_exceptions import RangeError, FormatError, NoteFormatError)
and context including class names, function names, or small code snippets from other files:
# Path: mingus/core/mt_exceptions.py
# class RangeError(Error):
# pass
#
# class FormatError(Error):
# pass
#
# class NoteFormatError(Error):
# pass
. Output only the next line. | self.assertRaises(FormatError, chords.from_shorthand, x) |
Next line prediction: <|code_start|> "A13" : ["A", "C#", "E", "G", "B", "F#"],
"Am13" : ["A", "C", "E", "G", "B", "F#"],
# Altered chords
"A7b9" : ["A", "C#", "E", "G", "Bb"],
"A7#9" : ["A", "C#", "E", "G", "B#"],
"A7b5" : ["A", "C#", "Eb", "G"],
"A6/7" : ["A", "C#", "E", "F#", "G"],
"A67" : ["A", "C#", "E", "F#", "G"],
# Special
"A5" : ["A", "E"],
"Ahendrix" : ["A", "C#", "E", "G", "C"],
"N.C." : [],
"NC" : [],
# Poly chords
"Dm|G" : ["G", "B", "D", "F", "A"],
"Dm7|G" : ["G", "B", "D", "F", "A", "C"],
"Am7|G7" : ["G", "B", "D", "F", "A", "C", "E", "G"],
}
map(lambda x: self.assertEqual(answers[x], chords.from_shorthand(x),\
"The shorthand of %s is not %s, expecting %s" % (x, chords.from_shorthand(x), answers[x])),\
answers.keys())
def test_malformed_from_shorthand(self):
for x in ["Bollocks", "Asd", "Bbasd@#45"]:
self.assertRaises(FormatError, chords.from_shorthand, x)
<|code_end|>
. Use current file imports:
(import sys
import mingus.core.chords as chords
import unittest
from mingus.core.mt_exceptions import RangeError, FormatError, NoteFormatError)
and context including class names, function names, or small code snippets from other files:
# Path: mingus/core/mt_exceptions.py
# class RangeError(Error):
# pass
#
# class FormatError(Error):
# pass
#
# class NoteFormatError(Error):
# pass
. Output only the next line. | self.assertRaises(NoteFormatError, chords.from_shorthand, x[1:]) |
Using the snippet: <|code_start|> self.flats = map(lambda x: x + 'b', self.base_notes)
self.exotic = map(lambda x: x + 'b###b#', self.base_notes)
def test_base_note_validity(self):
map(lambda x: self.assert_(notes.is_valid_note(x),\
"Base notes A-G"), self.base_notes)
def test_sharp_note_validity(self):
map(lambda x: self.assert_(notes.is_valid_note(x),\
"Sharp notes A#-G#"), self.sharps)
def test_flat_note_validity(self):
map(lambda x: self.assert_(notes.is_valid_note(x),\
"Flat notes Ab-Gb"),self.flats)
def test_exotic_note_validity(self):
map(lambda x: self.assert_(notes.is_valid_note(x),\
"Exotic notes Ab##b#-Gb###b#"), self.exotic)
def test_faulty_note_invalidity(self):
map(lambda x: self.assertEqual(False, notes.is_valid_note(x),\
"Faulty notes"), ['asdasd', 'C###f', 'c', 'd', 'E*'])
def test_valid_int_to_note(self):
n = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
map(lambda x: self.assertEqual(n[x], notes.int_to_note(x),\
"Int to note mapping %d-%s failed." % (x, n[x])), range(0,12))
def test_invalid_int_to_note(self):
faulty = [-1, 12, 13, 123123, -123]
<|code_end|>
, determine the next line of code. You have imports:
import sys
import mingus.core.notes as notes
import unittest
from mingus.core.mt_exceptions import RangeError
and context (class names, function names, or code) available:
# Path: mingus/core/mt_exceptions.py
# class RangeError(Error):
# pass
. Output only the next line. | map(lambda x: self.assertRaises(RangeError, notes.int_to_note, x), faulty) |
Continue the code snippet: <|code_start|># The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
ModelSQLAlchemyRedisBase = ModelSQLAlchemyRedisFactory.make()
@pytest.fixture
def bind():
return mock.MagicMock()
@pytest.fixture
def redis_bind():
return mock.MagicMock()
@pytest.fixture
def sqlalchemy_middleware(bind, redis_bind):
<|code_end|>
. Use current file imports:
from falconswagger.middlewares import SessionMiddleware
from falconswagger.models.orm.sqlalchemy_redis import ModelSQLAlchemyRedisFactory
from unittest import mock
import pytest
and context (classes, functions, or code) from other files:
# Path: falconswagger/middlewares.py
# class SessionMiddleware(object):
#
# def __init__(self, sqlalchemy_bind=None, redis_bind=None):
# self.sqlalchemy_bind = sqlalchemy_bind
# self.redis_bind = redis_bind
#
# def process_resource(self, req, resp, model, uri_params):
# if getattr(model, '__session__', None):
# req.context['session'] = model.__session__
# return
#
# req.context['session'] = Session(bind=self.sqlalchemy_bind, redis_bind=self.redis_bind)
#
# def process_response(self, req, resp, model):
# session = req.context.pop('session', None)
# if session is not None \
# and hasattr(session, 'close') \
# and not getattr(model, '__session__', None):
# session.close()
#
# Path: falconswagger/models/orm/sqlalchemy_redis.py
# class ModelSQLAlchemyRedisFactory(object):
#
# @staticmethod
# def make(name='ModelSQLAlchemyRedisBase', bind=None, metadata=None,
# mapper=None, class_registry=None, authorizer=None, keys_separator=b'|'):
# base = declarative_base(
# name=name, metaclass=ModelSQLAlchemyRedisMeta,
# cls=_ModelSQLAlchemyRedisBase, bind=bind, metadata=metadata,
# mapper=mapper, constructor=_ModelSQLAlchemyRedisBase.__init__)
# base.__authorizer__ = authorizer
# base.__keys_separator__ = \
# keys_separator.decode() if isinstance(keys_separator, str) else keys_separator
# return base
. Output only the next line. | return SessionMiddleware(bind, redis_bind) |
Based on the snippet: <|code_start|> for package in package_names
for module in list_modules(path.join(MYDIR, *package.split('.')))
]
cmdclass = {'build_ext': build_ext}
else:
cmdclass = {}
ext_modules = []
long_description = ''
with open('README.md') as readme:
long_description = readme.read()
install_requires = []
with open('requirements.txt') as requirements:
install_requires = requirements.readlines()
tests_require = []
with open('requirements-dev.txt') as requirements_dev:
tests_require = requirements_dev.readlines()
setup(
name='falcon-swagger',
packages=find_packages('.'),
include_package_data=True,
<|code_end|>
, predict the immediate next line with the help of imports:
from version import VERSION
from setuptools import setup, find_packages, Extension
from os import path
from Cython.Distutils import build_ext
import glob
import imp
import io
import os
import sys
and context (classes, functions, sometimes code) from other files:
# Path: version.py
# VERSION = '0.14.4'
. Output only the next line. | version=VERSION, |
Here is a snippet: <|code_start|>
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
ROOT_PATH = os.path.dirname(os.path.abspath(__file__))
sys.path.append(os.path.join(ROOT_PATH, '..'))
@pytest.fixture
def model_base():
<|code_end|>
. Write the next line using the current file imports:
import os
import sys
import pytest
from falconswagger.models.orm.sqlalchemy_redis import ModelSQLAlchemyRedisFactory
and context from other files:
# Path: falconswagger/models/orm/sqlalchemy_redis.py
# class ModelSQLAlchemyRedisFactory(object):
#
# @staticmethod
# def make(name='ModelSQLAlchemyRedisBase', bind=None, metadata=None,
# mapper=None, class_registry=None, authorizer=None, keys_separator=b'|'):
# base = declarative_base(
# name=name, metaclass=ModelSQLAlchemyRedisMeta,
# cls=_ModelSQLAlchemyRedisBase, bind=bind, metadata=metadata,
# mapper=mapper, constructor=_ModelSQLAlchemyRedisBase.__init__)
# base.__authorizer__ = authorizer
# base.__keys_separator__ = \
# keys_separator.decode() if isinstance(keys_separator, str) else keys_separator
# return base
, which may include functions, classes, or code. Output only the next line. | return ModelSQLAlchemyRedisFactory.make() |
Based on the snippet: <|code_start|> assert model2_string.__relationships__ == {'model1': model2_string.model1}
def test_if_builds_relationships_correctly_with_two_models_set_with_string(
self, model1, model2, model3_string):
assert model3_string.__relationships__ == {
'model1': model3_string.model1, 'model2': model3_string.model2}
def test_if_builds_backrefs_correctly_with_one_model(self, model2, model3):
assert model2.__backrefs__ == {model3.model2}
def test_if_builds_backrefs_correctly_with_two_models(self, model1, model2, model3):
assert model1.__backrefs__ == {model2.model1, model3.model1}
def test_if_builds_primaries_keys_correctly(self, model_base):
class model(model_base):
__tablename__ = 'test'
id3 = sa.Column(sa.Integer, primary_key=True)
id1 = sa.Column(sa.Integer, primary_key=True)
id2 = sa.Column(sa.Integer, primary_key=True)
assert model.primaries_keys == {'id1': model.id1, 'id2': model.id2, 'id3': model.id3}
def test_raises_model_error_with_invalid_base_class(self):
class model(object):
__baseclass_name__ = 'Test'
id = sa.Column(sa.Integer, primary_key=True)
with pytest.raises(ModelBaseError) as error:
sa.ext.declarative.declarative_base(
name='Invalid',
<|code_end|>
, predict the immediate next line with the help of imports:
from falconswagger.models.orm.sqlalchemy_redis import ModelSQLAlchemyRedisFactory, ModelSQLAlchemyRedisMeta
from falconswagger.models.orm.session import Session
from falconswagger.exceptions import ModelBaseError
from unittest import mock
import pytest
import sqlalchemy as sa
and context (classes, functions, sometimes code) from other files:
# Path: falconswagger/models/orm/sqlalchemy_redis.py
# class ModelSQLAlchemyRedisFactory(object):
#
# @staticmethod
# def make(name='ModelSQLAlchemyRedisBase', bind=None, metadata=None,
# mapper=None, class_registry=None, authorizer=None, keys_separator=b'|'):
# base = declarative_base(
# name=name, metaclass=ModelSQLAlchemyRedisMeta,
# cls=_ModelSQLAlchemyRedisBase, bind=bind, metadata=metadata,
# mapper=mapper, constructor=_ModelSQLAlchemyRedisBase.__init__)
# base.__authorizer__ = authorizer
# base.__keys_separator__ = \
# keys_separator.decode() if isinstance(keys_separator, str) else keys_separator
# return base
#
# class ModelSQLAlchemyRedisMeta(
# ModelSQLAlchemyRedisInitMetaMixin,
# ModelSQLAlchemyRedisOperationsMetaMixin):
# pass
#
# Path: falconswagger/models/orm/session.py
# class _SessionBase(SessionSA):
# def __init__(
# self, bind=None, autoflush=True,
# expire_on_commit=True, _enable_transaction_accounting=True,
# autocommit=False, twophase=False, weak_identity_map=True,
# binds=None, extension=None, info=None, query_cls=Query, redis_bind=None):
# def _clean_redis_sets(self):
# def commit(self):
# def delete(self, instance):
# def _update_objects_on_redis(self):
# def _exec_hdel(self, insts):
# def _get_filters_names_set(self, inst):
# def _exec_hmset(self, insts):
# def mark_for_hdel(self, inst):
# def mark_for_hmset(self, inst):
# def deleted_from_database(session, instance):
# def added_to_database(session, instance):
#
# Path: falconswagger/exceptions.py
# class ModelBaseError(FalconSwaggerError):
# def __init__(self, message, input_=None):
# FalconSwaggerError.__init__(self, message, HTTP_BAD_REQUEST)
# self.input_ = input_
. Output only the next line. | metaclass=ModelSQLAlchemyRedisMeta, cls=model) |
Next line prediction: <|code_start|>
def test_if_builds_relationships_correctly_with_one_model_set_with_string(
self, model1, model2_string):
assert model2_string.__relationships__ == {'model1': model2_string.model1}
def test_if_builds_relationships_correctly_with_two_models_set_with_string(
self, model1, model2, model3_string):
assert model3_string.__relationships__ == {
'model1': model3_string.model1, 'model2': model3_string.model2}
def test_if_builds_backrefs_correctly_with_one_model(self, model2, model3):
assert model2.__backrefs__ == {model3.model2}
def test_if_builds_backrefs_correctly_with_two_models(self, model1, model2, model3):
assert model1.__backrefs__ == {model2.model1, model3.model1}
def test_if_builds_primaries_keys_correctly(self, model_base):
class model(model_base):
__tablename__ = 'test'
id3 = sa.Column(sa.Integer, primary_key=True)
id1 = sa.Column(sa.Integer, primary_key=True)
id2 = sa.Column(sa.Integer, primary_key=True)
assert model.primaries_keys == {'id1': model.id1, 'id2': model.id2, 'id3': model.id3}
def test_raises_model_error_with_invalid_base_class(self):
class model(object):
__baseclass_name__ = 'Test'
id = sa.Column(sa.Integer, primary_key=True)
<|code_end|>
. Use current file imports:
(from falconswagger.models.orm.sqlalchemy_redis import ModelSQLAlchemyRedisFactory, ModelSQLAlchemyRedisMeta
from falconswagger.models.orm.session import Session
from falconswagger.exceptions import ModelBaseError
from unittest import mock
import pytest
import sqlalchemy as sa)
and context including class names, function names, or small code snippets from other files:
# Path: falconswagger/models/orm/sqlalchemy_redis.py
# class ModelSQLAlchemyRedisFactory(object):
#
# @staticmethod
# def make(name='ModelSQLAlchemyRedisBase', bind=None, metadata=None,
# mapper=None, class_registry=None, authorizer=None, keys_separator=b'|'):
# base = declarative_base(
# name=name, metaclass=ModelSQLAlchemyRedisMeta,
# cls=_ModelSQLAlchemyRedisBase, bind=bind, metadata=metadata,
# mapper=mapper, constructor=_ModelSQLAlchemyRedisBase.__init__)
# base.__authorizer__ = authorizer
# base.__keys_separator__ = \
# keys_separator.decode() if isinstance(keys_separator, str) else keys_separator
# return base
#
# class ModelSQLAlchemyRedisMeta(
# ModelSQLAlchemyRedisInitMetaMixin,
# ModelSQLAlchemyRedisOperationsMetaMixin):
# pass
#
# Path: falconswagger/models/orm/session.py
# class _SessionBase(SessionSA):
# def __init__(
# self, bind=None, autoflush=True,
# expire_on_commit=True, _enable_transaction_accounting=True,
# autocommit=False, twophase=False, weak_identity_map=True,
# binds=None, extension=None, info=None, query_cls=Query, redis_bind=None):
# def _clean_redis_sets(self):
# def commit(self):
# def delete(self, instance):
# def _update_objects_on_redis(self):
# def _exec_hdel(self, insts):
# def _get_filters_names_set(self, inst):
# def _exec_hmset(self, insts):
# def mark_for_hdel(self, inst):
# def mark_for_hmset(self, inst):
# def deleted_from_database(session, instance):
# def added_to_database(session, instance):
#
# Path: falconswagger/exceptions.py
# class ModelBaseError(FalconSwaggerError):
# def __init__(self, message, input_=None):
# FalconSwaggerError.__init__(self, message, HTTP_BAD_REQUEST)
# self.input_ = input_
. Output only the next line. | with pytest.raises(ModelBaseError) as error: |
Here is a snippet: <|code_start|> m1 = {'id': 1, 'model2': [m2]}
model1_mto.insert(session, m1)
m3_insert = {
'id': 1,
'model1': {
'id': 1,
'_operation': 'update',
'model2': [{
'id': 1,
'_operation': 'remove'
}]
}
}
objs = model3.insert(session, m3_insert)
assert session.query(model2_mto).one().todict() == {'id': 1, 'model1_id': None}
expected = {
'id': 1,
'model1_id': 1,
'model2_id': None,
'model1': {
'id': 1,
'model2': []
},
'model2': None
}
assert objs == [expected]
def test_insert_nested_update_without_relationships(
self, model1, model2, session, redis):
<|code_end|>
. Write the next line using the current file imports:
from falconswagger.models.orm.sqlalchemy_redis import ModelSQLAlchemyRedisFactory
from falconswagger.models.orm.session import Session
from falconswagger.exceptions import ModelBaseError
from unittest import mock
import pytest
import msgpack
import sqlalchemy as sa
and context from other files:
# Path: falconswagger/models/orm/sqlalchemy_redis.py
# class ModelSQLAlchemyRedisFactory(object):
#
# @staticmethod
# def make(name='ModelSQLAlchemyRedisBase', bind=None, metadata=None,
# mapper=None, class_registry=None, authorizer=None, keys_separator=b'|'):
# base = declarative_base(
# name=name, metaclass=ModelSQLAlchemyRedisMeta,
# cls=_ModelSQLAlchemyRedisBase, bind=bind, metadata=metadata,
# mapper=mapper, constructor=_ModelSQLAlchemyRedisBase.__init__)
# base.__authorizer__ = authorizer
# base.__keys_separator__ = \
# keys_separator.decode() if isinstance(keys_separator, str) else keys_separator
# return base
#
# Path: falconswagger/models/orm/session.py
# class _SessionBase(SessionSA):
# def __init__(
# self, bind=None, autoflush=True,
# expire_on_commit=True, _enable_transaction_accounting=True,
# autocommit=False, twophase=False, weak_identity_map=True,
# binds=None, extension=None, info=None, query_cls=Query, redis_bind=None):
# def _clean_redis_sets(self):
# def commit(self):
# def delete(self, instance):
# def _update_objects_on_redis(self):
# def _exec_hdel(self, insts):
# def _get_filters_names_set(self, inst):
# def _exec_hmset(self, insts):
# def mark_for_hdel(self, inst):
# def mark_for_hmset(self, inst):
# def deleted_from_database(session, instance):
# def added_to_database(session, instance):
#
# Path: falconswagger/exceptions.py
# class ModelBaseError(FalconSwaggerError):
# def __init__(self, message, input_=None):
# FalconSwaggerError.__init__(self, message, HTTP_BAD_REQUEST)
# self.input_ = input_
, which may include functions, classes, or code. Output only the next line. | with pytest.raises(ModelBaseError): |
Predict the next line for this snippet: <|code_start|># in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
class SessionMiddleware(object):
def __init__(self, sqlalchemy_bind=None, redis_bind=None):
self.sqlalchemy_bind = sqlalchemy_bind
self.redis_bind = redis_bind
def process_resource(self, req, resp, model, uri_params):
if getattr(model, '__session__', None):
req.context['session'] = model.__session__
return
<|code_end|>
with the help of current file imports:
from falconswagger.models.orm.session import Session
from falconswagger.models.orm.sqlalchemy_redis import ModelSQLAlchemyRedisMeta
and context from other files:
# Path: falconswagger/models/orm/session.py
# class _SessionBase(SessionSA):
# def __init__(
# self, bind=None, autoflush=True,
# expire_on_commit=True, _enable_transaction_accounting=True,
# autocommit=False, twophase=False, weak_identity_map=True,
# binds=None, extension=None, info=None, query_cls=Query, redis_bind=None):
# def _clean_redis_sets(self):
# def commit(self):
# def delete(self, instance):
# def _update_objects_on_redis(self):
# def _exec_hdel(self, insts):
# def _get_filters_names_set(self, inst):
# def _exec_hmset(self, insts):
# def mark_for_hdel(self, inst):
# def mark_for_hmset(self, inst):
# def deleted_from_database(session, instance):
# def added_to_database(session, instance):
#
# Path: falconswagger/models/orm/sqlalchemy_redis.py
# class ModelSQLAlchemyRedisMeta(
# ModelSQLAlchemyRedisInitMetaMixin,
# ModelSQLAlchemyRedisOperationsMetaMixin):
# pass
, which may contain function names, class names, or code. Output only the next line. | req.context['session'] = Session(bind=self.sqlalchemy_bind, redis_bind=self.redis_bind) |
Given the code snippet: <|code_start|># AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
class JsonBuilderMeta(type):
def _type_builder(cls, type_):
return getattr(cls, '_build_' + type_)
def _build_string(cls, value):
return str(value)
def _build_number(cls, value):
return float(value)
def _build_boolean(cls, value):
value = json.loads(value)
if not isinstance(value, bool):
raise ValueError(value)
return value
def _build_integer(cls, value):
return int(value)
def _build_array(cls, values, schema, nested_types, input_):
if 'array' in nested_types:
<|code_end|>
, generate the next line using the imports in this file:
from falconswagger.exceptions import ModelBaseError
from jsonschema import ValidationError
from copy import deepcopy
import json
and context (functions, classes, or occasionally code) from other files:
# Path: falconswagger/exceptions.py
# class ModelBaseError(FalconSwaggerError):
# def __init__(self, message, input_=None):
# FalconSwaggerError.__init__(self, message, HTTP_BAD_REQUEST)
# self.input_ = input_
. Output only the next line. | raise ModelBaseError('nested array was not allowed', input_=input_) |
Given the following code snippet before the placeholder: <|code_start|> return cls.get_instance_key(id_, id_.keys())
def delete(cls, session, ids, **kwargs):
keys = [cls._build_key(id_) for id_ in cls._to_list(ids)]
if keys:
session.redis_bind.hdel(cls.__key__, *keys)
def get(cls, session, ids=None, limit=None, offset=None, **kwargs):
if limit is not None and offset is not None:
limit += offset
elif ids is None and limit is None and offset is None:
return cls._unpack_objs(session.redis_bind.hgetall(cls.__key__))
if ids is None:
keys = [k for k in session.redis_bind.hkeys(cls.__key__)][offset:limit]
if keys:
return cls._unpack_objs(session.redis_bind.hmget(cls.__key__, *keys))
else:
return []
else:
ids = [cls._build_key(id_) for id_ in cls._to_list(ids)]
return cls._unpack_objs(session.redis_bind.hmget(cls.__key__, *ids[offset:limit]))
def _unpack_objs(cls, objs):
if isinstance(objs, dict):
objs = objs.values()
return [msgpack.loads(obj, encoding='utf-8') for obj in objs if obj is not None]
<|code_end|>
, predict the next line using imports from the current file:
from falconswagger.models.orm.redis_base import ModelRedisBaseMeta, ModelRedisBase
from collections import OrderedDict
from copy import deepcopy
from types import MethodType
import msgpack
and context including class names, function names, and sometimes code from other files:
# Path: falconswagger/models/orm/redis_base.py
# class ModelRedisBaseMeta(ModelLoggerMetaMixin, ModelOrmHttpMetaMixin):
#
# def __init__(cls, name, base_classes, attributes):
# cls._set_logger()
#
# if hasattr(cls, '__schema__'):
# cls._set_routes()
# else:
# cls._set_key()
#
# def _to_list(cls, objs):
# return objs if isinstance(objs, list) else [objs]
#
# def get_filters_names_key(cls):
# return cls.__key__ + '_filters_names'
#
# def get_key(cls, filters_names=None):
# if not filters_names or filters_names == cls.__key__:
# return cls.__key__
#
# return '{}_{}'.format(cls.__key__, filters_names)
#
# def get_instance_key(cls, instance, id_names=None):
# if isinstance(instance, dict):
# ids_ = [str(v) for v in ModelRedisBaseMeta.get_ids_values(cls, instance, id_names)]
# else:
# ids_ = [str(v) for v in cls.get_ids_values(instance, id_names)]
#
# return cls.__keys_separator__.decode().join(ids_).encode()
#
# def get_ids_values(cls, obj, keys=None):
# if keys is None:
# keys = cls.__id_names__
#
# return tuple([dict.get(obj, key) for key in sorted(keys)])
#
# class ModelRedisBase(object):
# __session__ = None
# __authorizer__ = None
# __api__ = None
# __id_names__ = None
#
# def get_key(self, id_names=None):
# return type(self).get_instance_key(self, id_names)
. Output only the next line. | class _ModelRedis(dict, ModelRedisBase): |
Using the snippet: <|code_start|>
@pytest.fixture
def session(model_base, request, variables, redis):
conn = pymysql.connect(
user=variables['database']['user'], password=variables['database']['password'])
with conn.cursor() as cursor:
try:
cursor.execute('drop database {};'.format(variables['database']['database']))
except:
pass
cursor.execute('create database {};'.format(variables['database']['database']))
conn.commit()
conn.close()
if variables['database']['password']:
url = 'mysql+pymysql://{user}:{password}'\
'@{host}:{port}/{database}'.format(**variables['database'])
else:
variables['database'].pop('password')
url = 'mysql+pymysql://{user}'\
'@{host}:{port}/{database}'.format(**variables['database'])
variables['database']['password'] = None
engine = create_engine(url)
model_base.metadata.bind = engine
model_base.metadata.create_all()
<|code_end|>
, determine the next line of code. You have imports:
from falconswagger.models.orm.session import Session
from unittest import mock
from sqlalchemy import create_engine
import pytest
import pymysql
and context (class names, function names, or code) available:
# Path: falconswagger/models/orm/session.py
# class _SessionBase(SessionSA):
# def __init__(
# self, bind=None, autoflush=True,
# expire_on_commit=True, _enable_transaction_accounting=True,
# autocommit=False, twophase=False, weak_identity_map=True,
# binds=None, extension=None, info=None, query_cls=Query, redis_bind=None):
# def _clean_redis_sets(self):
# def commit(self):
# def delete(self, instance):
# def _update_objects_on_redis(self):
# def _exec_hdel(self, insts):
# def _get_filters_names_set(self, inst):
# def _exec_hmset(self, insts):
# def mark_for_hdel(self, inst):
# def mark_for_hmset(self, inst):
# def deleted_from_database(session, instance):
# def added_to_database(session, instance):
. Output only the next line. | session = Session(bind=engine, redis_bind=redis) |
Given snippet: <|code_start|> rows = []
for row in X:
rows.append(self._transform(row))
# TF-IDF transformation
# TODO: implement own TF-IDF transformer. Here, some kind of hack is used
hacky_list = [reduce(add, [word + " " for word in ts]) for ts in rows]
self.timeseries = self.tfidf.fit_transform(hacky_list)
return self
def predict(self, X):
predictions = []
# Transform and compute cosine similarity
for row in X:
pred = get_most_similar(self._transform(row), self.timeseries)
predictions.append(pred)
return np.array(predictions)
def _transform(self, row):
row_sax = []
# TODO: check this option
wgen = wingen if self.adjust else raw_wingen
for window in wgen(row, self.window):
row_sax.append(
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import numpy as np
import scipy.stats
from sklearn.preprocessing import scale, StandardScaler
from sklearn.feature_extraction.text import TfidfVectorizer
from operator import add
from sciquence.sliding_window import wingen, raw_wingen
from sciquence.representation import sax
from scipy.spatial.distance import cosine
from sklearn.base import BaseEstimator
and context:
# Path: sciquence/representation/sax.py
# def sax(sequence, window, alphabet_size=5, adjust=True):
# '''
#
# Symbolic Aggregate Approximation.
#
# Transform time series into a string.
#
# Parameters
# ----------
# sequence: numpy.ndarray
# One-dimensional numpy array of arbitrary length
# window: int
# Length of sliding window
# alphabet_size: int
# Number of Gaussian breakpoints
# adjust: bool, default True
# Compute only for equal-size chunks
#
# Returns
# -------
# sax_representation: str
# A SAX representation
#
# Examples
# --------
# >>> import numpy as np
# >>> from sciquence.representation import sax
# >>> np.random.seed(42)
# >>> random_time_series = np.random.rand(50)
# >>> print sax(random_time_series, 10, alphabet_size=5)
# dcccc
#
# References
# ----------
# .. [1] Lin, J., Keogh, E., Lonardi, S., & Chiu, B. (2003).
# A Symbolic Representation of Time Series,
# with Implications for Streaming Algorithms.
# In proceedings of the 8th ACM SIGMOD Workshop
# on Research Issues in Data Mining and Knowledge Discovery.
#
# http://www.cs.ucr.edu/~eamonn/SAX.pdf
#
# .. [2] http://www.cs.ucr.edu/~eamonn/SAX.htm
# .. [3] https://jmotif.github.io/sax-vsm_site/morea/algorithm/SAX.html
#
# '''
#
# # TODO: check dimensionality, size, aphabet size etc.
# # Pre-step: checking if all arguments have proper values
#
#
# # First step: Standardization ( aka normalization, z-normalization or standard score)
# scaled = scale(sequence)
#
# # Second step: PAA
# paa_repr = paa(scaled, window=window, adjust=adjust)
#
# # Last step:
# breakpoints = gauss_breakpoints(alphabet_size)
# letters = _alphabet(alphabet_size)
#
# breakpoints= np.array(breakpoints)
# symbols = np.array(letters)
# return reduce(add, symbols[np.digitize(paa_repr, breakpoints)])
which might include code, classes, or functions. Output only the next line. | sax(window, window=self.word_length, alphabet_size=self.alphabet_size) |
Predict the next line after this snippet: <|code_start|> search_fields = ['curators__username', 'topic_tags__name', 'title']
prepopulated_fields = {"slug": ("title",)}
class CommentAdmin(admin.ModelAdmin):
search_fields = ['text', 'related__text', 'user__user__username', 'comment_type__name', 'tags__name']
class CommentTypeAdmin(admin.ModelAdmin):
pass
class TagAdmin(admin.ModelAdmin):
search_fields = ['name']
class CommentRelationAdmin(admin.ModelAdmin):
pass
class CommentResponseAdmin(admin.ModelAdmin):
list_display = ('comment', 'user', 'type')
class ArticleAdmin(admin.ModelAdmin):
pass
class NewsOrganizationAdmin(admin.ModelAdmin):
pass
class ClipAdmin(admin.ModelAdmin):
pass
class UserProfileAdmin(admin.ModelAdmin):
search_fields = ['user__username', 'user__email', 'user__first_name', 'user__last_name']
<|code_end|>
using the current file's imports:
from django.contrib import admin
from core.models import Summary,Topic,Comment,UserProfile,\
CommentType,CommentRelation,CommentResponse
from tagger.models import Tag
from clipper.models import Article, NewsOrganization, Clip
from django.contrib.auth.models import User
and any relevant context from other files:
# Path: core/models.py
# class SummaryManager(models.Manager):
# class Summary(models.Model):
# class Meta:
# class Topic(models.Model):
# class Comment(models.Model):
# class CommentTypeManager(models.Manager):
# class CommentType(models.Model):
# class CommentRelation(models.Model):
# class CommentResponse(models.Model):
# def get_by_natural_key(self, text):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# def recursive_traverse(self, comment, level = 1):
# def comments_to_show(self, cmp_function=comment_cmp):
# def get_questions(self):
# def burning_questions(self):
# def burning_question_ids(self):
# def question_is_burning(self, question):
# def top_answers(self):
# def popular_comments(self, num=5):
# def user_responded_comment_ids(self, user_profile, response_type):
# def user_voted_comment_ids(self, user_profile):
# def __unicode__(self):
# def num_responses(self, response_type):
# def num_upvotes(self):
# def opinion_level(self):
# def get_related(self, relation_type):
# def get_answers(self):
# def num_related(self, relation_type):
# def num_answers(self):
# def is_answered(self):
# def get_by_natural_key(self, name):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# COMMENT_RESPONSE_CHOICES = (
# ('share', 'I share this concern'),
# ('have', 'I have this question'),
# ('like', 'I like this'),
# ('concur', 'I concur'),
# ('opinion', 'This answer is primarily opinion'),
# ('accept', 'I accept this as the best answer'),
# )
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# class NewsOrganization(models.Model):
# """ A news organization that has produced an article. """
# url = models.URLField(verify_exists=False)
# name = models.CharField(max_length=80)
# users = models.ManyToManyField(UserProfile)
# feed_url = models.URLField(verify_exists=False)
#
# def __unicode__(self):
# return self.name
#
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
. Output only the next line. | admin.site.register(Summary, SummaryAdmin) |
Continue the code snippet: <|code_start|> prepopulated_fields = {"slug": ("title",)}
class CommentAdmin(admin.ModelAdmin):
search_fields = ['text', 'related__text', 'user__user__username', 'comment_type__name', 'tags__name']
class CommentTypeAdmin(admin.ModelAdmin):
pass
class TagAdmin(admin.ModelAdmin):
search_fields = ['name']
class CommentRelationAdmin(admin.ModelAdmin):
pass
class CommentResponseAdmin(admin.ModelAdmin):
list_display = ('comment', 'user', 'type')
class ArticleAdmin(admin.ModelAdmin):
pass
class NewsOrganizationAdmin(admin.ModelAdmin):
pass
class ClipAdmin(admin.ModelAdmin):
pass
class UserProfileAdmin(admin.ModelAdmin):
search_fields = ['user__username', 'user__email', 'user__first_name', 'user__last_name']
admin.site.register(Summary, SummaryAdmin)
<|code_end|>
. Use current file imports:
from django.contrib import admin
from core.models import Summary,Topic,Comment,UserProfile,\
CommentType,CommentRelation,CommentResponse
from tagger.models import Tag
from clipper.models import Article, NewsOrganization, Clip
from django.contrib.auth.models import User
and context (classes, functions, or code) from other files:
# Path: core/models.py
# class SummaryManager(models.Manager):
# class Summary(models.Model):
# class Meta:
# class Topic(models.Model):
# class Comment(models.Model):
# class CommentTypeManager(models.Manager):
# class CommentType(models.Model):
# class CommentRelation(models.Model):
# class CommentResponse(models.Model):
# def get_by_natural_key(self, text):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# def recursive_traverse(self, comment, level = 1):
# def comments_to_show(self, cmp_function=comment_cmp):
# def get_questions(self):
# def burning_questions(self):
# def burning_question_ids(self):
# def question_is_burning(self, question):
# def top_answers(self):
# def popular_comments(self, num=5):
# def user_responded_comment_ids(self, user_profile, response_type):
# def user_voted_comment_ids(self, user_profile):
# def __unicode__(self):
# def num_responses(self, response_type):
# def num_upvotes(self):
# def opinion_level(self):
# def get_related(self, relation_type):
# def get_answers(self):
# def num_related(self, relation_type):
# def num_answers(self):
# def is_answered(self):
# def get_by_natural_key(self, name):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# COMMENT_RESPONSE_CHOICES = (
# ('share', 'I share this concern'),
# ('have', 'I have this question'),
# ('like', 'I like this'),
# ('concur', 'I concur'),
# ('opinion', 'This answer is primarily opinion'),
# ('accept', 'I accept this as the best answer'),
# )
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# class NewsOrganization(models.Model):
# """ A news organization that has produced an article. """
# url = models.URLField(verify_exists=False)
# name = models.CharField(max_length=80)
# users = models.ManyToManyField(UserProfile)
# feed_url = models.URLField(verify_exists=False)
#
# def __unicode__(self):
# return self.name
#
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
. Output only the next line. | admin.site.register(Topic, TopicAdmin) |
Given snippet: <|code_start|>
class CommentAdmin(admin.ModelAdmin):
search_fields = ['text', 'related__text', 'user__user__username', 'comment_type__name', 'tags__name']
class CommentTypeAdmin(admin.ModelAdmin):
pass
class TagAdmin(admin.ModelAdmin):
search_fields = ['name']
class CommentRelationAdmin(admin.ModelAdmin):
pass
class CommentResponseAdmin(admin.ModelAdmin):
list_display = ('comment', 'user', 'type')
class ArticleAdmin(admin.ModelAdmin):
pass
class NewsOrganizationAdmin(admin.ModelAdmin):
pass
class ClipAdmin(admin.ModelAdmin):
pass
class UserProfileAdmin(admin.ModelAdmin):
search_fields = ['user__username', 'user__email', 'user__first_name', 'user__last_name']
admin.site.register(Summary, SummaryAdmin)
admin.site.register(Topic, TopicAdmin)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.contrib import admin
from core.models import Summary,Topic,Comment,UserProfile,\
CommentType,CommentRelation,CommentResponse
from tagger.models import Tag
from clipper.models import Article, NewsOrganization, Clip
from django.contrib.auth.models import User
and context:
# Path: core/models.py
# class SummaryManager(models.Manager):
# class Summary(models.Model):
# class Meta:
# class Topic(models.Model):
# class Comment(models.Model):
# class CommentTypeManager(models.Manager):
# class CommentType(models.Model):
# class CommentRelation(models.Model):
# class CommentResponse(models.Model):
# def get_by_natural_key(self, text):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# def recursive_traverse(self, comment, level = 1):
# def comments_to_show(self, cmp_function=comment_cmp):
# def get_questions(self):
# def burning_questions(self):
# def burning_question_ids(self):
# def question_is_burning(self, question):
# def top_answers(self):
# def popular_comments(self, num=5):
# def user_responded_comment_ids(self, user_profile, response_type):
# def user_voted_comment_ids(self, user_profile):
# def __unicode__(self):
# def num_responses(self, response_type):
# def num_upvotes(self):
# def opinion_level(self):
# def get_related(self, relation_type):
# def get_answers(self):
# def num_related(self, relation_type):
# def num_answers(self):
# def is_answered(self):
# def get_by_natural_key(self, name):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# COMMENT_RESPONSE_CHOICES = (
# ('share', 'I share this concern'),
# ('have', 'I have this question'),
# ('like', 'I like this'),
# ('concur', 'I concur'),
# ('opinion', 'This answer is primarily opinion'),
# ('accept', 'I accept this as the best answer'),
# )
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# class NewsOrganization(models.Model):
# """ A news organization that has produced an article. """
# url = models.URLField(verify_exists=False)
# name = models.CharField(max_length=80)
# users = models.ManyToManyField(UserProfile)
# feed_url = models.URLField(verify_exists=False)
#
# def __unicode__(self):
# return self.name
#
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
which might include code, classes, or functions. Output only the next line. | admin.site.register(Comment, CommentAdmin) |
Predict the next line for this snippet: <|code_start|>class CommentTypeAdmin(admin.ModelAdmin):
pass
class TagAdmin(admin.ModelAdmin):
search_fields = ['name']
class CommentRelationAdmin(admin.ModelAdmin):
pass
class CommentResponseAdmin(admin.ModelAdmin):
list_display = ('comment', 'user', 'type')
class ArticleAdmin(admin.ModelAdmin):
pass
class NewsOrganizationAdmin(admin.ModelAdmin):
pass
class ClipAdmin(admin.ModelAdmin):
pass
class UserProfileAdmin(admin.ModelAdmin):
search_fields = ['user__username', 'user__email', 'user__first_name', 'user__last_name']
admin.site.register(Summary, SummaryAdmin)
admin.site.register(Topic, TopicAdmin)
admin.site.register(Comment, CommentAdmin)
admin.site.register(CommentType, CommentTypeAdmin)
admin.site.register(CommentRelation, CommentRelationAdmin)
admin.site.register(CommentResponse, CommentResponseAdmin)
<|code_end|>
with the help of current file imports:
from django.contrib import admin
from core.models import Summary,Topic,Comment,UserProfile,\
CommentType,CommentRelation,CommentResponse
from tagger.models import Tag
from clipper.models import Article, NewsOrganization, Clip
from django.contrib.auth.models import User
and context from other files:
# Path: core/models.py
# class SummaryManager(models.Manager):
# class Summary(models.Model):
# class Meta:
# class Topic(models.Model):
# class Comment(models.Model):
# class CommentTypeManager(models.Manager):
# class CommentType(models.Model):
# class CommentRelation(models.Model):
# class CommentResponse(models.Model):
# def get_by_natural_key(self, text):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# def recursive_traverse(self, comment, level = 1):
# def comments_to_show(self, cmp_function=comment_cmp):
# def get_questions(self):
# def burning_questions(self):
# def burning_question_ids(self):
# def question_is_burning(self, question):
# def top_answers(self):
# def popular_comments(self, num=5):
# def user_responded_comment_ids(self, user_profile, response_type):
# def user_voted_comment_ids(self, user_profile):
# def __unicode__(self):
# def num_responses(self, response_type):
# def num_upvotes(self):
# def opinion_level(self):
# def get_related(self, relation_type):
# def get_answers(self):
# def num_related(self, relation_type):
# def num_answers(self):
# def is_answered(self):
# def get_by_natural_key(self, name):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# COMMENT_RESPONSE_CHOICES = (
# ('share', 'I share this concern'),
# ('have', 'I have this question'),
# ('like', 'I like this'),
# ('concur', 'I concur'),
# ('opinion', 'This answer is primarily opinion'),
# ('accept', 'I accept this as the best answer'),
# )
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# class NewsOrganization(models.Model):
# """ A news organization that has produced an article. """
# url = models.URLField(verify_exists=False)
# name = models.CharField(max_length=80)
# users = models.ManyToManyField(UserProfile)
# feed_url = models.URLField(verify_exists=False)
#
# def __unicode__(self):
# return self.name
#
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
, which may contain function names, class names, or code. Output only the next line. | admin.site.register(UserProfile, UserProfileAdmin) |
Next line prediction: <|code_start|>class CommentAdmin(admin.ModelAdmin):
search_fields = ['text', 'related__text', 'user__user__username', 'comment_type__name', 'tags__name']
class CommentTypeAdmin(admin.ModelAdmin):
pass
class TagAdmin(admin.ModelAdmin):
search_fields = ['name']
class CommentRelationAdmin(admin.ModelAdmin):
pass
class CommentResponseAdmin(admin.ModelAdmin):
list_display = ('comment', 'user', 'type')
class ArticleAdmin(admin.ModelAdmin):
pass
class NewsOrganizationAdmin(admin.ModelAdmin):
pass
class ClipAdmin(admin.ModelAdmin):
pass
class UserProfileAdmin(admin.ModelAdmin):
search_fields = ['user__username', 'user__email', 'user__first_name', 'user__last_name']
admin.site.register(Summary, SummaryAdmin)
admin.site.register(Topic, TopicAdmin)
admin.site.register(Comment, CommentAdmin)
<|code_end|>
. Use current file imports:
(from django.contrib import admin
from core.models import Summary,Topic,Comment,UserProfile,\
CommentType,CommentRelation,CommentResponse
from tagger.models import Tag
from clipper.models import Article, NewsOrganization, Clip
from django.contrib.auth.models import User)
and context including class names, function names, or small code snippets from other files:
# Path: core/models.py
# class SummaryManager(models.Manager):
# class Summary(models.Model):
# class Meta:
# class Topic(models.Model):
# class Comment(models.Model):
# class CommentTypeManager(models.Manager):
# class CommentType(models.Model):
# class CommentRelation(models.Model):
# class CommentResponse(models.Model):
# def get_by_natural_key(self, text):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# def recursive_traverse(self, comment, level = 1):
# def comments_to_show(self, cmp_function=comment_cmp):
# def get_questions(self):
# def burning_questions(self):
# def burning_question_ids(self):
# def question_is_burning(self, question):
# def top_answers(self):
# def popular_comments(self, num=5):
# def user_responded_comment_ids(self, user_profile, response_type):
# def user_voted_comment_ids(self, user_profile):
# def __unicode__(self):
# def num_responses(self, response_type):
# def num_upvotes(self):
# def opinion_level(self):
# def get_related(self, relation_type):
# def get_answers(self):
# def num_related(self, relation_type):
# def num_answers(self):
# def is_answered(self):
# def get_by_natural_key(self, name):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# COMMENT_RESPONSE_CHOICES = (
# ('share', 'I share this concern'),
# ('have', 'I have this question'),
# ('like', 'I like this'),
# ('concur', 'I concur'),
# ('opinion', 'This answer is primarily opinion'),
# ('accept', 'I accept this as the best answer'),
# )
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# class NewsOrganization(models.Model):
# """ A news organization that has produced an article. """
# url = models.URLField(verify_exists=False)
# name = models.CharField(max_length=80)
# users = models.ManyToManyField(UserProfile)
# feed_url = models.URLField(verify_exists=False)
#
# def __unicode__(self):
# return self.name
#
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
. Output only the next line. | admin.site.register(CommentType, CommentTypeAdmin) |
Predict the next line for this snippet: <|code_start|> search_fields = ['text', 'related__text', 'user__user__username', 'comment_type__name', 'tags__name']
class CommentTypeAdmin(admin.ModelAdmin):
pass
class TagAdmin(admin.ModelAdmin):
search_fields = ['name']
class CommentRelationAdmin(admin.ModelAdmin):
pass
class CommentResponseAdmin(admin.ModelAdmin):
list_display = ('comment', 'user', 'type')
class ArticleAdmin(admin.ModelAdmin):
pass
class NewsOrganizationAdmin(admin.ModelAdmin):
pass
class ClipAdmin(admin.ModelAdmin):
pass
class UserProfileAdmin(admin.ModelAdmin):
search_fields = ['user__username', 'user__email', 'user__first_name', 'user__last_name']
admin.site.register(Summary, SummaryAdmin)
admin.site.register(Topic, TopicAdmin)
admin.site.register(Comment, CommentAdmin)
admin.site.register(CommentType, CommentTypeAdmin)
<|code_end|>
with the help of current file imports:
from django.contrib import admin
from core.models import Summary,Topic,Comment,UserProfile,\
CommentType,CommentRelation,CommentResponse
from tagger.models import Tag
from clipper.models import Article, NewsOrganization, Clip
from django.contrib.auth.models import User
and context from other files:
# Path: core/models.py
# class SummaryManager(models.Manager):
# class Summary(models.Model):
# class Meta:
# class Topic(models.Model):
# class Comment(models.Model):
# class CommentTypeManager(models.Manager):
# class CommentType(models.Model):
# class CommentRelation(models.Model):
# class CommentResponse(models.Model):
# def get_by_natural_key(self, text):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# def recursive_traverse(self, comment, level = 1):
# def comments_to_show(self, cmp_function=comment_cmp):
# def get_questions(self):
# def burning_questions(self):
# def burning_question_ids(self):
# def question_is_burning(self, question):
# def top_answers(self):
# def popular_comments(self, num=5):
# def user_responded_comment_ids(self, user_profile, response_type):
# def user_voted_comment_ids(self, user_profile):
# def __unicode__(self):
# def num_responses(self, response_type):
# def num_upvotes(self):
# def opinion_level(self):
# def get_related(self, relation_type):
# def get_answers(self):
# def num_related(self, relation_type):
# def num_answers(self):
# def is_answered(self):
# def get_by_natural_key(self, name):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# COMMENT_RESPONSE_CHOICES = (
# ('share', 'I share this concern'),
# ('have', 'I have this question'),
# ('like', 'I like this'),
# ('concur', 'I concur'),
# ('opinion', 'This answer is primarily opinion'),
# ('accept', 'I accept this as the best answer'),
# )
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# class NewsOrganization(models.Model):
# """ A news organization that has produced an article. """
# url = models.URLField(verify_exists=False)
# name = models.CharField(max_length=80)
# users = models.ManyToManyField(UserProfile)
# feed_url = models.URLField(verify_exists=False)
#
# def __unicode__(self):
# return self.name
#
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
, which may contain function names, class names, or code. Output only the next line. | admin.site.register(CommentRelation, CommentRelationAdmin) |
Given snippet: <|code_start|>
class CommentTypeAdmin(admin.ModelAdmin):
pass
class TagAdmin(admin.ModelAdmin):
search_fields = ['name']
class CommentRelationAdmin(admin.ModelAdmin):
pass
class CommentResponseAdmin(admin.ModelAdmin):
list_display = ('comment', 'user', 'type')
class ArticleAdmin(admin.ModelAdmin):
pass
class NewsOrganizationAdmin(admin.ModelAdmin):
pass
class ClipAdmin(admin.ModelAdmin):
pass
class UserProfileAdmin(admin.ModelAdmin):
search_fields = ['user__username', 'user__email', 'user__first_name', 'user__last_name']
admin.site.register(Summary, SummaryAdmin)
admin.site.register(Topic, TopicAdmin)
admin.site.register(Comment, CommentAdmin)
admin.site.register(CommentType, CommentTypeAdmin)
admin.site.register(CommentRelation, CommentRelationAdmin)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.contrib import admin
from core.models import Summary,Topic,Comment,UserProfile,\
CommentType,CommentRelation,CommentResponse
from tagger.models import Tag
from clipper.models import Article, NewsOrganization, Clip
from django.contrib.auth.models import User
and context:
# Path: core/models.py
# class SummaryManager(models.Manager):
# class Summary(models.Model):
# class Meta:
# class Topic(models.Model):
# class Comment(models.Model):
# class CommentTypeManager(models.Manager):
# class CommentType(models.Model):
# class CommentRelation(models.Model):
# class CommentResponse(models.Model):
# def get_by_natural_key(self, text):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# def recursive_traverse(self, comment, level = 1):
# def comments_to_show(self, cmp_function=comment_cmp):
# def get_questions(self):
# def burning_questions(self):
# def burning_question_ids(self):
# def question_is_burning(self, question):
# def top_answers(self):
# def popular_comments(self, num=5):
# def user_responded_comment_ids(self, user_profile, response_type):
# def user_voted_comment_ids(self, user_profile):
# def __unicode__(self):
# def num_responses(self, response_type):
# def num_upvotes(self):
# def opinion_level(self):
# def get_related(self, relation_type):
# def get_answers(self):
# def num_related(self, relation_type):
# def num_answers(self):
# def is_answered(self):
# def get_by_natural_key(self, name):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# COMMENT_RESPONSE_CHOICES = (
# ('share', 'I share this concern'),
# ('have', 'I have this question'),
# ('like', 'I like this'),
# ('concur', 'I concur'),
# ('opinion', 'This answer is primarily opinion'),
# ('accept', 'I accept this as the best answer'),
# )
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# class NewsOrganization(models.Model):
# """ A news organization that has produced an article. """
# url = models.URLField(verify_exists=False)
# name = models.CharField(max_length=80)
# users = models.ManyToManyField(UserProfile)
# feed_url = models.URLField(verify_exists=False)
#
# def __unicode__(self):
# return self.name
#
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
which might include code, classes, or functions. Output only the next line. | admin.site.register(CommentResponse, CommentResponseAdmin) |
Predict the next line after this snippet: <|code_start|> pass
class TagAdmin(admin.ModelAdmin):
search_fields = ['name']
class CommentRelationAdmin(admin.ModelAdmin):
pass
class CommentResponseAdmin(admin.ModelAdmin):
list_display = ('comment', 'user', 'type')
class ArticleAdmin(admin.ModelAdmin):
pass
class NewsOrganizationAdmin(admin.ModelAdmin):
pass
class ClipAdmin(admin.ModelAdmin):
pass
class UserProfileAdmin(admin.ModelAdmin):
search_fields = ['user__username', 'user__email', 'user__first_name', 'user__last_name']
admin.site.register(Summary, SummaryAdmin)
admin.site.register(Topic, TopicAdmin)
admin.site.register(Comment, CommentAdmin)
admin.site.register(CommentType, CommentTypeAdmin)
admin.site.register(CommentRelation, CommentRelationAdmin)
admin.site.register(CommentResponse, CommentResponseAdmin)
admin.site.register(UserProfile, UserProfileAdmin)
<|code_end|>
using the current file's imports:
from django.contrib import admin
from core.models import Summary,Topic,Comment,UserProfile,\
CommentType,CommentRelation,CommentResponse
from tagger.models import Tag
from clipper.models import Article, NewsOrganization, Clip
from django.contrib.auth.models import User
and any relevant context from other files:
# Path: core/models.py
# class SummaryManager(models.Manager):
# class Summary(models.Model):
# class Meta:
# class Topic(models.Model):
# class Comment(models.Model):
# class CommentTypeManager(models.Manager):
# class CommentType(models.Model):
# class CommentRelation(models.Model):
# class CommentResponse(models.Model):
# def get_by_natural_key(self, text):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# def recursive_traverse(self, comment, level = 1):
# def comments_to_show(self, cmp_function=comment_cmp):
# def get_questions(self):
# def burning_questions(self):
# def burning_question_ids(self):
# def question_is_burning(self, question):
# def top_answers(self):
# def popular_comments(self, num=5):
# def user_responded_comment_ids(self, user_profile, response_type):
# def user_voted_comment_ids(self, user_profile):
# def __unicode__(self):
# def num_responses(self, response_type):
# def num_upvotes(self):
# def opinion_level(self):
# def get_related(self, relation_type):
# def get_answers(self):
# def num_related(self, relation_type):
# def num_answers(self):
# def is_answered(self):
# def get_by_natural_key(self, name):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# COMMENT_RESPONSE_CHOICES = (
# ('share', 'I share this concern'),
# ('have', 'I have this question'),
# ('like', 'I like this'),
# ('concur', 'I concur'),
# ('opinion', 'This answer is primarily opinion'),
# ('accept', 'I accept this as the best answer'),
# )
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# class NewsOrganization(models.Model):
# """ A news organization that has produced an article. """
# url = models.URLField(verify_exists=False)
# name = models.CharField(max_length=80)
# users = models.ManyToManyField(UserProfile)
# feed_url = models.URLField(verify_exists=False)
#
# def __unicode__(self):
# return self.name
#
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
. Output only the next line. | admin.site.register(Tag, TagAdmin) |
Next line prediction: <|code_start|>class TagAdmin(admin.ModelAdmin):
search_fields = ['name']
class CommentRelationAdmin(admin.ModelAdmin):
pass
class CommentResponseAdmin(admin.ModelAdmin):
list_display = ('comment', 'user', 'type')
class ArticleAdmin(admin.ModelAdmin):
pass
class NewsOrganizationAdmin(admin.ModelAdmin):
pass
class ClipAdmin(admin.ModelAdmin):
pass
class UserProfileAdmin(admin.ModelAdmin):
search_fields = ['user__username', 'user__email', 'user__first_name', 'user__last_name']
admin.site.register(Summary, SummaryAdmin)
admin.site.register(Topic, TopicAdmin)
admin.site.register(Comment, CommentAdmin)
admin.site.register(CommentType, CommentTypeAdmin)
admin.site.register(CommentRelation, CommentRelationAdmin)
admin.site.register(CommentResponse, CommentResponseAdmin)
admin.site.register(UserProfile, UserProfileAdmin)
admin.site.register(Tag, TagAdmin)
admin.site.register(Clip, ClipAdmin)
<|code_end|>
. Use current file imports:
(from django.contrib import admin
from core.models import Summary,Topic,Comment,UserProfile,\
CommentType,CommentRelation,CommentResponse
from tagger.models import Tag
from clipper.models import Article, NewsOrganization, Clip
from django.contrib.auth.models import User)
and context including class names, function names, or small code snippets from other files:
# Path: core/models.py
# class SummaryManager(models.Manager):
# class Summary(models.Model):
# class Meta:
# class Topic(models.Model):
# class Comment(models.Model):
# class CommentTypeManager(models.Manager):
# class CommentType(models.Model):
# class CommentRelation(models.Model):
# class CommentResponse(models.Model):
# def get_by_natural_key(self, text):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# def recursive_traverse(self, comment, level = 1):
# def comments_to_show(self, cmp_function=comment_cmp):
# def get_questions(self):
# def burning_questions(self):
# def burning_question_ids(self):
# def question_is_burning(self, question):
# def top_answers(self):
# def popular_comments(self, num=5):
# def user_responded_comment_ids(self, user_profile, response_type):
# def user_voted_comment_ids(self, user_profile):
# def __unicode__(self):
# def num_responses(self, response_type):
# def num_upvotes(self):
# def opinion_level(self):
# def get_related(self, relation_type):
# def get_answers(self):
# def num_related(self, relation_type):
# def num_answers(self):
# def is_answered(self):
# def get_by_natural_key(self, name):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# COMMENT_RESPONSE_CHOICES = (
# ('share', 'I share this concern'),
# ('have', 'I have this question'),
# ('like', 'I like this'),
# ('concur', 'I concur'),
# ('opinion', 'This answer is primarily opinion'),
# ('accept', 'I accept this as the best answer'),
# )
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# class NewsOrganization(models.Model):
# """ A news organization that has produced an article. """
# url = models.URLField(verify_exists=False)
# name = models.CharField(max_length=80)
# users = models.ManyToManyField(UserProfile)
# feed_url = models.URLField(verify_exists=False)
#
# def __unicode__(self):
# return self.name
#
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
. Output only the next line. | admin.site.register(Article, ArticleAdmin) |
Predict the next line after this snippet: <|code_start|> search_fields = ['name']
class CommentRelationAdmin(admin.ModelAdmin):
pass
class CommentResponseAdmin(admin.ModelAdmin):
list_display = ('comment', 'user', 'type')
class ArticleAdmin(admin.ModelAdmin):
pass
class NewsOrganizationAdmin(admin.ModelAdmin):
pass
class ClipAdmin(admin.ModelAdmin):
pass
class UserProfileAdmin(admin.ModelAdmin):
search_fields = ['user__username', 'user__email', 'user__first_name', 'user__last_name']
admin.site.register(Summary, SummaryAdmin)
admin.site.register(Topic, TopicAdmin)
admin.site.register(Comment, CommentAdmin)
admin.site.register(CommentType, CommentTypeAdmin)
admin.site.register(CommentRelation, CommentRelationAdmin)
admin.site.register(CommentResponse, CommentResponseAdmin)
admin.site.register(UserProfile, UserProfileAdmin)
admin.site.register(Tag, TagAdmin)
admin.site.register(Clip, ClipAdmin)
admin.site.register(Article, ArticleAdmin)
<|code_end|>
using the current file's imports:
from django.contrib import admin
from core.models import Summary,Topic,Comment,UserProfile,\
CommentType,CommentRelation,CommentResponse
from tagger.models import Tag
from clipper.models import Article, NewsOrganization, Clip
from django.contrib.auth.models import User
and any relevant context from other files:
# Path: core/models.py
# class SummaryManager(models.Manager):
# class Summary(models.Model):
# class Meta:
# class Topic(models.Model):
# class Comment(models.Model):
# class CommentTypeManager(models.Manager):
# class CommentType(models.Model):
# class CommentRelation(models.Model):
# class CommentResponse(models.Model):
# def get_by_natural_key(self, text):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# def recursive_traverse(self, comment, level = 1):
# def comments_to_show(self, cmp_function=comment_cmp):
# def get_questions(self):
# def burning_questions(self):
# def burning_question_ids(self):
# def question_is_burning(self, question):
# def top_answers(self):
# def popular_comments(self, num=5):
# def user_responded_comment_ids(self, user_profile, response_type):
# def user_voted_comment_ids(self, user_profile):
# def __unicode__(self):
# def num_responses(self, response_type):
# def num_upvotes(self):
# def opinion_level(self):
# def get_related(self, relation_type):
# def get_answers(self):
# def num_related(self, relation_type):
# def num_answers(self):
# def is_answered(self):
# def get_by_natural_key(self, name):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# COMMENT_RESPONSE_CHOICES = (
# ('share', 'I share this concern'),
# ('have', 'I have this question'),
# ('like', 'I like this'),
# ('concur', 'I concur'),
# ('opinion', 'This answer is primarily opinion'),
# ('accept', 'I accept this as the best answer'),
# )
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# class NewsOrganization(models.Model):
# """ A news organization that has produced an article. """
# url = models.URLField(verify_exists=False)
# name = models.CharField(max_length=80)
# users = models.ManyToManyField(UserProfile)
# feed_url = models.URLField(verify_exists=False)
#
# def __unicode__(self):
# return self.name
#
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
. Output only the next line. | admin.site.register(NewsOrganization, NewsOrganizationAdmin) |
Using the snippet: <|code_start|>
class TagAdmin(admin.ModelAdmin):
search_fields = ['name']
class CommentRelationAdmin(admin.ModelAdmin):
pass
class CommentResponseAdmin(admin.ModelAdmin):
list_display = ('comment', 'user', 'type')
class ArticleAdmin(admin.ModelAdmin):
pass
class NewsOrganizationAdmin(admin.ModelAdmin):
pass
class ClipAdmin(admin.ModelAdmin):
pass
class UserProfileAdmin(admin.ModelAdmin):
search_fields = ['user__username', 'user__email', 'user__first_name', 'user__last_name']
admin.site.register(Summary, SummaryAdmin)
admin.site.register(Topic, TopicAdmin)
admin.site.register(Comment, CommentAdmin)
admin.site.register(CommentType, CommentTypeAdmin)
admin.site.register(CommentRelation, CommentRelationAdmin)
admin.site.register(CommentResponse, CommentResponseAdmin)
admin.site.register(UserProfile, UserProfileAdmin)
admin.site.register(Tag, TagAdmin)
<|code_end|>
, determine the next line of code. You have imports:
from django.contrib import admin
from core.models import Summary,Topic,Comment,UserProfile,\
CommentType,CommentRelation,CommentResponse
from tagger.models import Tag
from clipper.models import Article, NewsOrganization, Clip
from django.contrib.auth.models import User
and context (class names, function names, or code) available:
# Path: core/models.py
# class SummaryManager(models.Manager):
# class Summary(models.Model):
# class Meta:
# class Topic(models.Model):
# class Comment(models.Model):
# class CommentTypeManager(models.Manager):
# class CommentType(models.Model):
# class CommentRelation(models.Model):
# class CommentResponse(models.Model):
# def get_by_natural_key(self, text):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# def recursive_traverse(self, comment, level = 1):
# def comments_to_show(self, cmp_function=comment_cmp):
# def get_questions(self):
# def burning_questions(self):
# def burning_question_ids(self):
# def question_is_burning(self, question):
# def top_answers(self):
# def popular_comments(self, num=5):
# def user_responded_comment_ids(self, user_profile, response_type):
# def user_voted_comment_ids(self, user_profile):
# def __unicode__(self):
# def num_responses(self, response_type):
# def num_upvotes(self):
# def opinion_level(self):
# def get_related(self, relation_type):
# def get_answers(self):
# def num_related(self, relation_type):
# def num_answers(self):
# def is_answered(self):
# def get_by_natural_key(self, name):
# def __unicode__(self):
# def natural_key(self):
# def __unicode__(self):
# COMMENT_RESPONSE_CHOICES = (
# ('share', 'I share this concern'),
# ('have', 'I have this question'),
# ('like', 'I like this'),
# ('concur', 'I concur'),
# ('opinion', 'This answer is primarily opinion'),
# ('accept', 'I accept this as the best answer'),
# )
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# class NewsOrganization(models.Model):
# """ A news organization that has produced an article. """
# url = models.URLField(verify_exists=False)
# name = models.CharField(max_length=80)
# users = models.ManyToManyField(UserProfile)
# feed_url = models.URLField(verify_exists=False)
#
# def __unicode__(self):
# return self.name
#
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
. Output only the next line. | admin.site.register(Clip, ClipAdmin) |
Predict the next line after this snippet: <|code_start|> """
want to require selected text so people are encouraged to answer using
published story
"""
selected_text = forms.CharField(widget=forms.Textarea(\
attrs={'cols':32,'class':'clipper_text_field'}), required=True, \
label="Any text you highlight in the article will appear here!")
user_comments = forms.CharField(widget=forms.Textarea(\
attrs={'cols':32,'class':'clipper_text_field'}), required=False, \
label="Add some of your own commentary here.")
title = forms.CharField(required=False, \
label="Not the right title for this article? Mind filling it in for us?"\
, widget=forms.TextInput(attrs={'size':'30', 'class':'clipper_text_field'}))
author = forms.CharField(required=False, \
widget=forms.TextInput(attrs={'size':'30', 'class':'clipper_text_field'}),
label="Is this the person who wrote the article? " +\
"No? Mind putting the right name here?")
date_published = forms.DateField(required=False, \
widget=forms.DateTimeInput(format='%m/%d/%Y',attrs={'class':'required date'}),
label="Does this date look date that this article was " +\
"published under? If not, could you fix it?")
url_field = forms.URLField(required=True, widget=forms.HiddenInput)
comment_id_field = forms.CharField(widget=forms.HiddenInput, required=True)
topic_id_field = forms.CharField(widget=forms.HiddenInput, required=True)
def clean(self):
"""
sanitize user input so there isn't any HTML... issue117
"""
f_comments = self.cleaned_data.get('user_comments')
<|code_end|>
using the current file's imports:
from django import forms
from core import utils
and any relevant context from other files:
# Path: core/utils.py
# def sanitize_html(value, base_url=None):
# def build_readable_errors(errordict):
# def comment_cmp(comm1, comm2):
# def slugify(s):
# def get_logger(name, filename=settings.LOG_FILENAME):
# def add_to_query(self, query, alias, col, source, is_summary):
# def settings_context(request):
# class SQLCountIfConcur(models.sql.aggregates.Aggregate):
# class CountIfConcur(models.Aggregate):
. Output only the next line. | self.cleaned_data['user_comments'] = utils.sanitize_html(f_comments) |
Given the following code snippet before the placeholder: <|code_start|> return self.text[:80]
def natural_key(self):
return self.text
class Meta:
verbose_name_plural = 'Summaries'
class Topic(models.Model):
"""A subject of discussion. An information silo. These will generally
correspond to a page on the front end that will aggregate
comments and other content around the subject. This might
be something like 'Evanston Libraries'
Fields:
slug: A shortened, space-replaced, weird character cleaned
version of the title. This will get used in the URL
paths to views related to a given topic.
topic_tags: Content with any of these tags can get pulled into a topic
view.
curators: Users who have priveleges to update this topic.
summary: Short (1-2) paragraph description of the topic, maintained
by one of the curators.
articles: Articles (probably recent ones) to display on the front page, selected by curators. Probably ancestors of timeline."""
title = models.CharField(max_length=80, unique = True)
slug = models.SlugField(unique = True)
summary = models.ForeignKey(Summary)
topic_tags = models.ManyToManyField(Tag, null=True, blank=True)
curators = models.ManyToManyField(UserProfile)
<|code_end|>
, predict the next line using imports from the current file:
from django.db import models
from django.contrib.sites.models import Site
from utils import comment_cmp, CountIfConcur, get_logger
from clipper.models import Article
from clipper.models import Clip
from tagger.models import Tag
from users.models import UserProfile
and context including class names, function names, and sometimes code from other files:
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# Path: clipper/models.py
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: users/models.py
# class UserProfile(models.Model):
# """Extra user data.
#
# Fields:
#
# user: Django user for the profile.
# facebook_user_id: User ID from the Facebook API. This is populated if
# the user chooses to register/login with Facebook.
# is_verified: User has claimed account, filled in some optional fields.
# reporter_verified: A reporter has contacted the user, probably for a story.
# interest: Interest in seeking a user account. This is populated by the
# signup form.
#
# """
#
# USER_TYPE_CHOICES = (
# (u'R', u'reporter'),
# (u'S', u'source'),
# (u'A', u'author'))
#
# INTEREST_CHOICES = (
# (u'', u'Neither or unanswered'),
# (u'publisher', u'publisher'),
# (u'consumer', u'consumer'),
# )
#
# user = models.ForeignKey(User)
# facebook_user_id = models.TextField(blank=True)
# street_address = models.TextField(blank=True)
# city = models.TextField(blank=True)
# state = models.CharField(blank=True, max_length=2)
# zip = models.CharField(blank=True, max_length=10)
# phone_number = models.CharField(blank=True, max_length=12)
# dob = models.DateField(blank=True, null = True)
# user_type = models.CharField(max_length=15, choices = USER_TYPE_CHOICES)
# is_verified = models.BooleanField(default = False)
# reporter_verified = models.ForeignKey("UserProfile", blank=True, null=True)
# interest = models.CharField(max_length=15, choices=INTEREST_CHOICES,
# default='', blank=True)
#
# def is_reporter(self):
# return self.user_type == u'R'
#
# def __unicode__(self):
# return self.user.username
. Output only the next line. | articles = models.ManyToManyField(Article, blank=True) |
Predict the next line for this snippet: <|code_start|> related: Comments that are related to this comment, e.g. an answer to
a question, a re-phrasing of a comment, a question about
a comment, or something that is just conceptually related.
sites: Sites which this content can appear on. This is anticipating
sharing content between multiple sites, e.g. a Chicago
election site and an Evanston local news site.
comment_type: Question, concern, respsonse ...
topics: Topics to which this comment relates.
sources: different from a comment you own; these are comments you're associated with
where that user may not even be an active user in the database. We'll set to is_active=False, to
reflect, e.g., MOS interviews. Will set up claiming process so these users can BECOME active by entering contact
info, etc.
is_parent: after several comments are merged, one becomes the parent. By default, this is the only one shown. Defaults
to true, since comment is assumed to be its own parent when it's independent/visible."""
text = models.TextField()
user = models.ForeignKey(UserProfile, related_name="comments")
sources = models.ManyToManyField(UserProfile, related_name = "sourced_comments", blank=True, null = True)
tags = models.ManyToManyField(Tag, null=True, blank=True)
related = models.ManyToManyField("self", through="CommentRelation",
symmetrical=False, null=True)
sites = models.ManyToManyField(Site, blank=True)
comment_type = models.ForeignKey("CommentType")
topics = models.ManyToManyField("Topic", blank=True, related_name = 'comments')
responses = models.ManyToManyField(UserProfile, through="CommentResponse",
symmetrical=False, null=True,
related_name="responses")
is_parent = models.BooleanField(default = True)
is_deleted = models.BooleanField(default = False)
date_created = models.DateTimeField(auto_now_add=True)
<|code_end|>
with the help of current file imports:
from django.db import models
from django.contrib.sites.models import Site
from utils import comment_cmp, CountIfConcur, get_logger
from clipper.models import Article
from clipper.models import Clip
from tagger.models import Tag
from users.models import UserProfile
and context from other files:
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# Path: clipper/models.py
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: users/models.py
# class UserProfile(models.Model):
# """Extra user data.
#
# Fields:
#
# user: Django user for the profile.
# facebook_user_id: User ID from the Facebook API. This is populated if
# the user chooses to register/login with Facebook.
# is_verified: User has claimed account, filled in some optional fields.
# reporter_verified: A reporter has contacted the user, probably for a story.
# interest: Interest in seeking a user account. This is populated by the
# signup form.
#
# """
#
# USER_TYPE_CHOICES = (
# (u'R', u'reporter'),
# (u'S', u'source'),
# (u'A', u'author'))
#
# INTEREST_CHOICES = (
# (u'', u'Neither or unanswered'),
# (u'publisher', u'publisher'),
# (u'consumer', u'consumer'),
# )
#
# user = models.ForeignKey(User)
# facebook_user_id = models.TextField(blank=True)
# street_address = models.TextField(blank=True)
# city = models.TextField(blank=True)
# state = models.CharField(blank=True, max_length=2)
# zip = models.CharField(blank=True, max_length=10)
# phone_number = models.CharField(blank=True, max_length=12)
# dob = models.DateField(blank=True, null = True)
# user_type = models.CharField(max_length=15, choices = USER_TYPE_CHOICES)
# is_verified = models.BooleanField(default = False)
# reporter_verified = models.ForeignKey("UserProfile", blank=True, null=True)
# interest = models.CharField(max_length=15, choices=INTEREST_CHOICES,
# default='', blank=True)
#
# def is_reporter(self):
# return self.user_type == u'R'
#
# def __unicode__(self):
# return self.user.username
, which may contain function names, class names, or code. Output only the next line. | clips = models.ManyToManyField(Clip, blank=True, null=True) |
Next line prediction: <|code_start|>
def __unicode__(self):
return self.text[:80]
def natural_key(self):
return self.text
class Meta:
verbose_name_plural = 'Summaries'
class Topic(models.Model):
"""A subject of discussion. An information silo. These will generally
correspond to a page on the front end that will aggregate
comments and other content around the subject. This might
be something like 'Evanston Libraries'
Fields:
slug: A shortened, space-replaced, weird character cleaned
version of the title. This will get used in the URL
paths to views related to a given topic.
topic_tags: Content with any of these tags can get pulled into a topic
view.
curators: Users who have priveleges to update this topic.
summary: Short (1-2) paragraph description of the topic, maintained
by one of the curators.
articles: Articles (probably recent ones) to display on the front page, selected by curators. Probably ancestors of timeline."""
title = models.CharField(max_length=80, unique = True)
slug = models.SlugField(unique = True)
summary = models.ForeignKey(Summary)
<|code_end|>
. Use current file imports:
(from django.db import models
from django.contrib.sites.models import Site
from utils import comment_cmp, CountIfConcur, get_logger
from clipper.models import Article
from clipper.models import Clip
from tagger.models import Tag
from users.models import UserProfile)
and context including class names, function names, or small code snippets from other files:
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# Path: clipper/models.py
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: users/models.py
# class UserProfile(models.Model):
# """Extra user data.
#
# Fields:
#
# user: Django user for the profile.
# facebook_user_id: User ID from the Facebook API. This is populated if
# the user chooses to register/login with Facebook.
# is_verified: User has claimed account, filled in some optional fields.
# reporter_verified: A reporter has contacted the user, probably for a story.
# interest: Interest in seeking a user account. This is populated by the
# signup form.
#
# """
#
# USER_TYPE_CHOICES = (
# (u'R', u'reporter'),
# (u'S', u'source'),
# (u'A', u'author'))
#
# INTEREST_CHOICES = (
# (u'', u'Neither or unanswered'),
# (u'publisher', u'publisher'),
# (u'consumer', u'consumer'),
# )
#
# user = models.ForeignKey(User)
# facebook_user_id = models.TextField(blank=True)
# street_address = models.TextField(blank=True)
# city = models.TextField(blank=True)
# state = models.CharField(blank=True, max_length=2)
# zip = models.CharField(blank=True, max_length=10)
# phone_number = models.CharField(blank=True, max_length=12)
# dob = models.DateField(blank=True, null = True)
# user_type = models.CharField(max_length=15, choices = USER_TYPE_CHOICES)
# is_verified = models.BooleanField(default = False)
# reporter_verified = models.ForeignKey("UserProfile", blank=True, null=True)
# interest = models.CharField(max_length=15, choices=INTEREST_CHOICES,
# default='', blank=True)
#
# def is_reporter(self):
# return self.user_type == u'R'
#
# def __unicode__(self):
# return self.user.username
. Output only the next line. | topic_tags = models.ManyToManyField(Tag, null=True, blank=True) |
Here is a snippet: <|code_start|> def __unicode__(self):
return self.text[:80]
def natural_key(self):
return self.text
class Meta:
verbose_name_plural = 'Summaries'
class Topic(models.Model):
"""A subject of discussion. An information silo. These will generally
correspond to a page on the front end that will aggregate
comments and other content around the subject. This might
be something like 'Evanston Libraries'
Fields:
slug: A shortened, space-replaced, weird character cleaned
version of the title. This will get used in the URL
paths to views related to a given topic.
topic_tags: Content with any of these tags can get pulled into a topic
view.
curators: Users who have priveleges to update this topic.
summary: Short (1-2) paragraph description of the topic, maintained
by one of the curators.
articles: Articles (probably recent ones) to display on the front page, selected by curators. Probably ancestors of timeline."""
title = models.CharField(max_length=80, unique = True)
slug = models.SlugField(unique = True)
summary = models.ForeignKey(Summary)
topic_tags = models.ManyToManyField(Tag, null=True, blank=True)
<|code_end|>
. Write the next line using the current file imports:
from django.db import models
from django.contrib.sites.models import Site
from utils import comment_cmp, CountIfConcur, get_logger
from clipper.models import Article
from clipper.models import Clip
from tagger.models import Tag
from users.models import UserProfile
and context from other files:
# Path: clipper/models.py
# class Article(models.Model):
# """ A news article. These will be the sources for answers. """
# url = models.URLField(verify_exists=False, unique = True)
# news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
# source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
# authors = models.ManyToManyField(UserProfile)
# title = models.CharField(max_length=200)
# date_published = models.DateTimeField(null=True)
# # But we'll probably not be tagging articles initially, just aggregating tags from
# # related clips
# tags = models.ManyToManyField(Tag, null=True)
#
# def __unicode__(self):
# return self.title
#
# Path: clipper/models.py
# class Clip(models.Model):
# """ Relevent text from an article. """
# tags = models.ManyToManyField(Tag, null=True)
# article = models.ForeignKey(Article)
# user = models.ForeignKey(UserProfile)
# text = models.TextField()
# date_created = models.DateTimeField(auto_now_add=True)
# user_comments = models.TextField()
#
# def __unicode__(self):
# return self.text[:80]
#
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: users/models.py
# class UserProfile(models.Model):
# """Extra user data.
#
# Fields:
#
# user: Django user for the profile.
# facebook_user_id: User ID from the Facebook API. This is populated if
# the user chooses to register/login with Facebook.
# is_verified: User has claimed account, filled in some optional fields.
# reporter_verified: A reporter has contacted the user, probably for a story.
# interest: Interest in seeking a user account. This is populated by the
# signup form.
#
# """
#
# USER_TYPE_CHOICES = (
# (u'R', u'reporter'),
# (u'S', u'source'),
# (u'A', u'author'))
#
# INTEREST_CHOICES = (
# (u'', u'Neither or unanswered'),
# (u'publisher', u'publisher'),
# (u'consumer', u'consumer'),
# )
#
# user = models.ForeignKey(User)
# facebook_user_id = models.TextField(blank=True)
# street_address = models.TextField(blank=True)
# city = models.TextField(blank=True)
# state = models.CharField(blank=True, max_length=2)
# zip = models.CharField(blank=True, max_length=10)
# phone_number = models.CharField(blank=True, max_length=12)
# dob = models.DateField(blank=True, null = True)
# user_type = models.CharField(max_length=15, choices = USER_TYPE_CHOICES)
# is_verified = models.BooleanField(default = False)
# reporter_verified = models.ForeignKey("UserProfile", blank=True, null=True)
# interest = models.CharField(max_length=15, choices=INTEREST_CHOICES,
# default='', blank=True)
#
# def is_reporter(self):
# return self.user_type == u'R'
#
# def __unicode__(self):
# return self.user.username
, which may include functions, classes, or code. Output only the next line. | curators = models.ManyToManyField(UserProfile) |
Given snippet: <|code_start|> if user.is_active:
login(request, user)
# Success!
data['username'] = username
else:
raise UserAccountDisabled
else:
raise BadUsernameOrPassword
else:
# Form didn't validate
# HACK ALERT: Incorrect usernames/passwords are
# are checked in the validation code of user.forms.LoginForm
# We'll detect this and try to return a more reasonable
# error message.
if '__all__' in form.errors.keys():
if form.errors['__all__'] == \
[form.WRONG_USERNAME_OR_PASSWORD_MSG]:
raise BadUsernameOrPassword( \
form.WRONG_USERNAME_OR_PASSWORD_MSG)
status = 400 # Bad Request
data['error'] = "Some required fields are missing"
data['field_errors'] = form.errors
data['error_html'] = core.utils.build_readable_errors(form.errors)
else:
# Method not POST
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import json
import core.utils
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render_to_response
from django.conf import settings
from django.template import RequestContext
from django.contrib.auth import authenticate, login, logout
from fbapi import facebook
from core.exceptions import MethodUnsupported, NonAjaxRequest
from users.exceptions import BadUsernameOrPassword, UserAccountDisabled, \
UserUsernameExists, UserEmailExists, \
NoFacebookUser
from models import UserProfile
from models import User
from models import ActivationKeyValue
from forms import LoginForm, RegisterForm, InviteForm, ActivateUnactivatedForm
from registration.models import RegistrationProfile
and context:
# Path: core/exceptions.py
# class MethodUnsupported(Exception):
# """Exception thrown when an HTTP request method isn't supported by the REST
# API"""
# pass
#
# class NonAjaxRequest(Exception):
# """Exception thrown when an API call is made that is not an AJAX request
# and we don't want to allow this kind of (potentially) cross-site
# call
#
# """
# pass
#
# Path: users/exceptions.py
# class BadUsernameOrPassword(Exception):
# def __init__(self, msg='Bad username or password.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserAccountDisabled(Exception):
# def __init__(self, msg='User account has been disabled.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserUsernameExists(Exception):
# def __init__(self, msg='The username is taken, please try another'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserEmailExists(Exception):
# def __init__(self, msg='This email already exists, please try another'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class NoFacebookUser(Exception):
# def __init__(self, msg='No Facebook user detected.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
which might include code, classes, or functions. Output only the next line. | raise MethodUnsupported("This endpoint only accepts POSTs.") |
Using the snippet: <|code_start|>
logger = core.utils.get_logger(__name__)
def ajax_login_required(view_func):
"""
Decorator for AJAX endpoints requiring authentication.
Thank you http://stackoverflow.com/questions/312925/django-authentication-and-ajax-urls-that-require-login/523196#523196
"""
def wrap(request, *args, **kwargs):
status = 200
data = {}
try:
if request.is_ajax():
if request.user.is_authenticated():
return view_func(request, *args, **kwargs)
else:
raise BadUsernameOrPassword
else:
# Non-AJAX request. Disallow for now.
<|code_end|>
, determine the next line of code. You have imports:
import json
import core.utils
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render_to_response
from django.conf import settings
from django.template import RequestContext
from django.contrib.auth import authenticate, login, logout
from fbapi import facebook
from core.exceptions import MethodUnsupported, NonAjaxRequest
from users.exceptions import BadUsernameOrPassword, UserAccountDisabled, \
UserUsernameExists, UserEmailExists, \
NoFacebookUser
from models import UserProfile
from models import User
from models import ActivationKeyValue
from forms import LoginForm, RegisterForm, InviteForm, ActivateUnactivatedForm
from registration.models import RegistrationProfile
and context (class names, function names, or code) available:
# Path: core/exceptions.py
# class MethodUnsupported(Exception):
# """Exception thrown when an HTTP request method isn't supported by the REST
# API"""
# pass
#
# class NonAjaxRequest(Exception):
# """Exception thrown when an API call is made that is not an AJAX request
# and we don't want to allow this kind of (potentially) cross-site
# call
#
# """
# pass
#
# Path: users/exceptions.py
# class BadUsernameOrPassword(Exception):
# def __init__(self, msg='Bad username or password.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserAccountDisabled(Exception):
# def __init__(self, msg='User account has been disabled.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserUsernameExists(Exception):
# def __init__(self, msg='The username is taken, please try another'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserEmailExists(Exception):
# def __init__(self, msg='This email already exists, please try another'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class NoFacebookUser(Exception):
# def __init__(self, msg='No Facebook user detected.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
. Output only the next line. | raise NonAjaxRequest( \ |
Given the following code snippet before the placeholder: <|code_start|>
logger = core.utils.get_logger(__name__)
def ajax_login_required(view_func):
"""
Decorator for AJAX endpoints requiring authentication.
Thank you http://stackoverflow.com/questions/312925/django-authentication-and-ajax-urls-that-require-login/523196#523196
"""
def wrap(request, *args, **kwargs):
status = 200
data = {}
try:
if request.is_ajax():
if request.user.is_authenticated():
return view_func(request, *args, **kwargs)
else:
<|code_end|>
, predict the next line using imports from the current file:
import json
import core.utils
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render_to_response
from django.conf import settings
from django.template import RequestContext
from django.contrib.auth import authenticate, login, logout
from fbapi import facebook
from core.exceptions import MethodUnsupported, NonAjaxRequest
from users.exceptions import BadUsernameOrPassword, UserAccountDisabled, \
UserUsernameExists, UserEmailExists, \
NoFacebookUser
from models import UserProfile
from models import User
from models import ActivationKeyValue
from forms import LoginForm, RegisterForm, InviteForm, ActivateUnactivatedForm
from registration.models import RegistrationProfile
and context including class names, function names, and sometimes code from other files:
# Path: core/exceptions.py
# class MethodUnsupported(Exception):
# """Exception thrown when an HTTP request method isn't supported by the REST
# API"""
# pass
#
# class NonAjaxRequest(Exception):
# """Exception thrown when an API call is made that is not an AJAX request
# and we don't want to allow this kind of (potentially) cross-site
# call
#
# """
# pass
#
# Path: users/exceptions.py
# class BadUsernameOrPassword(Exception):
# def __init__(self, msg='Bad username or password.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserAccountDisabled(Exception):
# def __init__(self, msg='User account has been disabled.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserUsernameExists(Exception):
# def __init__(self, msg='The username is taken, please try another'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserEmailExists(Exception):
# def __init__(self, msg='This email already exists, please try another'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class NoFacebookUser(Exception):
# def __init__(self, msg='No Facebook user detected.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
. Output only the next line. | raise BadUsernameOrPassword |
Based on the snippet: <|code_start|> logger.info('users.views.register(request: returning page='+return_page)
return render_to_response(return_page, template_dict,\
context_instance=RequestContext(request))
def api_auth(request, output_format='json'):
"""Like auth() but through AJAX"""
data = {} # Response data
status = 200 # Ok
try:
if request.is_ajax():
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
username = form.cleaned_data['username']
password = form.cleaned_data['password']
# Try to authenticate the user
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
# Success!
data['username'] = username
else:
<|code_end|>
, predict the immediate next line with the help of imports:
import json
import core.utils
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render_to_response
from django.conf import settings
from django.template import RequestContext
from django.contrib.auth import authenticate, login, logout
from fbapi import facebook
from core.exceptions import MethodUnsupported, NonAjaxRequest
from users.exceptions import BadUsernameOrPassword, UserAccountDisabled, \
UserUsernameExists, UserEmailExists, \
NoFacebookUser
from models import UserProfile
from models import User
from models import ActivationKeyValue
from forms import LoginForm, RegisterForm, InviteForm, ActivateUnactivatedForm
from registration.models import RegistrationProfile
and context (classes, functions, sometimes code) from other files:
# Path: core/exceptions.py
# class MethodUnsupported(Exception):
# """Exception thrown when an HTTP request method isn't supported by the REST
# API"""
# pass
#
# class NonAjaxRequest(Exception):
# """Exception thrown when an API call is made that is not an AJAX request
# and we don't want to allow this kind of (potentially) cross-site
# call
#
# """
# pass
#
# Path: users/exceptions.py
# class BadUsernameOrPassword(Exception):
# def __init__(self, msg='Bad username or password.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserAccountDisabled(Exception):
# def __init__(self, msg='User account has been disabled.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserUsernameExists(Exception):
# def __init__(self, msg='The username is taken, please try another'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserEmailExists(Exception):
# def __init__(self, msg='This email already exists, please try another'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class NoFacebookUser(Exception):
# def __init__(self, msg='No Facebook user detected.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
. Output only the next line. | raise UserAccountDisabled |
Predict the next line for this snippet: <|code_start|> baseuser.last_name=f_last_name
baseuser.save()
newuser = UserProfile(user=baseuser, city=f_city, \
street_address=f_street_address, state=f_state, \
zip=f_zip_code, phone_number=f_phone)
newuser.save()
if not f_dont_log_user_in:
# Create user
user = authenticate(username=f_username, \
password=f_password)
login(request, user)
# Set our response codes and data
status = 201 # Created
data['username'] = f_username
data['uri'] = '/api/%s/users/%s/' % (output_format, \
f_username)
else:
# Form didn't validate
# HACK ALERT: Conflicting usernames/emails
# are checked in the validation code of user.forms.RegisterForm
# We'll detect this and try to return a more reasonable
# error message.
if 'username' in form.errors.keys():
if form.errors['username'] == \
[form.USERNAME_EXISTS_MSG]:
<|code_end|>
with the help of current file imports:
import json
import core.utils
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render_to_response
from django.conf import settings
from django.template import RequestContext
from django.contrib.auth import authenticate, login, logout
from fbapi import facebook
from core.exceptions import MethodUnsupported, NonAjaxRequest
from users.exceptions import BadUsernameOrPassword, UserAccountDisabled, \
UserUsernameExists, UserEmailExists, \
NoFacebookUser
from models import UserProfile
from models import User
from models import ActivationKeyValue
from forms import LoginForm, RegisterForm, InviteForm, ActivateUnactivatedForm
from registration.models import RegistrationProfile
and context from other files:
# Path: core/exceptions.py
# class MethodUnsupported(Exception):
# """Exception thrown when an HTTP request method isn't supported by the REST
# API"""
# pass
#
# class NonAjaxRequest(Exception):
# """Exception thrown when an API call is made that is not an AJAX request
# and we don't want to allow this kind of (potentially) cross-site
# call
#
# """
# pass
#
# Path: users/exceptions.py
# class BadUsernameOrPassword(Exception):
# def __init__(self, msg='Bad username or password.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserAccountDisabled(Exception):
# def __init__(self, msg='User account has been disabled.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserUsernameExists(Exception):
# def __init__(self, msg='The username is taken, please try another'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserEmailExists(Exception):
# def __init__(self, msg='This email already exists, please try another'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class NoFacebookUser(Exception):
# def __init__(self, msg='No Facebook user detected.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
, which may contain function names, class names, or code. Output only the next line. | raise UserUsernameExists(form.USERNAME_EXISTS_MSG) |
Given the code snippet: <|code_start|> zip=f_zip_code, phone_number=f_phone)
newuser.save()
if not f_dont_log_user_in:
# Create user
user = authenticate(username=f_username, \
password=f_password)
login(request, user)
# Set our response codes and data
status = 201 # Created
data['username'] = f_username
data['uri'] = '/api/%s/users/%s/' % (output_format, \
f_username)
else:
# Form didn't validate
# HACK ALERT: Conflicting usernames/emails
# are checked in the validation code of user.forms.RegisterForm
# We'll detect this and try to return a more reasonable
# error message.
if 'username' in form.errors.keys():
if form.errors['username'] == \
[form.USERNAME_EXISTS_MSG]:
raise UserUsernameExists(form.USERNAME_EXISTS_MSG)
if 'email' in form.errors.keys():
if form.errors['email'] == [form.EMAIL_EXISTS_MSG]:
<|code_end|>
, generate the next line using the imports in this file:
import json
import core.utils
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render_to_response
from django.conf import settings
from django.template import RequestContext
from django.contrib.auth import authenticate, login, logout
from fbapi import facebook
from core.exceptions import MethodUnsupported, NonAjaxRequest
from users.exceptions import BadUsernameOrPassword, UserAccountDisabled, \
UserUsernameExists, UserEmailExists, \
NoFacebookUser
from models import UserProfile
from models import User
from models import ActivationKeyValue
from forms import LoginForm, RegisterForm, InviteForm, ActivateUnactivatedForm
from registration.models import RegistrationProfile
and context (functions, classes, or occasionally code) from other files:
# Path: core/exceptions.py
# class MethodUnsupported(Exception):
# """Exception thrown when an HTTP request method isn't supported by the REST
# API"""
# pass
#
# class NonAjaxRequest(Exception):
# """Exception thrown when an API call is made that is not an AJAX request
# and we don't want to allow this kind of (potentially) cross-site
# call
#
# """
# pass
#
# Path: users/exceptions.py
# class BadUsernameOrPassword(Exception):
# def __init__(self, msg='Bad username or password.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserAccountDisabled(Exception):
# def __init__(self, msg='User account has been disabled.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserUsernameExists(Exception):
# def __init__(self, msg='The username is taken, please try another'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserEmailExists(Exception):
# def __init__(self, msg='This email already exists, please try another'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class NoFacebookUser(Exception):
# def __init__(self, msg='No Facebook user detected.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
. Output only the next line. | raise UserEmailExists(form.EMAIL_EXISTS_MSG) |
Given the code snippet: <|code_start|> try:
user_profile = UserProfile.objects.get(\
facebook_user_id=fb_user['uid'])
except UserProfile.DoesNotExist:
#they're not, so we need to create them and move em along
fb_graph = facebook.GraphAPI(fb_user['access_token'])
fb_profile = fb_graph.get_object("me")
username = fb_profile['first_name'] + fb_profile['last_name']
password = fb_profile['id']
base_user = User.objects.create_user(username=username,\
password=password, email='na')
user_profile = UserProfile(user=base_user,\
facebook_user_id=fb_profile['id'])
user_profile.save()
finally:
# Log the user in without authenticating them
# See http://zcentric.com/2010/05/12/django-fix-for-user-object-has-no-attribute-backend/
user_profile.user.backend = \
'django.contrib.auth.backends.ModelBackend'
login(request, user_profile.user)
#logger.debug("User %s logged in." % (user_profile.user))
# Set up our return data
data['username'] = user_profile.user.username
data['uri'] = '/api/%s/users/%s/' % (output_format, \
user_profile.user.username)
else:
<|code_end|>
, generate the next line using the imports in this file:
import json
import core.utils
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render_to_response
from django.conf import settings
from django.template import RequestContext
from django.contrib.auth import authenticate, login, logout
from fbapi import facebook
from core.exceptions import MethodUnsupported, NonAjaxRequest
from users.exceptions import BadUsernameOrPassword, UserAccountDisabled, \
UserUsernameExists, UserEmailExists, \
NoFacebookUser
from models import UserProfile
from models import User
from models import ActivationKeyValue
from forms import LoginForm, RegisterForm, InviteForm, ActivateUnactivatedForm
from registration.models import RegistrationProfile
and context (functions, classes, or occasionally code) from other files:
# Path: core/exceptions.py
# class MethodUnsupported(Exception):
# """Exception thrown when an HTTP request method isn't supported by the REST
# API"""
# pass
#
# class NonAjaxRequest(Exception):
# """Exception thrown when an API call is made that is not an AJAX request
# and we don't want to allow this kind of (potentially) cross-site
# call
#
# """
# pass
#
# Path: users/exceptions.py
# class BadUsernameOrPassword(Exception):
# def __init__(self, msg='Bad username or password.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserAccountDisabled(Exception):
# def __init__(self, msg='User account has been disabled.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserUsernameExists(Exception):
# def __init__(self, msg='The username is taken, please try another'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class UserEmailExists(Exception):
# def __init__(self, msg='This email already exists, please try another'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
#
# class NoFacebookUser(Exception):
# def __init__(self, msg='No Facebook user detected.'):
# self.msg = msg
#
# def __str__(self):
# return self.msg
. Output only the next line. | raise NoFacebookUser |
Predict the next line for this snippet: <|code_start|>
class Article(models.Model):
""" A news article. These will be the sources for answers. """
url = models.URLField(verify_exists=False, unique = True)
news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
authors = models.ManyToManyField(UserProfile)
title = models.CharField(max_length=200)
date_published = models.DateTimeField(null=True)
# But we'll probably not be tagging articles initially, just aggregating tags from
# related clips
<|code_end|>
with the help of current file imports:
from django.db import models
from tagger.models import Tag
from users.models import UserProfile
and context from other files:
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: users/models.py
# class UserProfile(models.Model):
# """Extra user data.
#
# Fields:
#
# user: Django user for the profile.
# facebook_user_id: User ID from the Facebook API. This is populated if
# the user chooses to register/login with Facebook.
# is_verified: User has claimed account, filled in some optional fields.
# reporter_verified: A reporter has contacted the user, probably for a story.
# interest: Interest in seeking a user account. This is populated by the
# signup form.
#
# """
#
# USER_TYPE_CHOICES = (
# (u'R', u'reporter'),
# (u'S', u'source'),
# (u'A', u'author'))
#
# INTEREST_CHOICES = (
# (u'', u'Neither or unanswered'),
# (u'publisher', u'publisher'),
# (u'consumer', u'consumer'),
# )
#
# user = models.ForeignKey(User)
# facebook_user_id = models.TextField(blank=True)
# street_address = models.TextField(blank=True)
# city = models.TextField(blank=True)
# state = models.CharField(blank=True, max_length=2)
# zip = models.CharField(blank=True, max_length=10)
# phone_number = models.CharField(blank=True, max_length=12)
# dob = models.DateField(blank=True, null = True)
# user_type = models.CharField(max_length=15, choices = USER_TYPE_CHOICES)
# is_verified = models.BooleanField(default = False)
# reporter_verified = models.ForeignKey("UserProfile", blank=True, null=True)
# interest = models.CharField(max_length=15, choices=INTEREST_CHOICES,
# default='', blank=True)
#
# def is_reporter(self):
# return self.user_type == u'R'
#
# def __unicode__(self):
# return self.user.username
, which may contain function names, class names, or code. Output only the next line. | tags = models.ManyToManyField(Tag, null=True) |
Using the snippet: <|code_start|>
class Article(models.Model):
""" A news article. These will be the sources for answers. """
url = models.URLField(verify_exists=False, unique = True)
news_organization = models.ForeignKey("NewsOrganization", related_name='articles_created')
source = models.ForeignKey("NewsOrganization", related_name = 'articles_sourced')
<|code_end|>
, determine the next line of code. You have imports:
from django.db import models
from tagger.models import Tag
from users.models import UserProfile
and context (class names, function names, or code) available:
# Path: tagger/models.py
# class Tag(models.Model):
# """ Generic class to implement tagging. """
# name = models.CharField(max_length=80, db_index=True, unique = True)
#
# def __unicode__(self):
# return self.name
#
# Path: users/models.py
# class UserProfile(models.Model):
# """Extra user data.
#
# Fields:
#
# user: Django user for the profile.
# facebook_user_id: User ID from the Facebook API. This is populated if
# the user chooses to register/login with Facebook.
# is_verified: User has claimed account, filled in some optional fields.
# reporter_verified: A reporter has contacted the user, probably for a story.
# interest: Interest in seeking a user account. This is populated by the
# signup form.
#
# """
#
# USER_TYPE_CHOICES = (
# (u'R', u'reporter'),
# (u'S', u'source'),
# (u'A', u'author'))
#
# INTEREST_CHOICES = (
# (u'', u'Neither or unanswered'),
# (u'publisher', u'publisher'),
# (u'consumer', u'consumer'),
# )
#
# user = models.ForeignKey(User)
# facebook_user_id = models.TextField(blank=True)
# street_address = models.TextField(blank=True)
# city = models.TextField(blank=True)
# state = models.CharField(blank=True, max_length=2)
# zip = models.CharField(blank=True, max_length=10)
# phone_number = models.CharField(blank=True, max_length=12)
# dob = models.DateField(blank=True, null = True)
# user_type = models.CharField(max_length=15, choices = USER_TYPE_CHOICES)
# is_verified = models.BooleanField(default = False)
# reporter_verified = models.ForeignKey("UserProfile", blank=True, null=True)
# interest = models.CharField(max_length=15, choices=INTEREST_CHOICES,
# default='', blank=True)
#
# def is_reporter(self):
# return self.user_type == u'R'
#
# def __unicode__(self):
# return self.user.username
. Output only the next line. | authors = models.ManyToManyField(UserProfile) |
Based on the snippet: <|code_start|> libs.append(item)
return libs
def replaceFileName(fileMatch):
global currentFilesPath
fileName = fileMatch.group(1)
currentWD = os.getcwd()
pathName = abspath(currentWD) +"/"+fileName
if not os.path.isfile(pathName):
dirname, filename = os.path.split(abspath(getsourcefile(lambda:0)))
pathName = dirname +"/"+fileName
if not os.path.isfile(pathName):
pathName = currentFilesPath +"/"+fileName
if not os.path.isfile(pathName):
cdErr("Cannot find include file '"+fileName+"'")
includedStr = progSpec.stringFromFile(pathName)
includedStr = processIncludedFiles(includedStr, pathName)
return includedStr
def processIncludedFiles(fileString, fileName):
global currentFilesPath
dirname, filename = os.path.split(abspath(fileName))
currentFilesPath = dirname
pattern = re.compile(r'#include +([\w -\.\/\\]+)')
return pattern.sub(replaceFileName, fileString)
def loadTagsFromFile(fileName):
codeDogStr = progSpec.stringFromFile(fileName)
codeDogStr = processIncludedFiles(codeDogStr, fileName)
<|code_end|>
, predict the immediate next line with the help of imports:
from inspect import getsourcefile
from os.path import abspath
from pprint import pprint
from progSpec import cdlog, cdErr
from pyparsing import ParseResults
import os
import re
import codeDogParser
import progSpec
and context (classes, functions, sometimes code) from other files:
# Path: progSpec.py
# def cdlog(lvl, mesg):
# global MaxLogLevelToShow
# global lastLogMesgs
# global highestLvl
# highestLvl=lvl
# resizeLogArray(lvl)
# lastLogMesgs[lvl]=mesg
# for i in range(highestLvl+1, len(lastLogMesgs)):
# lastLogMesgs[i]=''
# if(lvl<=MaxLogLevelToShow):
# if(lvl==0): print('')
# printAtLvl(lvl, mesg, '| ')
#
# def cdErr(mesg):
# global lastLogMesgs
# global highestLvl
# highestLvl+=1
# lastLogMesgs[highestLvl]="\n\nError: "+mesg
# exit(1)
. Output only the next line. | cdlog(2, "Parsing file: "+str(fileName)) |
Based on the snippet: <|code_start|>
In codeDog the problem is solved by telling
the compiler about features and needs instead of about the libraries.
The compiler then chooses which libraries to link from the listed program needs.
There are two kinds of need that the programmer can specify in dog files:
We'll call them 'features' and 'components'. Features are functionality that
must be added to codeDog in order for your program to work (GUI-toolkit,
Unicode, Math-kit, Networking.) Features often correspond to actual libraries.
Components are files that describe libraries that may be specific to particular
platforms. GTK3, XCODE, etc. Both features and components are "needs"
that are specified with tags.
'''
def getTagsFromLibFiles():
"""simple getter for module level variable"""
return tagsFromLibFiles
def collectLibFilenamesFromFolder(folderPath):
for filename in os.listdir(folderPath):
if filename.endswith("Lib.dog"):
libPaths.append(os.path.join(folderPath, filename))
elif filename.endswith("Lib.dog.proxy"):
line = open(os.path.join(folderPath, filename)).readline()
line=line.strip()
baseName = os.path.basename(line)
#print("baseName: {}".format(baseName))
if (filename.strip('.proxy') == baseName):
libPaths.append(os.path.realpath(line))
else:
<|code_end|>
, predict the immediate next line with the help of imports:
from inspect import getsourcefile
from os.path import abspath
from pprint import pprint
from progSpec import cdlog, cdErr
from pyparsing import ParseResults
import os
import re
import codeDogParser
import progSpec
and context (classes, functions, sometimes code) from other files:
# Path: progSpec.py
# def cdlog(lvl, mesg):
# global MaxLogLevelToShow
# global lastLogMesgs
# global highestLvl
# highestLvl=lvl
# resizeLogArray(lvl)
# lastLogMesgs[lvl]=mesg
# for i in range(highestLvl+1, len(lastLogMesgs)):
# lastLogMesgs[i]=''
# if(lvl<=MaxLogLevelToShow):
# if(lvl==0): print('')
# printAtLvl(lvl, mesg, '| ')
#
# def cdErr(mesg):
# global lastLogMesgs
# global highestLvl
# highestLvl+=1
# lastLogMesgs[highestLvl]="\n\nError: "+mesg
# exit(1)
. Output only the next line. | cdErr("File name "+filename+" does not match path name.") |
Using the snippet: <|code_start|> }
void: clear() <- {
'''+clearWidgetCode+'''
}
}\n''' # TODO: add <VARSFROMWIDGETCODE>
CODE = CODE.replace('<NEWSTRUCTNAME>', newStructName)
CODE = CODE.replace('<CLASSNAME>', className)
#print ('==========================================================\n'+CODE)
codeDogParser.AddToObjectFromText(classes[0], classes[1], CODE, newStructName)
def apply(classes, tags, topClassName):
print('APPLY: in Apply\n')
global classesToProcess
global classesEncoded
classesEncoded={}
# Choose an appropriate app style
appStyle='default'
topWhichScreenFieldID = topClassName+'::whichScreen(int)'
if (progSpec.doesClassDirectlyImlementThisField(classes[0], topClassName, topWhichScreenFieldID)): # if all data fields are classes
appStyle='Z_stack'
else: appStyle='TabbedStack'
guiStructName = topClassName+'_GUI'
classesEncoded[guiStructName]=1
classesToProcess=[[topClassName, 'struct', appStyle, guiStructName]]
# Amend items to each GUI data class
for classToAmend in classesToProcess:
[className, widgetType, dialogStyle, newStructName] = classToAmend
<|code_end|>
, determine the next line of code. You have imports:
import progSpec
import codeDogParser
from progSpec import cdlog, cdErr
and context (class names, function names, or code) available:
# Path: progSpec.py
# def cdlog(lvl, mesg):
# global MaxLogLevelToShow
# global lastLogMesgs
# global highestLvl
# highestLvl=lvl
# resizeLogArray(lvl)
# lastLogMesgs[lvl]=mesg
# for i in range(highestLvl+1, len(lastLogMesgs)):
# lastLogMesgs[i]=''
# if(lvl<=MaxLogLevelToShow):
# if(lvl==0): print('')
# printAtLvl(lvl, mesg, '| ')
#
# def cdErr(mesg):
# global lastLogMesgs
# global highestLvl
# highestLvl+=1
# lastLogMesgs[highestLvl]="\n\nError: "+mesg
# exit(1)
. Output only the next line. | cdlog(1, 'BUILDING '+dialogStyle+' GUI for '+widgetType+' ' + className + ' ('+newStructName+')') |
Here is a snippet: <|code_start|>#///////////////// Use this pattern to gererate a GUI to manipulate a struct.
classesToProcess=[]
classesEncoded={}
currentClassName=''
currentModelSpec=None
# Code accmulator strings:
newWidgetFields=''
widgetInitFuncCode=''
widgetFromVarsCode=''
varsFromWidgetCode=''
clearWidgetCode=''
def findModelRef(classes, structTypeName):
modelRef = progSpec.findSpecOf(classes, structTypeName, 'model')
if modelRef==None:
<|code_end|>
. Write the next line using the current file imports:
import progSpec
import codeDogParser
from progSpec import cdlog, cdErr
and context from other files:
# Path: progSpec.py
# def cdlog(lvl, mesg):
# global MaxLogLevelToShow
# global lastLogMesgs
# global highestLvl
# highestLvl=lvl
# resizeLogArray(lvl)
# lastLogMesgs[lvl]=mesg
# for i in range(highestLvl+1, len(lastLogMesgs)):
# lastLogMesgs[i]=''
# if(lvl<=MaxLogLevelToShow):
# if(lvl==0): print('')
# printAtLvl(lvl, mesg, '| ')
#
# def cdErr(mesg):
# global lastLogMesgs
# global highestLvl
# highestLvl+=1
# lastLogMesgs[highestLvl]="\n\nError: "+mesg
# exit(1)
, which may include functions, classes, or code. Output only the next line. | cdErr('To build a list GUI for list of "'+structTypeName+'" a model is needed but is not found.') |
Given the code snippet: <|code_start|># buildMac.py
def runCMD(myCMD, myDir):
print(" COMMAND: ", myCMD, "\n")
pipe = subprocess.Popen(myCMD, cwd=myDir, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = pipe.communicate()
if out:
print(" Result: ",out)
if err:
print("\n", err)
if (err.find("ERROR")) >= 0:
exit(1)
return [out, err]
def makeDir(dirToGen):
#print "dirToGen:", dirToGen
try:
os.makedirs(dirToGen)
except OSError as exception:
if exception.errno != errno.EEXIST: raise
def writeFile(path, fileName, fileSpecs, fileExtension):
#print path
makeDir(path)
fileName += fileExtension
pathName = path + os.sep + fileName
<|code_end|>
, generate the next line using the imports in this file:
import os
import subprocess
import errno
import shutil
from progSpec import cdlog, cdErr
and context (functions, classes, or occasionally code) from other files:
# Path: progSpec.py
# def cdlog(lvl, mesg):
# global MaxLogLevelToShow
# global lastLogMesgs
# global highestLvl
# highestLvl=lvl
# resizeLogArray(lvl)
# lastLogMesgs[lvl]=mesg
# for i in range(highestLvl+1, len(lastLogMesgs)):
# lastLogMesgs[i]=''
# if(lvl<=MaxLogLevelToShow):
# if(lvl==0): print('')
# printAtLvl(lvl, mesg, '| ')
#
# def cdErr(mesg):
# global lastLogMesgs
# global highestLvl
# highestLvl+=1
# lastLogMesgs[highestLvl]="\n\nError: "+mesg
# exit(1)
. Output only the next line. | cdlog(1, "WRITING FILE: "+pathName) |
Predict the next line after this snippet: <|code_start|>
######################################### O B J E C T D E S C R I P T I O N S
fieldDefs = ZeroOrMore(fieldDef)("fieldDefs")
SetFieldStmt = Group(Word(alphanums + "_.") + '=' + Word(alphanums + r"_. */+-(){}[]\|<>,./?`~@#$%^&*=:!'" + '"'))
coFactualEl = Group("(" + Group(fieldDef + "<=>" + Group(OneOrMore(SetFieldStmt + Suppress(';')))) + ")")("coFactualEl")
sequenceEl = "{" - fieldDefs + "}"
alternateEl = "[" - Group(OneOrMore((coFactualEl | fieldDef) + Optional("|").suppress()))("fieldDefs") + "]"
anonModel = sequenceEl("sequenceEl") | alternateEl("alternateEl")
owners <<= Keyword("const") | Keyword("me") | Keyword("my") | Keyword("our") | Keyword("their") | Keyword("we") | Keyword("itr") | Keyword("id_our") | Keyword("id_their")
fullFieldDef <<= Optional('>')('isNext') + Optional(owners)('owner') + Group(baseType | altModeSpec | classSpec | Group(anonModel) | datastructID)('fieldType') + Optional(arraySpec) + Optional(nameAndVal)
fieldDef <<= Group(flagDef('flagDef') | modeSpec('modeDef') | (quotedString('constStr') + Optional("[opt]") + Optional(":"+CID)) | intNum('constNum') | nameAndVal('nameVal') | fullFieldDef('fullFieldDef'))("fieldDef")
modelTypes = (Keyword("model") | Keyword("struct") | Keyword("string") | Keyword("stream"))
objectDef = Group(modelTypes + classDef + Optional(Literal(":")("optionalTag") + tagDefList) + (Keyword('auto') | anonModel))("objectDef")
doPattern = Group(Keyword("do") + classSpec + Suppress("(") + CIDList + Suppress(")"))("doPattern")
macroDef = Group(Keyword("#define") + CID('macroName') + Suppress("(") + Optional(CIDList('macroArgs')) + Suppress(")") + Group("<%" + SkipTo("%>", include=True))("macroBody"))
objectList = Group(ZeroOrMore(objectDef | doPattern | macroDef))("objectList")
objectDef.setParseAction(logObj)
fieldDef.setParseAction(logFieldDef)
######################################### P A R S E R S T A R T S Y M B O L
progSpecParser = Group(Optional(buildSpecList.setParseAction(logBSL)) + tagDefList.setParseAction(logTags) + objectList)("progSpecParser")
libTagParser = Group(Optional(buildSpecList.setParseAction(logBSL)) + tagDefList.setParseAction(logTags) + (modelTypes|Keyword("do")|Keyword("#define")|StringEnd()))("libTagParser")
# # # # # # # # # # # # # E x t r a c t P a r s e R e s u l t s # # # # # # # # # # # # #
def parseInput(inputStr):
cdlog(2, "Parsing build-specs...")
progSpec.saveTextToErrFile(inputStr)
try:
localResults = progSpecParser.parseString(inputStr, parseAll=True)
except ParseBaseException as pe:
<|code_end|>
using the current file's imports:
import re
import progSpec
from progSpec import cdlog, cdErr, logLvl
from pyparsing import *
and any relevant context from other files:
# Path: progSpec.py
# def cdlog(lvl, mesg):
# global MaxLogLevelToShow
# global lastLogMesgs
# global highestLvl
# highestLvl=lvl
# resizeLogArray(lvl)
# lastLogMesgs[lvl]=mesg
# for i in range(highestLvl+1, len(lastLogMesgs)):
# lastLogMesgs[i]=''
# if(lvl<=MaxLogLevelToShow):
# if(lvl==0): print('')
# printAtLvl(lvl, mesg, '| ')
#
# def cdErr(mesg):
# global lastLogMesgs
# global highestLvl
# highestLvl+=1
# lastLogMesgs[highestLvl]="\n\nError: "+mesg
# exit(1)
#
# def logLvl():
# return highestLvl+1
. Output only the next line. | cdErr( "While parsing: {}".format( pe)) |
Predict the next line for this snippet: <|code_start|> exit(1)
return thisActionItem
def extractActSeq(funcName, childActSeq):
actionList = childActSeq.actionList
actSeq = []
for actionItem in actionList:
thisActionItem = extractActItem(funcName, actionItem)
actSeq.append(thisActionItem)
return actSeq
def extractFuncBody(funcName, funcBodyIn):
'''Extract body of funcName (str) from funcBodyIn (parseResults)
Returns two values: funcBodyOut for CodeDog defined body & funcTextVerbatim for verbatim text.
If body is verbatim: funcBodyOut is an empty string, funcTextVerbatim is a string
If body is CodeDog: funcBodyOut is a list of stuff, funcTextVerbatim is an empty string
'''
if funcBodyIn.rValueVerbatim:
funcBodyOut = ""
funcTextVerbatim = funcBodyIn.rValueVerbatim[1] # opening and closing verbatim symbols are indices 0 and 2
elif funcBodyIn.actionSeq:
funcBodyOut = extractActSeq(funcName, funcBodyIn.actionSeq)
funcTextVerbatim = ""
else:
cdErr("problem in extractFuncBody: funcBodyIn has no rValueVerbatim or actionSeq")
exit(1)
return funcBodyOut, funcTextVerbatim
def extractFieldDefs(ProgSpec, className, stateType, fieldResults):
<|code_end|>
with the help of current file imports:
import re
import progSpec
from progSpec import cdlog, cdErr, logLvl
from pyparsing import *
and context from other files:
# Path: progSpec.py
# def cdlog(lvl, mesg):
# global MaxLogLevelToShow
# global lastLogMesgs
# global highestLvl
# highestLvl=lvl
# resizeLogArray(lvl)
# lastLogMesgs[lvl]=mesg
# for i in range(highestLvl+1, len(lastLogMesgs)):
# lastLogMesgs[i]=''
# if(lvl<=MaxLogLevelToShow):
# if(lvl==0): print('')
# printAtLvl(lvl, mesg, '| ')
#
# def cdErr(mesg):
# global lastLogMesgs
# global highestLvl
# highestLvl+=1
# lastLogMesgs[highestLvl]="\n\nError: "+mesg
# exit(1)
#
# def logLvl():
# return highestLvl+1
, which may contain function names, class names, or code. Output only the next line. | cdlog(logLvl(), "EXTRACTING {}".format(className)) |
Given the following code snippet before the placeholder: <|code_start|>#///////////////// pattern_WriteCallProxy.py
#///////////////// Use this pattern to gererate call proxies. e.g. callback functions
def findStructRef(classes, structTypeName):
structRef = progSpec.findSpecOf(classes, structTypeName, 'struct')
if structRef==None:
<|code_end|>
, predict the next line using imports from the current file:
import progSpec
import codeDogParser
from progSpec import cdlog, cdErr
and context including class names, function names, and sometimes code from other files:
# Path: progSpec.py
# def cdlog(lvl, mesg):
# global MaxLogLevelToShow
# global lastLogMesgs
# global highestLvl
# highestLvl=lvl
# resizeLogArray(lvl)
# lastLogMesgs[lvl]=mesg
# for i in range(highestLvl+1, len(lastLogMesgs)):
# lastLogMesgs[i]=''
# if(lvl<=MaxLogLevelToShow):
# if(lvl==0): print('')
# printAtLvl(lvl, mesg, '| ')
#
# def cdErr(mesg):
# global lastLogMesgs
# global highestLvl
# highestLvl+=1
# lastLogMesgs[highestLvl]="\n\nError: "+mesg
# exit(1)
. Output only the next line. | cdErr('To build a list GUI for list of "'+structTypeName+'" a struct is needed but is not found.') |
Predict the next line for this snippet: <|code_start|> if returnCode!=0 or (errText and (errText.find("ERROR")) >= 0 or errText.find("error")>=0):
print("ERRORS:---------------\n")
#print(string_escape(str(errText))[2:-1])
print(errText)
print("----------------------\n")
return returnCode
def makeDirs(dirToGen):
#print("dirToGen:", dirToGen)
try:
os.makedirs(dirToGen, exist_ok=True)
except FileExistsError:
# Another thread was already created the directory when
# several simultaneous requests has come
if os.path.isdir(os.path.dirname(dirToGen)):
pass
else:
raise
except OSError as exception:
print("ERROR MAKING_DIR", exception)
if exception.errno != errno.EEXIST: raise
def writeFile(path, fileName, fileSpecs, fileExtension):
#print path
makeDirs(path)
fileName += fileExtension
pathName = path + os.sep + fileName
<|code_end|>
with the help of current file imports:
import progSpec
import os
import subprocess
import buildAndroid
import buildMac
import errno
import shutil
import checkSys
import environmentMngr as emgr
import urllib.request
from progSpec import cdlog, cdErr
from pathlib import Path
from git import Repo
and context from other files:
# Path: progSpec.py
# def cdlog(lvl, mesg):
# global MaxLogLevelToShow
# global lastLogMesgs
# global highestLvl
# highestLvl=lvl
# resizeLogArray(lvl)
# lastLogMesgs[lvl]=mesg
# for i in range(highestLvl+1, len(lastLogMesgs)):
# lastLogMesgs[i]=''
# if(lvl<=MaxLogLevelToShow):
# if(lvl==0): print('')
# printAtLvl(lvl, mesg, '| ')
#
# def cdErr(mesg):
# global lastLogMesgs
# global highestLvl
# highestLvl+=1
# lastLogMesgs[highestLvl]="\n\nError: "+mesg
# exit(1)
, which may contain function names, class names, or code. Output only the next line. | cdlog(1, "WRITING FILE: "+pathName) |
Predict the next line for this snippet: <|code_start|>
def downloadExtractZip(downloadUrl, packageName, packageDirectory):
zipExtension = ""
if downloadUrl.endswith(".zip"):
zipExtension = ".zip"
elif downloadUrl.endswith(".tar.gz"):
zipExtension = ".tar.gz"
elif downloadUrl.endswith(".tar.bz2"):
zipExtension = ".tar.bz2"
elif downloadUrl.endswith(".tar.xz"):
zipExtension = ".tar.xz"
elif downloadUrl.endswith(".tar"):
zipExtension = ".tar"
else:
pass
zipFileDirectory = packageDirectory + '/' + packageName
innerPackageName = packageName # TODO: get actual innerPackageName
innerPackageDir = zipFileDirectory + '/' + innerPackageName
packagePath = zipFileDirectory + '/' + packageName + zipExtension
checkDirectory = os.path.isdir(zipFileDirectory)
zipFileName = os.path.basename(downloadUrl)
if not checkDirectory:
makeDirs(zipFileDirectory + "/INSTALL")
emgr.downloadFile(packagePath, downloadUrl)
try:
cdlog(1, "Extracting zip file: " + zipFileName)
shutil.unpack_archive(packagePath, zipFileDirectory)
except:
<|code_end|>
with the help of current file imports:
import progSpec
import os
import subprocess
import buildAndroid
import buildMac
import errno
import shutil
import checkSys
import environmentMngr as emgr
import urllib.request
from progSpec import cdlog, cdErr
from pathlib import Path
from git import Repo
and context from other files:
# Path: progSpec.py
# def cdlog(lvl, mesg):
# global MaxLogLevelToShow
# global lastLogMesgs
# global highestLvl
# highestLvl=lvl
# resizeLogArray(lvl)
# lastLogMesgs[lvl]=mesg
# for i in range(highestLvl+1, len(lastLogMesgs)):
# lastLogMesgs[i]=''
# if(lvl<=MaxLogLevelToShow):
# if(lvl==0): print('')
# printAtLvl(lvl, mesg, '| ')
#
# def cdErr(mesg):
# global lastLogMesgs
# global highestLvl
# highestLvl+=1
# lastLogMesgs[highestLvl]="\n\nError: "+mesg
# exit(1)
, which may contain function names, class names, or code. Output only the next line. | cdErr("Could not extract zip archive file: " + zipFileName) |
Given snippet: <|code_start|> appendRule('RdxSeq', 'term', 'parseAUTO', 'a number')
appendRule('alphaNumSeq', 'term', 'parseAUTO', "an alpha-numeric string")
appendRule('ws', 'term', 'parseAUTO', 'white space')
appendRule('wsc', 'term', 'parseAUTO', 'white space or C comment')
appendRule('quotedStr', 'term', 'parseAUTO', "a quoted string with single or double quotes and escapes")
appendRule('quotedStr1', 'term', 'parseAUTO', "a single quoted string with escapes")
appendRule('quotedStr2', 'term', 'parseAUTO', "a double quoted string with escapes")
appendRule('HexNum_str', 'term', 'parseAUTO', "a hexadecimal number")
appendRule('BinNum_str', 'term', 'parseAUTO', "a binary number")
appendRule('BigInt', 'term', 'parseAUTO', "an integer")
appendRule('FlexNum', 'term', 'parseAUTO', "a rational number")
appendRule('CID', 'term', 'parseAUTO', 'a C-like identifier')
appendRule('UniID', 'term', 'parseAUTO', 'a unicode identifier')
appendRule('printables', 'term', 'parseAUTO', "a seqence of printable chars")
appendRule('toEOL', 'term', 'parseAUTO', "read to End Of Line, including EOL.")
# TODO: delimited List, keyWord
nextParseNameID=0 # Global used to uniquify sub-seqs and sub-alts in a struct parse. E.g.: ruleName: parse_myStruct_sub1
def fetchOrWriteTerminalParseRule(modelName, field, logLvl):
global nextParseNameID
#print "FIELD_IN:", modelName, field
fieldName='N/A'
fieldValue=''
if 'value' in field: fieldValue =field['value']
typeSpec = field['typeSpec']
fieldType = progSpec.getFieldType(typeSpec)
fieldOwner = typeSpec['owner']
if 'fieldName' in field: fieldName =field['fieldName']
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import re
import progSpec
import codeDogParser
from progSpec import cdlog, cdErr
and context:
# Path: progSpec.py
# def cdlog(lvl, mesg):
# global MaxLogLevelToShow
# global lastLogMesgs
# global highestLvl
# highestLvl=lvl
# resizeLogArray(lvl)
# lastLogMesgs[lvl]=mesg
# for i in range(highestLvl+1, len(lastLogMesgs)):
# lastLogMesgs[i]=''
# if(lvl<=MaxLogLevelToShow):
# if(lvl==0): print('')
# printAtLvl(lvl, mesg, '| ')
#
# def cdErr(mesg):
# global lastLogMesgs
# global highestLvl
# highestLvl+=1
# lastLogMesgs[highestLvl]="\n\nError: "+mesg
# exit(1)
which might include code, classes, or functions. Output only the next line. | cdlog(logLvl, "WRITING PARSE RULE for: {}.{}".format(modelName, fieldName)) |
Given the following code snippet before the placeholder: <|code_start|> partIndexes.append(ruleIdxStr)
else: pass; # These fields probably have corresponding cofactuals
nameOut=appendRule(nameIn, "nonterm", SeqOrAlt, partIndexes)
return nameOut
####################################################### E x t r a c t i o n F u n c t i o n s
def getFunctionName(fromName, toName):
if len(fromName)>=5 and fromName[-5:-3]=='::': fromName=fromName[:-5]
if len(toName)>=5 and toName[-5:-3]=='::': toName=toName[:-5]
S='Extract_'+fromName.replace('::', '_')+'_to_'+toName.replace('::', '_')
return S
def fetchMemVersion(classes, objName):
if objName=='[' or objName=='{': return [None, None]
memObj = progSpec.findSpecOf(classes[0], objName, 'struct')
if memObj==None: return [None, None]
return [memObj, objName]
def Write_ALT_Extracter(classes, parentStructName, fields, VarTagBase, VarTagSuffix, VarName, indent, level, logLvl):
# Structname should be the name of the structure being parsed. It will be converted to the mem version to get 'to' fields.
# Fields is the list of alternates.
# VarTag is a string used to create local variables.
# VarName is the LVAL variable name.
global globalFieldCount
cdlog(logLvl, "WRITING code to extract one of {} from parse tree...".format(parentStructName))
InnerMemObjFields = []
progSpec.populateCallableStructFields(InnerMemObjFields, classes, parentStructName)
<|code_end|>
, predict the next line using imports from the current file:
import re
import progSpec
import codeDogParser
from progSpec import cdlog, cdErr
and context including class names, function names, and sometimes code from other files:
# Path: progSpec.py
# def cdlog(lvl, mesg):
# global MaxLogLevelToShow
# global lastLogMesgs
# global highestLvl
# highestLvl=lvl
# resizeLogArray(lvl)
# lastLogMesgs[lvl]=mesg
# for i in range(highestLvl+1, len(lastLogMesgs)):
# lastLogMesgs[i]=''
# if(lvl<=MaxLogLevelToShow):
# if(lvl==0): print('')
# printAtLvl(lvl, mesg, '| ')
#
# def cdErr(mesg):
# global lastLogMesgs
# global highestLvl
# highestLvl+=1
# lastLogMesgs[highestLvl]="\n\nError: "+mesg
# exit(1)
. Output only the next line. | if parentStructName.find('::') != -1: cdErr("TODO: Make string parsing work on derived classes. Probably just select the correct fields for the destination struct.") |
Given the following code snippet before the placeholder: <|code_start|> classesToProcess.append(structTypeName)
if(fldCat=='struct'):
S=" "+'SRet_ <- SRet_ + indent + dispFieldAsText("'+label+'", 15) + "\\n"\n SRet_ <- SRet_ + '+valStr+'+ "\\n"\n'
else:
ender=''
starter=''
if(fldCat=='flag' or fldCat=='bool'):
starter = 'if('+fieldName+'){'
ender = '}'
elif(fldCat=='int' or fldCat=='double'):
starter = 'if('+fieldName+'!=0){'
ender = '}'
S=" "+starter+'SRet_ <- SRet_ + indent + dispFieldAsText("'+label+'", 15) + '+valStr+' + "\\n"\n'+ender
return S
def processField(self, fieldName, field, fldCat):
S=""
itemName = '_'+fieldName+'_item'
if fldCat=='func': return ''
typeSpec=field['typeSpec']
if progSpec.isAContainer(typeSpec):
if(progSpec.getDatastructID(typeSpec) == "list"):
innerFieldType=progSpec.getFieldType(typeSpec)
#print "ARRAYSPEC:",innerFieldType, field
fldCatInner=progSpec.innerTypeCategory(innerFieldType)
itemName = '_'+fieldName+'_item'
calcdName=fieldName+'["+toString('+itemName+'_key)+"]'
S+=" withEach "+itemName+" in "+fieldName+"{\n"
S+=" "+self.displayTextFieldAction(calcdName, itemName, field, fldCatInner)+" }\n"
else:
<|code_end|>
, predict the next line using imports from the current file:
import progSpec
import codeDogParser
import pattern_GenSymbols
from progSpec import cdlog, cdErr
and context including class names, function names, and sometimes code from other files:
# Path: progSpec.py
# def cdlog(lvl, mesg):
# global MaxLogLevelToShow
# global lastLogMesgs
# global highestLvl
# highestLvl=lvl
# resizeLogArray(lvl)
# lastLogMesgs[lvl]=mesg
# for i in range(highestLvl+1, len(lastLogMesgs)):
# lastLogMesgs[i]=''
# if(lvl<=MaxLogLevelToShow):
# if(lvl==0): print('')
# printAtLvl(lvl, mesg, '| ')
#
# def cdErr(mesg):
# global lastLogMesgs
# global highestLvl
# highestLvl+=1
# lastLogMesgs[highestLvl]="\n\nError: "+mesg
# exit(1)
. Output only the next line. | cdlog(2, "Map not supported") |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.