Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Given the code snippet: <|code_start|>
# compound()
class CompoundMatchRule(SubtreeMatchRule):
def __str__(self) -> str:
return str(categorization.Category('compound', self._positive_properties,
self._negative_properties))
def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
# Stop before the term that immediately precedes the head
for index in range(head_index - 1):
if ((not self._positive_properties <= category_list[index].positive_properties) or
<|code_end|>
, generate the next line using the imports in this file:
from typing import Sequence
from pyramids import categorization
from pyramids.categorization import Category
from pyramids.rules.subtree_match import SubtreeMatchRule
and context (functions, classes, or occasionally code) from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/subtree_match.py
# class SubtreeMatchRule:
#
# def __init__(self, positive_properties: Iterable[Property],
# negative_properties: Iterable[Property]):
# self._positive_properties = make_property_set(positive_properties)
# self._negative_properties = make_property_set(negative_properties)
#
# @property
# def positive_properties(self) -> FrozenSet[Property]:
# return self._positive_properties
#
# @property
# def negative_properties(self) -> FrozenSet[Property]:
# return self._negative_properties
#
# def __str__(self) -> str:
# raise NotImplementedError()
#
# def __repr__(self) -> str:
# return (type(self).__name__ + "(" + repr(self._positive_properties) + ", " +
# repr(self._negative_properties) + ")")
#
# # def __eq__(self, other):
# # raise NotImplementedError()
# #
# # def __ne__(self, other):
# # raise NotImplementedError()
# #
# # def __le__(self, other):
# # raise NotImplementedError()
# #
# # def __ge__(self, other):
# # raise NotImplementedError()
# #
# # def __lt__(self, other):
# # raise NotImplementedError()
# #
# # def __gt__(self, other):
# # raise NotImplementedError()
#
# def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
# raise NotImplementedError()
. Output only the next line. | (self._negative_properties & category_list[index].positive_properties)): |
Given the code snippet: <|code_start|>
class SubtreeMatchRule:
def __init__(self, positive_properties: Iterable[Property],
negative_properties: Iterable[Property]):
self._positive_properties = make_property_set(positive_properties)
self._negative_properties = make_property_set(negative_properties)
<|code_end|>
, generate the next line using the imports in this file:
from typing import Iterable, FrozenSet, Sequence
from pyramids.categorization import make_property_set, Property, Category
and context (functions, classes, or occasionally code) from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
. Output only the next line. | @property |
Continue the code snippet: <|code_start|>
class SubtreeMatchRule:
def __init__(self, positive_properties: Iterable[Property],
negative_properties: Iterable[Property]):
self._positive_properties = make_property_set(positive_properties)
self._negative_properties = make_property_set(negative_properties)
@property
def positive_properties(self) -> FrozenSet[Property]:
return self._positive_properties
@property
def negative_properties(self) -> FrozenSet[Property]:
return self._negative_properties
def __str__(self) -> str:
<|code_end|>
. Use current file imports:
from typing import Iterable, FrozenSet, Sequence
from pyramids.categorization import make_property_set, Property, Category
and context (classes, functions, or code) from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
. Output only the next line. | raise NotImplementedError() |
Here is a snippet: <|code_start|>
class SubtreeMatchRule:
def __init__(self, positive_properties: Iterable[Property],
negative_properties: Iterable[Property]):
self._positive_properties = make_property_set(positive_properties)
self._negative_properties = make_property_set(negative_properties)
@property
def positive_properties(self) -> FrozenSet[Property]:
return self._positive_properties
@property
def negative_properties(self) -> FrozenSet[Property]:
return self._negative_properties
def __str__(self) -> str:
raise NotImplementedError()
def __repr__(self) -> str:
return (type(self).__name__ + "(" + repr(self._positive_properties) + ", " +
<|code_end|>
. Write the next line using the current file imports:
from typing import Iterable, FrozenSet, Sequence
from pyramids.categorization import make_property_set, Property, Category
and context from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
, which may include functions, classes, or code. Output only the next line. | repr(self._negative_properties) + ")") |
Here is a snippet: <|code_start|> assert case in (CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE)
super().__init__(category)
self._case = case
self._hash = hash(self._category) ^ hash(self._case)
@property
def case(self) -> Property:
return self._case
def __hash__(self) -> int:
return self._hash
def __eq__(self, other: 'CaseRule') -> bool:
if not isinstance(other, CaseRule):
return NotImplemented
return self is other or (self._hash == other._hash and self._category == other._category and
self._case == other._case)
def __ne__(self, other: 'CaseRule') -> bool:
if not isinstance(other, CaseRule):
return NotImplemented
return not (self == other)
def __contains__(self, token: str) -> bool:
positive, negative = self.discover_case_properties(token)
return self._case in positive
def __repr__(self) -> str:
return type(self).__name__ + repr((self.category, str(self.case)))
<|code_end|>
. Write the next line using the current file imports:
from pyramids.categorization import Property, Category
from pyramids.rules.leaf import LeafRule
from pyramids.properties import CASE_FREE, MIXED_CASE, TITLE_CASE, UPPER_CASE, LOWER_CASE
and context from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/leaf.py
# class LeafRule(ParseRule):
# """Used by Parser to identify base-level (atomic) tokens, which are the
# leaves in a parse tree."""
#
# def __init__(self, category: Category):
# super().__init__()
# self._category = category
#
# @property
# def category(self) -> Category:
# return self._category
#
# def __contains__(self, token: str) -> bool:
# raise NotImplementedError()
#
# def __call__(self, parser_state: 'parsing.ParserState', new_token: str, index: int) -> bool:
# if new_token in self:
# positive, negative = self.discover_case_properties(new_token)
# category = self._category.promote_properties(positive, negative)
# category = extend_properties(parser_state.model, category)
# node = trees.ParseTreeUtils.make_leaf_parse_tree_node(parser_state.tokens, self, index,
# category)
# parser_state.add_node(node)
# return True
# else:
# return False
#
# @classmethod
# def discover_case_properties(cls, token: str) -> Tuple[Set[Property], Set[Property]]:
# token_uppered = token.upper()
# token_lowered = token.lower()
# positive = set()
# if token_uppered == token_lowered:
# positive.add(CASE_FREE)
# elif token == token_lowered:
# positive.add(LOWER_CASE)
# else:
# if token == token_uppered:
# positive.add(UPPER_CASE)
# if token == token.title():
# positive.add(TITLE_CASE)
# positive.add(MIXED_CASE)
# if not positive:
# positive.add(MIXED_CASE)
# negative = {CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE} - positive
# return positive, negative
#
# def iter_scoring_features(self, parse_node: trees.TreeNodeInterface) \
# -> Iterator[scoring.ScoringFeature]:
# # CAREFUL!!! Scoring features must be perfectly recoverable via
# # ast.literal_eval(repr(feature))
# head_cat = str(parse_node.payload.category.name)
# head_token = parse_node.payload.head_spelling
# yield scoring.ScoringFeature(('head spelling', (head_cat, head_token)))
# for prop in parse_node.payload.category.positive_properties:
# yield scoring.ScoringFeature(('head properties', (head_cat, str(prop))))
#
# Path: pyramids/properties.py
# CASE_FREE = Property.get("case_free")
#
# MIXED_CASE = Property.get("mixed_case")
#
# TITLE_CASE = Property.get("title_case")
#
# UPPER_CASE = Property.get("upper_case")
#
# LOWER_CASE = Property.get("lower_case")
, which may include functions, classes, or code. Output only the next line. | def __str__(self) -> str: |
Next line prediction: <|code_start|> super().__init__(category)
self._case = case
self._hash = hash(self._category) ^ hash(self._case)
@property
def case(self) -> Property:
return self._case
def __hash__(self) -> int:
return self._hash
def __eq__(self, other: 'CaseRule') -> bool:
if not isinstance(other, CaseRule):
return NotImplemented
return self is other or (self._hash == other._hash and self._category == other._category and
self._case == other._case)
def __ne__(self, other: 'CaseRule') -> bool:
if not isinstance(other, CaseRule):
return NotImplemented
return not (self == other)
def __contains__(self, token: str) -> bool:
positive, negative = self.discover_case_properties(token)
return self._case in positive
def __repr__(self) -> str:
return type(self).__name__ + repr((self.category, str(self.case)))
def __str__(self) -> str:
<|code_end|>
. Use current file imports:
(from pyramids.categorization import Property, Category
from pyramids.rules.leaf import LeafRule
from pyramids.properties import CASE_FREE, MIXED_CASE, TITLE_CASE, UPPER_CASE, LOWER_CASE)
and context including class names, function names, or small code snippets from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/leaf.py
# class LeafRule(ParseRule):
# """Used by Parser to identify base-level (atomic) tokens, which are the
# leaves in a parse tree."""
#
# def __init__(self, category: Category):
# super().__init__()
# self._category = category
#
# @property
# def category(self) -> Category:
# return self._category
#
# def __contains__(self, token: str) -> bool:
# raise NotImplementedError()
#
# def __call__(self, parser_state: 'parsing.ParserState', new_token: str, index: int) -> bool:
# if new_token in self:
# positive, negative = self.discover_case_properties(new_token)
# category = self._category.promote_properties(positive, negative)
# category = extend_properties(parser_state.model, category)
# node = trees.ParseTreeUtils.make_leaf_parse_tree_node(parser_state.tokens, self, index,
# category)
# parser_state.add_node(node)
# return True
# else:
# return False
#
# @classmethod
# def discover_case_properties(cls, token: str) -> Tuple[Set[Property], Set[Property]]:
# token_uppered = token.upper()
# token_lowered = token.lower()
# positive = set()
# if token_uppered == token_lowered:
# positive.add(CASE_FREE)
# elif token == token_lowered:
# positive.add(LOWER_CASE)
# else:
# if token == token_uppered:
# positive.add(UPPER_CASE)
# if token == token.title():
# positive.add(TITLE_CASE)
# positive.add(MIXED_CASE)
# if not positive:
# positive.add(MIXED_CASE)
# negative = {CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE} - positive
# return positive, negative
#
# def iter_scoring_features(self, parse_node: trees.TreeNodeInterface) \
# -> Iterator[scoring.ScoringFeature]:
# # CAREFUL!!! Scoring features must be perfectly recoverable via
# # ast.literal_eval(repr(feature))
# head_cat = str(parse_node.payload.category.name)
# head_token = parse_node.payload.head_spelling
# yield scoring.ScoringFeature(('head spelling', (head_cat, head_token)))
# for prop in parse_node.payload.category.positive_properties:
# yield scoring.ScoringFeature(('head properties', (head_cat, str(prop))))
#
# Path: pyramids/properties.py
# CASE_FREE = Property.get("case_free")
#
# MIXED_CASE = Property.get("mixed_case")
#
# TITLE_CASE = Property.get("title_case")
#
# UPPER_CASE = Property.get("upper_case")
#
# LOWER_CASE = Property.get("lower_case")
. Output only the next line. | return self.case + '->' + str(self.category) |
Based on the snippet: <|code_start|>
class CaseRule(LeafRule):
def __init__(self, category: Category, case: Property):
case = Property.get(case)
assert case in (CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE)
super().__init__(category)
self._case = case
self._hash = hash(self._category) ^ hash(self._case)
@property
def case(self) -> Property:
return self._case
def __hash__(self) -> int:
return self._hash
def __eq__(self, other: 'CaseRule') -> bool:
if not isinstance(other, CaseRule):
return NotImplemented
return self is other or (self._hash == other._hash and self._category == other._category and
<|code_end|>
, predict the immediate next line with the help of imports:
from pyramids.categorization import Property, Category
from pyramids.rules.leaf import LeafRule
from pyramids.properties import CASE_FREE, MIXED_CASE, TITLE_CASE, UPPER_CASE, LOWER_CASE
and context (classes, functions, sometimes code) from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/leaf.py
# class LeafRule(ParseRule):
# """Used by Parser to identify base-level (atomic) tokens, which are the
# leaves in a parse tree."""
#
# def __init__(self, category: Category):
# super().__init__()
# self._category = category
#
# @property
# def category(self) -> Category:
# return self._category
#
# def __contains__(self, token: str) -> bool:
# raise NotImplementedError()
#
# def __call__(self, parser_state: 'parsing.ParserState', new_token: str, index: int) -> bool:
# if new_token in self:
# positive, negative = self.discover_case_properties(new_token)
# category = self._category.promote_properties(positive, negative)
# category = extend_properties(parser_state.model, category)
# node = trees.ParseTreeUtils.make_leaf_parse_tree_node(parser_state.tokens, self, index,
# category)
# parser_state.add_node(node)
# return True
# else:
# return False
#
# @classmethod
# def discover_case_properties(cls, token: str) -> Tuple[Set[Property], Set[Property]]:
# token_uppered = token.upper()
# token_lowered = token.lower()
# positive = set()
# if token_uppered == token_lowered:
# positive.add(CASE_FREE)
# elif token == token_lowered:
# positive.add(LOWER_CASE)
# else:
# if token == token_uppered:
# positive.add(UPPER_CASE)
# if token == token.title():
# positive.add(TITLE_CASE)
# positive.add(MIXED_CASE)
# if not positive:
# positive.add(MIXED_CASE)
# negative = {CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE} - positive
# return positive, negative
#
# def iter_scoring_features(self, parse_node: trees.TreeNodeInterface) \
# -> Iterator[scoring.ScoringFeature]:
# # CAREFUL!!! Scoring features must be perfectly recoverable via
# # ast.literal_eval(repr(feature))
# head_cat = str(parse_node.payload.category.name)
# head_token = parse_node.payload.head_spelling
# yield scoring.ScoringFeature(('head spelling', (head_cat, head_token)))
# for prop in parse_node.payload.category.positive_properties:
# yield scoring.ScoringFeature(('head properties', (head_cat, str(prop))))
#
# Path: pyramids/properties.py
# CASE_FREE = Property.get("case_free")
#
# MIXED_CASE = Property.get("mixed_case")
#
# TITLE_CASE = Property.get("title_case")
#
# UPPER_CASE = Property.get("upper_case")
#
# LOWER_CASE = Property.get("lower_case")
. Output only the next line. | self._case == other._case) |
Predict the next line for this snippet: <|code_start|>
class CaseRule(LeafRule):
def __init__(self, category: Category, case: Property):
case = Property.get(case)
assert case in (CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE)
super().__init__(category)
self._case = case
self._hash = hash(self._category) ^ hash(self._case)
@property
def case(self) -> Property:
return self._case
def __hash__(self) -> int:
<|code_end|>
with the help of current file imports:
from pyramids.categorization import Property, Category
from pyramids.rules.leaf import LeafRule
from pyramids.properties import CASE_FREE, MIXED_CASE, TITLE_CASE, UPPER_CASE, LOWER_CASE
and context from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/leaf.py
# class LeafRule(ParseRule):
# """Used by Parser to identify base-level (atomic) tokens, which are the
# leaves in a parse tree."""
#
# def __init__(self, category: Category):
# super().__init__()
# self._category = category
#
# @property
# def category(self) -> Category:
# return self._category
#
# def __contains__(self, token: str) -> bool:
# raise NotImplementedError()
#
# def __call__(self, parser_state: 'parsing.ParserState', new_token: str, index: int) -> bool:
# if new_token in self:
# positive, negative = self.discover_case_properties(new_token)
# category = self._category.promote_properties(positive, negative)
# category = extend_properties(parser_state.model, category)
# node = trees.ParseTreeUtils.make_leaf_parse_tree_node(parser_state.tokens, self, index,
# category)
# parser_state.add_node(node)
# return True
# else:
# return False
#
# @classmethod
# def discover_case_properties(cls, token: str) -> Tuple[Set[Property], Set[Property]]:
# token_uppered = token.upper()
# token_lowered = token.lower()
# positive = set()
# if token_uppered == token_lowered:
# positive.add(CASE_FREE)
# elif token == token_lowered:
# positive.add(LOWER_CASE)
# else:
# if token == token_uppered:
# positive.add(UPPER_CASE)
# if token == token.title():
# positive.add(TITLE_CASE)
# positive.add(MIXED_CASE)
# if not positive:
# positive.add(MIXED_CASE)
# negative = {CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE} - positive
# return positive, negative
#
# def iter_scoring_features(self, parse_node: trees.TreeNodeInterface) \
# -> Iterator[scoring.ScoringFeature]:
# # CAREFUL!!! Scoring features must be perfectly recoverable via
# # ast.literal_eval(repr(feature))
# head_cat = str(parse_node.payload.category.name)
# head_token = parse_node.payload.head_spelling
# yield scoring.ScoringFeature(('head spelling', (head_cat, head_token)))
# for prop in parse_node.payload.category.positive_properties:
# yield scoring.ScoringFeature(('head properties', (head_cat, str(prop))))
#
# Path: pyramids/properties.py
# CASE_FREE = Property.get("case_free")
#
# MIXED_CASE = Property.get("mixed_case")
#
# TITLE_CASE = Property.get("title_case")
#
# UPPER_CASE = Property.get("upper_case")
#
# LOWER_CASE = Property.get("lower_case")
, which may contain function names, class names, or code. Output only the next line. | return self._hash |
Based on the snippet: <|code_start|>
class CaseRule(LeafRule):
def __init__(self, category: Category, case: Property):
case = Property.get(case)
assert case in (CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE)
super().__init__(category)
<|code_end|>
, predict the immediate next line with the help of imports:
from pyramids.categorization import Property, Category
from pyramids.rules.leaf import LeafRule
from pyramids.properties import CASE_FREE, MIXED_CASE, TITLE_CASE, UPPER_CASE, LOWER_CASE
and context (classes, functions, sometimes code) from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/leaf.py
# class LeafRule(ParseRule):
# """Used by Parser to identify base-level (atomic) tokens, which are the
# leaves in a parse tree."""
#
# def __init__(self, category: Category):
# super().__init__()
# self._category = category
#
# @property
# def category(self) -> Category:
# return self._category
#
# def __contains__(self, token: str) -> bool:
# raise NotImplementedError()
#
# def __call__(self, parser_state: 'parsing.ParserState', new_token: str, index: int) -> bool:
# if new_token in self:
# positive, negative = self.discover_case_properties(new_token)
# category = self._category.promote_properties(positive, negative)
# category = extend_properties(parser_state.model, category)
# node = trees.ParseTreeUtils.make_leaf_parse_tree_node(parser_state.tokens, self, index,
# category)
# parser_state.add_node(node)
# return True
# else:
# return False
#
# @classmethod
# def discover_case_properties(cls, token: str) -> Tuple[Set[Property], Set[Property]]:
# token_uppered = token.upper()
# token_lowered = token.lower()
# positive = set()
# if token_uppered == token_lowered:
# positive.add(CASE_FREE)
# elif token == token_lowered:
# positive.add(LOWER_CASE)
# else:
# if token == token_uppered:
# positive.add(UPPER_CASE)
# if token == token.title():
# positive.add(TITLE_CASE)
# positive.add(MIXED_CASE)
# if not positive:
# positive.add(MIXED_CASE)
# negative = {CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE} - positive
# return positive, negative
#
# def iter_scoring_features(self, parse_node: trees.TreeNodeInterface) \
# -> Iterator[scoring.ScoringFeature]:
# # CAREFUL!!! Scoring features must be perfectly recoverable via
# # ast.literal_eval(repr(feature))
# head_cat = str(parse_node.payload.category.name)
# head_token = parse_node.payload.head_spelling
# yield scoring.ScoringFeature(('head spelling', (head_cat, head_token)))
# for prop in parse_node.payload.category.positive_properties:
# yield scoring.ScoringFeature(('head properties', (head_cat, str(prop))))
#
# Path: pyramids/properties.py
# CASE_FREE = Property.get("case_free")
#
# MIXED_CASE = Property.get("mixed_case")
#
# TITLE_CASE = Property.get("title_case")
#
# UPPER_CASE = Property.get("upper_case")
#
# LOWER_CASE = Property.get("lower_case")
. Output only the next line. | self._case = case |
Next line prediction: <|code_start|>
class CaseRule(LeafRule):
def __init__(self, category: Category, case: Property):
case = Property.get(case)
assert case in (CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE)
super().__init__(category)
self._case = case
self._hash = hash(self._category) ^ hash(self._case)
@property
def case(self) -> Property:
return self._case
def __hash__(self) -> int:
<|code_end|>
. Use current file imports:
(from pyramids.categorization import Property, Category
from pyramids.rules.leaf import LeafRule
from pyramids.properties import CASE_FREE, MIXED_CASE, TITLE_CASE, UPPER_CASE, LOWER_CASE)
and context including class names, function names, or small code snippets from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/leaf.py
# class LeafRule(ParseRule):
# """Used by Parser to identify base-level (atomic) tokens, which are the
# leaves in a parse tree."""
#
# def __init__(self, category: Category):
# super().__init__()
# self._category = category
#
# @property
# def category(self) -> Category:
# return self._category
#
# def __contains__(self, token: str) -> bool:
# raise NotImplementedError()
#
# def __call__(self, parser_state: 'parsing.ParserState', new_token: str, index: int) -> bool:
# if new_token in self:
# positive, negative = self.discover_case_properties(new_token)
# category = self._category.promote_properties(positive, negative)
# category = extend_properties(parser_state.model, category)
# node = trees.ParseTreeUtils.make_leaf_parse_tree_node(parser_state.tokens, self, index,
# category)
# parser_state.add_node(node)
# return True
# else:
# return False
#
# @classmethod
# def discover_case_properties(cls, token: str) -> Tuple[Set[Property], Set[Property]]:
# token_uppered = token.upper()
# token_lowered = token.lower()
# positive = set()
# if token_uppered == token_lowered:
# positive.add(CASE_FREE)
# elif token == token_lowered:
# positive.add(LOWER_CASE)
# else:
# if token == token_uppered:
# positive.add(UPPER_CASE)
# if token == token.title():
# positive.add(TITLE_CASE)
# positive.add(MIXED_CASE)
# if not positive:
# positive.add(MIXED_CASE)
# negative = {CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE} - positive
# return positive, negative
#
# def iter_scoring_features(self, parse_node: trees.TreeNodeInterface) \
# -> Iterator[scoring.ScoringFeature]:
# # CAREFUL!!! Scoring features must be perfectly recoverable via
# # ast.literal_eval(repr(feature))
# head_cat = str(parse_node.payload.category.name)
# head_token = parse_node.payload.head_spelling
# yield scoring.ScoringFeature(('head spelling', (head_cat, head_token)))
# for prop in parse_node.payload.category.positive_properties:
# yield scoring.ScoringFeature(('head properties', (head_cat, str(prop))))
#
# Path: pyramids/properties.py
# CASE_FREE = Property.get("case_free")
#
# MIXED_CASE = Property.get("mixed_case")
#
# TITLE_CASE = Property.get("title_case")
#
# UPPER_CASE = Property.get("upper_case")
#
# LOWER_CASE = Property.get("lower_case")
. Output only the next line. | return self._hash |
Based on the snippet: <|code_start|>
class CaseRule(LeafRule):
def __init__(self, category: Category, case: Property):
case = Property.get(case)
assert case in (CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE)
super().__init__(category)
self._case = case
self._hash = hash(self._category) ^ hash(self._case)
@property
def case(self) -> Property:
return self._case
<|code_end|>
, predict the immediate next line with the help of imports:
from pyramids.categorization import Property, Category
from pyramids.rules.leaf import LeafRule
from pyramids.properties import CASE_FREE, MIXED_CASE, TITLE_CASE, UPPER_CASE, LOWER_CASE
and context (classes, functions, sometimes code) from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/leaf.py
# class LeafRule(ParseRule):
# """Used by Parser to identify base-level (atomic) tokens, which are the
# leaves in a parse tree."""
#
# def __init__(self, category: Category):
# super().__init__()
# self._category = category
#
# @property
# def category(self) -> Category:
# return self._category
#
# def __contains__(self, token: str) -> bool:
# raise NotImplementedError()
#
# def __call__(self, parser_state: 'parsing.ParserState', new_token: str, index: int) -> bool:
# if new_token in self:
# positive, negative = self.discover_case_properties(new_token)
# category = self._category.promote_properties(positive, negative)
# category = extend_properties(parser_state.model, category)
# node = trees.ParseTreeUtils.make_leaf_parse_tree_node(parser_state.tokens, self, index,
# category)
# parser_state.add_node(node)
# return True
# else:
# return False
#
# @classmethod
# def discover_case_properties(cls, token: str) -> Tuple[Set[Property], Set[Property]]:
# token_uppered = token.upper()
# token_lowered = token.lower()
# positive = set()
# if token_uppered == token_lowered:
# positive.add(CASE_FREE)
# elif token == token_lowered:
# positive.add(LOWER_CASE)
# else:
# if token == token_uppered:
# positive.add(UPPER_CASE)
# if token == token.title():
# positive.add(TITLE_CASE)
# positive.add(MIXED_CASE)
# if not positive:
# positive.add(MIXED_CASE)
# negative = {CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE} - positive
# return positive, negative
#
# def iter_scoring_features(self, parse_node: trees.TreeNodeInterface) \
# -> Iterator[scoring.ScoringFeature]:
# # CAREFUL!!! Scoring features must be perfectly recoverable via
# # ast.literal_eval(repr(feature))
# head_cat = str(parse_node.payload.category.name)
# head_token = parse_node.payload.head_spelling
# yield scoring.ScoringFeature(('head spelling', (head_cat, head_token)))
# for prop in parse_node.payload.category.positive_properties:
# yield scoring.ScoringFeature(('head properties', (head_cat, str(prop))))
#
# Path: pyramids/properties.py
# CASE_FREE = Property.get("case_free")
#
# MIXED_CASE = Property.get("mixed_case")
#
# TITLE_CASE = Property.get("title_case")
#
# UPPER_CASE = Property.get("upper_case")
#
# LOWER_CASE = Property.get("lower_case")
. Output only the next line. | def __hash__(self) -> int: |
Continue the code snippet: <|code_start|>
class CaseRule(LeafRule):
def __init__(self, category: Category, case: Property):
case = Property.get(case)
assert case in (CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE)
super().__init__(category)
<|code_end|>
. Use current file imports:
from pyramids.categorization import Property, Category
from pyramids.rules.leaf import LeafRule
from pyramids.properties import CASE_FREE, MIXED_CASE, TITLE_CASE, UPPER_CASE, LOWER_CASE
and context (classes, functions, or code) from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/leaf.py
# class LeafRule(ParseRule):
# """Used by Parser to identify base-level (atomic) tokens, which are the
# leaves in a parse tree."""
#
# def __init__(self, category: Category):
# super().__init__()
# self._category = category
#
# @property
# def category(self) -> Category:
# return self._category
#
# def __contains__(self, token: str) -> bool:
# raise NotImplementedError()
#
# def __call__(self, parser_state: 'parsing.ParserState', new_token: str, index: int) -> bool:
# if new_token in self:
# positive, negative = self.discover_case_properties(new_token)
# category = self._category.promote_properties(positive, negative)
# category = extend_properties(parser_state.model, category)
# node = trees.ParseTreeUtils.make_leaf_parse_tree_node(parser_state.tokens, self, index,
# category)
# parser_state.add_node(node)
# return True
# else:
# return False
#
# @classmethod
# def discover_case_properties(cls, token: str) -> Tuple[Set[Property], Set[Property]]:
# token_uppered = token.upper()
# token_lowered = token.lower()
# positive = set()
# if token_uppered == token_lowered:
# positive.add(CASE_FREE)
# elif token == token_lowered:
# positive.add(LOWER_CASE)
# else:
# if token == token_uppered:
# positive.add(UPPER_CASE)
# if token == token.title():
# positive.add(TITLE_CASE)
# positive.add(MIXED_CASE)
# if not positive:
# positive.add(MIXED_CASE)
# negative = {CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE} - positive
# return positive, negative
#
# def iter_scoring_features(self, parse_node: trees.TreeNodeInterface) \
# -> Iterator[scoring.ScoringFeature]:
# # CAREFUL!!! Scoring features must be perfectly recoverable via
# # ast.literal_eval(repr(feature))
# head_cat = str(parse_node.payload.category.name)
# head_token = parse_node.payload.head_spelling
# yield scoring.ScoringFeature(('head spelling', (head_cat, head_token)))
# for prop in parse_node.payload.category.positive_properties:
# yield scoring.ScoringFeature(('head properties', (head_cat, str(prop))))
#
# Path: pyramids/properties.py
# CASE_FREE = Property.get("case_free")
#
# MIXED_CASE = Property.get("mixed_case")
#
# TITLE_CASE = Property.get("title_case")
#
# UPPER_CASE = Property.get("upper_case")
#
# LOWER_CASE = Property.get("lower_case")
. Output only the next line. | self._case = case |
Predict the next line after this snippet: <|code_start|> total_weight += weight
return total_score, total_weight
def adjust_score(self, parse_node: 'trees.TreeNodeInterface', target: float) -> None:
if not 0 <= target <= 1:
raise ValueError("Score target must be in the interval [0, 1].")
default_score, default_weight, count = self._scoring_features[None]
count += 1
error = (target - default_score) ** 2
weight_target = 1 - error
default_score += (target - default_score) / count
default_weight += (weight_target - default_weight) / count
self._scoring_features[None] = (default_score, default_weight, count)
for feature in self.iter_scoring_features(parse_node):
if feature in self._scoring_features:
score, weight, count = self._scoring_features[feature]
count += 1
else:
score, weight, _ = self._scoring_features[None]
count = 2 # Default is counted as 1, plus one new measurement
error = (target - score) ** 2
weight_target = 1 - error
score += (target - score) / count
weight += (weight_target - weight) / count
self._scoring_features[feature] = (score, weight, count)
def get_score(self, feature: scoring.ScoringFeature) -> Tuple[float, float, int]:
if feature in self._scoring_features:
return self._scoring_features[feature]
else:
<|code_end|>
using the current file's imports:
from typing import Tuple, Dict, Optional, Iterator, Union, TYPE_CHECKING
from pyramids import scoring
from pyramids import trees
and any relevant context from other files:
# Path: pyramids/scoring.py
# class ScoringFeature:
# def validate_key(cls, key: ScoringKey):
# def __init__(self, key: ScoringKey):
# def __hash__(self) -> int:
# def __eq__(self, other: 'ScoringFeature') -> bool:
# def __ne__(self, other: 'ScoringFeature') -> bool:
# def __str__(self) -> str:
# def __repr__(self) -> str:
# def key(self) -> ScoringKey:
. Output only the next line. | return 0, 0, 0 |
Given the code snippet: <|code_start|>
class SuffixRule(LeafRule):
def __init__(self, category: Category, suffixes: Iterable[str], positive: bool = True):
super().__init__(category)
self._suffixes = frozenset([suffix.lower() for suffix in suffixes])
self._positive = bool(positive)
self._hash = hash(self._category) ^ hash(self._suffixes) ^ hash(self._positive)
def __hash__(self) -> int:
<|code_end|>
, generate the next line using the imports in this file:
from typing import Iterable, FrozenSet
from pyramids.categorization import Category
from pyramids.rules.leaf import LeafRule
and context (functions, classes, or occasionally code) from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/leaf.py
# class LeafRule(ParseRule):
# """Used by Parser to identify base-level (atomic) tokens, which are the
# leaves in a parse tree."""
#
# def __init__(self, category: Category):
# super().__init__()
# self._category = category
#
# @property
# def category(self) -> Category:
# return self._category
#
# def __contains__(self, token: str) -> bool:
# raise NotImplementedError()
#
# def __call__(self, parser_state: 'parsing.ParserState', new_token: str, index: int) -> bool:
# if new_token in self:
# positive, negative = self.discover_case_properties(new_token)
# category = self._category.promote_properties(positive, negative)
# category = extend_properties(parser_state.model, category)
# node = trees.ParseTreeUtils.make_leaf_parse_tree_node(parser_state.tokens, self, index,
# category)
# parser_state.add_node(node)
# return True
# else:
# return False
#
# @classmethod
# def discover_case_properties(cls, token: str) -> Tuple[Set[Property], Set[Property]]:
# token_uppered = token.upper()
# token_lowered = token.lower()
# positive = set()
# if token_uppered == token_lowered:
# positive.add(CASE_FREE)
# elif token == token_lowered:
# positive.add(LOWER_CASE)
# else:
# if token == token_uppered:
# positive.add(UPPER_CASE)
# if token == token.title():
# positive.add(TITLE_CASE)
# positive.add(MIXED_CASE)
# if not positive:
# positive.add(MIXED_CASE)
# negative = {CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE} - positive
# return positive, negative
#
# def iter_scoring_features(self, parse_node: trees.TreeNodeInterface) \
# -> Iterator[scoring.ScoringFeature]:
# # CAREFUL!!! Scoring features must be perfectly recoverable via
# # ast.literal_eval(repr(feature))
# head_cat = str(parse_node.payload.category.name)
# head_token = parse_node.payload.head_spelling
# yield scoring.ScoringFeature(('head spelling', (head_cat, head_token)))
# for prop in parse_node.payload.category.positive_properties:
# yield scoring.ScoringFeature(('head properties', (head_cat, str(prop))))
. Output only the next line. | return self._hash |
Based on the snippet: <|code_start|> self._suffixes = frozenset([suffix.lower() for suffix in suffixes])
self._positive = bool(positive)
self._hash = hash(self._category) ^ hash(self._suffixes) ^ hash(self._positive)
def __hash__(self) -> int:
return self._hash
def __eq__(self, other: 'SuffixRule') -> bool:
if not isinstance(other, SuffixRule):
return NotImplemented
return self is other or (self._hash == other._hash and self._positive == other._positive and
self._category == other._category and
self._suffixes == other._suffixes)
def __ne__(self, other: 'SuffixRule') -> bool:
if not isinstance(other, SuffixRule):
return NotImplemented
return not (self == other)
def __contains__(self, token: str) -> bool:
token = token.lower()
for suffix in self._suffixes:
if len(token) > len(suffix) + 1 and token.endswith(suffix):
return self._positive
return not self._positive
def __repr__(self) -> str:
return (type(self).__name__ + "(" + repr(self.category) + ", " +
repr(sorted(self.suffixes)) + ", " + repr(self.positive) + ")")
<|code_end|>
, predict the immediate next line with the help of imports:
from typing import Iterable, FrozenSet
from pyramids.categorization import Category
from pyramids.rules.leaf import LeafRule
and context (classes, functions, sometimes code) from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/leaf.py
# class LeafRule(ParseRule):
# """Used by Parser to identify base-level (atomic) tokens, which are the
# leaves in a parse tree."""
#
# def __init__(self, category: Category):
# super().__init__()
# self._category = category
#
# @property
# def category(self) -> Category:
# return self._category
#
# def __contains__(self, token: str) -> bool:
# raise NotImplementedError()
#
# def __call__(self, parser_state: 'parsing.ParserState', new_token: str, index: int) -> bool:
# if new_token in self:
# positive, negative = self.discover_case_properties(new_token)
# category = self._category.promote_properties(positive, negative)
# category = extend_properties(parser_state.model, category)
# node = trees.ParseTreeUtils.make_leaf_parse_tree_node(parser_state.tokens, self, index,
# category)
# parser_state.add_node(node)
# return True
# else:
# return False
#
# @classmethod
# def discover_case_properties(cls, token: str) -> Tuple[Set[Property], Set[Property]]:
# token_uppered = token.upper()
# token_lowered = token.lower()
# positive = set()
# if token_uppered == token_lowered:
# positive.add(CASE_FREE)
# elif token == token_lowered:
# positive.add(LOWER_CASE)
# else:
# if token == token_uppered:
# positive.add(UPPER_CASE)
# if token == token.title():
# positive.add(TITLE_CASE)
# positive.add(MIXED_CASE)
# if not positive:
# positive.add(MIXED_CASE)
# negative = {CASE_FREE, LOWER_CASE, UPPER_CASE, TITLE_CASE, MIXED_CASE} - positive
# return positive, negative
#
# def iter_scoring_features(self, parse_node: trees.TreeNodeInterface) \
# -> Iterator[scoring.ScoringFeature]:
# # CAREFUL!!! Scoring features must be perfectly recoverable via
# # ast.literal_eval(repr(feature))
# head_cat = str(parse_node.payload.category.name)
# head_token = parse_node.payload.head_spelling
# yield scoring.ScoringFeature(('head spelling', (head_cat, head_token)))
# for prop in parse_node.payload.category.positive_properties:
# yield scoring.ScoringFeature(('head properties', (head_cat, str(prop))))
. Output only the next line. | def __str__(self) -> str: |
Given snippet: <|code_start|>
# head()
class HeadMatchRule(SubtreeMatchRule):
def __str__(self) -> str:
return str(categorization.Category('head', self._positive_properties,
self._negative_properties))
def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from typing import Sequence
from pyramids import categorization
from pyramids.categorization import Category
from pyramids.rules.subtree_match import SubtreeMatchRule
and context:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/subtree_match.py
# class SubtreeMatchRule:
#
# def __init__(self, positive_properties: Iterable[Property],
# negative_properties: Iterable[Property]):
# self._positive_properties = make_property_set(positive_properties)
# self._negative_properties = make_property_set(negative_properties)
#
# @property
# def positive_properties(self) -> FrozenSet[Property]:
# return self._positive_properties
#
# @property
# def negative_properties(self) -> FrozenSet[Property]:
# return self._negative_properties
#
# def __str__(self) -> str:
# raise NotImplementedError()
#
# def __repr__(self) -> str:
# return (type(self).__name__ + "(" + repr(self._positive_properties) + ", " +
# repr(self._negative_properties) + ")")
#
# # def __eq__(self, other):
# # raise NotImplementedError()
# #
# # def __ne__(self, other):
# # raise NotImplementedError()
# #
# # def __le__(self, other):
# # raise NotImplementedError()
# #
# # def __ge__(self, other):
# # raise NotImplementedError()
# #
# # def __lt__(self, other):
# # raise NotImplementedError()
# #
# # def __gt__(self, other):
# # raise NotImplementedError()
#
# def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
# raise NotImplementedError()
which might include code, classes, or functions. Output only the next line. | return ((self._positive_properties <= category_list[head_index].positive_properties) and |
Given the following code snippet before the placeholder: <|code_start|>
# head()
class HeadMatchRule(SubtreeMatchRule):
def __str__(self) -> str:
return str(categorization.Category('head', self._positive_properties,
<|code_end|>
, predict the next line using imports from the current file:
from typing import Sequence
from pyramids import categorization
from pyramids.categorization import Category
from pyramids.rules.subtree_match import SubtreeMatchRule
and context including class names, function names, and sometimes code from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/subtree_match.py
# class SubtreeMatchRule:
#
# def __init__(self, positive_properties: Iterable[Property],
# negative_properties: Iterable[Property]):
# self._positive_properties = make_property_set(positive_properties)
# self._negative_properties = make_property_set(negative_properties)
#
# @property
# def positive_properties(self) -> FrozenSet[Property]:
# return self._positive_properties
#
# @property
# def negative_properties(self) -> FrozenSet[Property]:
# return self._negative_properties
#
# def __str__(self) -> str:
# raise NotImplementedError()
#
# def __repr__(self) -> str:
# return (type(self).__name__ + "(" + repr(self._positive_properties) + ", " +
# repr(self._negative_properties) + ")")
#
# # def __eq__(self, other):
# # raise NotImplementedError()
# #
# # def __ne__(self, other):
# # raise NotImplementedError()
# #
# # def __le__(self, other):
# # raise NotImplementedError()
# #
# # def __ge__(self, other):
# # raise NotImplementedError()
# #
# # def __lt__(self, other):
# # raise NotImplementedError()
# #
# # def __gt__(self, other):
# # raise NotImplementedError()
#
# def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
# raise NotImplementedError()
. Output only the next line. | self._negative_properties)) |
Using the snippet: <|code_start|>
# head()
class HeadMatchRule(SubtreeMatchRule):
def __str__(self) -> str:
return str(categorization.Category('head', self._positive_properties,
<|code_end|>
, determine the next line of code. You have imports:
from typing import Sequence
from pyramids import categorization
from pyramids.categorization import Category
from pyramids.rules.subtree_match import SubtreeMatchRule
and context (class names, function names, or code) available:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/subtree_match.py
# class SubtreeMatchRule:
#
# def __init__(self, positive_properties: Iterable[Property],
# negative_properties: Iterable[Property]):
# self._positive_properties = make_property_set(positive_properties)
# self._negative_properties = make_property_set(negative_properties)
#
# @property
# def positive_properties(self) -> FrozenSet[Property]:
# return self._positive_properties
#
# @property
# def negative_properties(self) -> FrozenSet[Property]:
# return self._negative_properties
#
# def __str__(self) -> str:
# raise NotImplementedError()
#
# def __repr__(self) -> str:
# return (type(self).__name__ + "(" + repr(self._positive_properties) + ", " +
# repr(self._negative_properties) + ")")
#
# # def __eq__(self, other):
# # raise NotImplementedError()
# #
# # def __ne__(self, other):
# # raise NotImplementedError()
# #
# # def __le__(self, other):
# # raise NotImplementedError()
# #
# # def __ge__(self, other):
# # raise NotImplementedError()
# #
# # def __lt__(self, other):
# # raise NotImplementedError()
# #
# # def __gt__(self, other):
# # raise NotImplementedError()
#
# def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
# raise NotImplementedError()
. Output only the next line. | self._negative_properties)) |
Given the following code snippet before the placeholder: <|code_start|>
# all_terms(),
class AllTermsMatchRule(SubtreeMatchRule):
def __str__(self) -> str:
return str(categorization.Category('all_terms', self._positive_properties,
self._negative_properties))
def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
for index in range(len(category_list)):
if index == head_index:
continue
<|code_end|>
, predict the next line using imports from the current file:
from typing import Sequence
from pyramids import categorization
from pyramids.categorization import Category
from pyramids.rules.subtree_match import SubtreeMatchRule
and context including class names, function names, and sometimes code from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/subtree_match.py
# class SubtreeMatchRule:
#
# def __init__(self, positive_properties: Iterable[Property],
# negative_properties: Iterable[Property]):
# self._positive_properties = make_property_set(positive_properties)
# self._negative_properties = make_property_set(negative_properties)
#
# @property
# def positive_properties(self) -> FrozenSet[Property]:
# return self._positive_properties
#
# @property
# def negative_properties(self) -> FrozenSet[Property]:
# return self._negative_properties
#
# def __str__(self) -> str:
# raise NotImplementedError()
#
# def __repr__(self) -> str:
# return (type(self).__name__ + "(" + repr(self._positive_properties) + ", " +
# repr(self._negative_properties) + ")")
#
# # def __eq__(self, other):
# # raise NotImplementedError()
# #
# # def __ne__(self, other):
# # raise NotImplementedError()
# #
# # def __le__(self, other):
# # raise NotImplementedError()
# #
# # def __ge__(self, other):
# # raise NotImplementedError()
# #
# # def __lt__(self, other):
# # raise NotImplementedError()
# #
# # def __gt__(self, other):
# # raise NotImplementedError()
#
# def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
# raise NotImplementedError()
. Output only the next line. | if (not (self._positive_properties <= category_list[index].positive_properties) or |
Based on the snippet: <|code_start|>
# all_terms(),
class AllTermsMatchRule(SubtreeMatchRule):
def __str__(self) -> str:
return str(categorization.Category('all_terms', self._positive_properties,
<|code_end|>
, predict the immediate next line with the help of imports:
from typing import Sequence
from pyramids import categorization
from pyramids.categorization import Category
from pyramids.rules.subtree_match import SubtreeMatchRule
and context (classes, functions, sometimes code) from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/subtree_match.py
# class SubtreeMatchRule:
#
# def __init__(self, positive_properties: Iterable[Property],
# negative_properties: Iterable[Property]):
# self._positive_properties = make_property_set(positive_properties)
# self._negative_properties = make_property_set(negative_properties)
#
# @property
# def positive_properties(self) -> FrozenSet[Property]:
# return self._positive_properties
#
# @property
# def negative_properties(self) -> FrozenSet[Property]:
# return self._negative_properties
#
# def __str__(self) -> str:
# raise NotImplementedError()
#
# def __repr__(self) -> str:
# return (type(self).__name__ + "(" + repr(self._positive_properties) + ", " +
# repr(self._negative_properties) + ")")
#
# # def __eq__(self, other):
# # raise NotImplementedError()
# #
# # def __ne__(self, other):
# # raise NotImplementedError()
# #
# # def __le__(self, other):
# # raise NotImplementedError()
# #
# # def __ge__(self, other):
# # raise NotImplementedError()
# #
# # def __lt__(self, other):
# # raise NotImplementedError()
# #
# # def __gt__(self, other):
# # raise NotImplementedError()
#
# def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
# raise NotImplementedError()
. Output only the next line. | self._negative_properties)) |
Here is a snippet: <|code_start|>"""Test suite for Cython categorization code (_categorization.pyx)."""
def test_repr_eval():
"""Ensure that alternately calling repr() and eval() on a category gets back the original
category unchanged."""
cat = Category("abc", ["def"], ["ghi"])
serialized = repr(cat)
restored = eval(serialized) # pylint: disable=eval-used
assert cat == restored, (cat, serialized)
<|code_end|>
. Write the next line using the current file imports:
from pyramids.categorization import Category
and context from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
, which may include functions, classes, or code. Output only the next line. | if __name__ == '__main__': |
Predict the next line for this snippet: <|code_start|>
# any_term()
class AnyTermMatchRule(SubtreeMatchRule):
def __str__(self) -> str:
return str(categorization.Category('any_term', self._positive_properties,
<|code_end|>
with the help of current file imports:
from typing import Sequence
from pyramids import categorization
from pyramids.categorization import Category
from pyramids.rules.subtree_match import SubtreeMatchRule
and context from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/subtree_match.py
# class SubtreeMatchRule:
#
# def __init__(self, positive_properties: Iterable[Property],
# negative_properties: Iterable[Property]):
# self._positive_properties = make_property_set(positive_properties)
# self._negative_properties = make_property_set(negative_properties)
#
# @property
# def positive_properties(self) -> FrozenSet[Property]:
# return self._positive_properties
#
# @property
# def negative_properties(self) -> FrozenSet[Property]:
# return self._negative_properties
#
# def __str__(self) -> str:
# raise NotImplementedError()
#
# def __repr__(self) -> str:
# return (type(self).__name__ + "(" + repr(self._positive_properties) + ", " +
# repr(self._negative_properties) + ")")
#
# # def __eq__(self, other):
# # raise NotImplementedError()
# #
# # def __ne__(self, other):
# # raise NotImplementedError()
# #
# # def __le__(self, other):
# # raise NotImplementedError()
# #
# # def __ge__(self, other):
# # raise NotImplementedError()
# #
# # def __lt__(self, other):
# # raise NotImplementedError()
# #
# # def __gt__(self, other):
# # raise NotImplementedError()
#
# def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
# raise NotImplementedError()
, which may contain function names, class names, or code. Output only the next line. | self._negative_properties)) |
Here is a snippet: <|code_start|>
# any_term()
class AnyTermMatchRule(SubtreeMatchRule):
def __str__(self) -> str:
return str(categorization.Category('any_term', self._positive_properties,
self._negative_properties))
def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
for index in range(len(category_list)):
if index == head_index:
continue
<|code_end|>
. Write the next line using the current file imports:
from typing import Sequence
from pyramids import categorization
from pyramids.categorization import Category
from pyramids.rules.subtree_match import SubtreeMatchRule
and context from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/subtree_match.py
# class SubtreeMatchRule:
#
# def __init__(self, positive_properties: Iterable[Property],
# negative_properties: Iterable[Property]):
# self._positive_properties = make_property_set(positive_properties)
# self._negative_properties = make_property_set(negative_properties)
#
# @property
# def positive_properties(self) -> FrozenSet[Property]:
# return self._positive_properties
#
# @property
# def negative_properties(self) -> FrozenSet[Property]:
# return self._negative_properties
#
# def __str__(self) -> str:
# raise NotImplementedError()
#
# def __repr__(self) -> str:
# return (type(self).__name__ + "(" + repr(self._positive_properties) + ", " +
# repr(self._negative_properties) + ")")
#
# # def __eq__(self, other):
# # raise NotImplementedError()
# #
# # def __ne__(self, other):
# # raise NotImplementedError()
# #
# # def __le__(self, other):
# # raise NotImplementedError()
# #
# # def __ge__(self, other):
# # raise NotImplementedError()
# #
# # def __lt__(self, other):
# # raise NotImplementedError()
# #
# # def __gt__(self, other):
# # raise NotImplementedError()
#
# def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
# raise NotImplementedError()
, which may include functions, classes, or code. Output only the next line. | if ((self._positive_properties <= category_list[index].positive_properties) and |
Next line prediction: <|code_start|>
if TYPE_CHECKING:
class BranchRule(ParseRule, metaclass=ABCMeta):
""""Used by Parser to identify higher-level (composite) structures,
which are the branches in a parse tree."""
@abstractmethod
def __call__(self, parser_state: 'parsing.ParserState', new_node: 'trees.TreeNodeSet',
emergency: bool = False) -> None:
raise NotImplementedError()
@property
<|code_end|>
. Use current file imports:
(from abc import ABCMeta, abstractmethod
from typing import FrozenSet, Iterable, Tuple, Iterator, Sequence, TYPE_CHECKING
from pyramids.categorization import LinkLabel, Category
from pyramids.rules.parse_rule import ParseRule
from pyramids import scoring
from pyramids import parsing, trees, traversal, model)
and context including class names, function names, or small code snippets from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/parse_rule.py
# class ParseRule:
# _scoring_features: Dict[Optional[scoring.ScoringFeature], Tuple[float, float, int]]
#
# def __init__(self, default_score: float = None, default_accuracy: float = None):
# if default_score is None:
# default_score = .5
# if default_accuracy is None:
# default_accuracy = 0.001
# self._scoring_features = {None: (default_score, default_accuracy, 0)}
#
# # def __str__(self) -> str:
# # raise NotImplementedError()
#
# def calculate_weighted_score(self, parse_node: 'trees.TreeNodeInterface') \
# -> Tuple[float, float]:
# default_score, default_weight, count = self._scoring_features[None]
# total_score = default_score * default_weight
# total_weight = default_weight
# for feature in self.iter_scoring_features(parse_node):
# if feature is not None and feature in self._scoring_features:
# score, weight, count = self._scoring_features[feature]
# total_score += score * weight
# total_weight += weight
# return total_score, total_weight
#
# def adjust_score(self, parse_node: 'trees.TreeNodeInterface', target: float) -> None:
# if not 0 <= target <= 1:
# raise ValueError("Score target must be in the interval [0, 1].")
# default_score, default_weight, count = self._scoring_features[None]
# count += 1
# error = (target - default_score) ** 2
# weight_target = 1 - error
# default_score += (target - default_score) / count
# default_weight += (weight_target - default_weight) / count
# self._scoring_features[None] = (default_score, default_weight, count)
# for feature in self.iter_scoring_features(parse_node):
# if feature in self._scoring_features:
# score, weight, count = self._scoring_features[feature]
# count += 1
# else:
# score, weight, _ = self._scoring_features[None]
# count = 2 # Default is counted as 1, plus one new measurement
# error = (target - score) ** 2
# weight_target = 1 - error
# score += (target - score) / count
# weight += (weight_target - weight) / count
# self._scoring_features[feature] = (score, weight, count)
#
# def get_score(self, feature: scoring.ScoringFeature) -> Tuple[float, float, int]:
# if feature in self._scoring_features:
# return self._scoring_features[feature]
# else:
# return 0, 0, 0
#
# def set_score(self, feature: Union[scoring.ScoringKey, scoring.ScoringFeature], score: float,
# accuracy: float, count: int) -> None:
# if not isinstance(feature, scoring.ScoringFeature):
# feature = scoring.ScoringFeature(feature)
# score = float(score)
# accuracy = float(accuracy)
# if not 0 <= score <= 1:
# raise ValueError("Score must be in the interval [0, 1].")
# if not 0 <= accuracy <= 1:
# raise ValueError("Accuracy must be in the interval [0, 1].")
# if count < 0:
# raise ValueError("Count must be non-negative.")
# # noinspection PyTypeChecker
# self._scoring_features[feature] = (score, accuracy, count)
#
# def iter_all_scoring_features(self) -> Iterator[Optional[scoring.ScoringFeature]]:
# return iter(self._scoring_features)
#
# def iter_scoring_features(self, parse_node: 'trees.TreeNodeInterface') \
# -> Iterator[Optional[scoring.ScoringFeature]]:
# raise NotImplementedError()
#
# Path: pyramids/scoring.py
# class ScoringFeature:
# def validate_key(cls, key: ScoringKey):
# def __init__(self, key: ScoringKey):
# def __hash__(self) -> int:
# def __eq__(self, other: 'ScoringFeature') -> bool:
# def __ne__(self, other: 'ScoringFeature') -> bool:
# def __str__(self) -> str:
# def __repr__(self) -> str:
# def key(self) -> ScoringKey:
. Output only the next line. | @abstractmethod |
Given snippet: <|code_start|>class BranchRule(ParseRule, metaclass=ABCMeta):
""""Used by Parser to identify higher-level (composite) structures,
which are the branches in a parse tree."""
@abstractmethod
def __call__(self, parser_state: 'parsing.ParserState', new_node: 'trees.TreeNodeSet',
emergency: bool = False) -> None:
raise NotImplementedError()
@property
@abstractmethod
def all_link_types(self) -> FrozenSet[LinkLabel]:
raise NotImplementedError()
@abstractmethod
def get_link_types(self, parse_node: 'traversal.TraversableElement',
link_set_index: int) -> Iterable[Tuple[LinkLabel, bool, bool]]:
raise NotImplementedError()
@property
@abstractmethod
def head_category_set(self) -> FrozenSet[Category]:
raise NotImplementedError()
@property
@abstractmethod
def link_type_sets(self) -> Tuple[FrozenSet[Tuple[LinkLabel, bool, bool]],
FrozenSet[Tuple[LinkLabel, bool, bool]]]:
raise NotImplementedError()
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from abc import ABCMeta, abstractmethod
from typing import FrozenSet, Iterable, Tuple, Iterator, Sequence, TYPE_CHECKING
from pyramids.categorization import LinkLabel, Category
from pyramids.rules.parse_rule import ParseRule
from pyramids import scoring
from pyramids import parsing, trees, traversal, model
and context:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/parse_rule.py
# class ParseRule:
# _scoring_features: Dict[Optional[scoring.ScoringFeature], Tuple[float, float, int]]
#
# def __init__(self, default_score: float = None, default_accuracy: float = None):
# if default_score is None:
# default_score = .5
# if default_accuracy is None:
# default_accuracy = 0.001
# self._scoring_features = {None: (default_score, default_accuracy, 0)}
#
# # def __str__(self) -> str:
# # raise NotImplementedError()
#
# def calculate_weighted_score(self, parse_node: 'trees.TreeNodeInterface') \
# -> Tuple[float, float]:
# default_score, default_weight, count = self._scoring_features[None]
# total_score = default_score * default_weight
# total_weight = default_weight
# for feature in self.iter_scoring_features(parse_node):
# if feature is not None and feature in self._scoring_features:
# score, weight, count = self._scoring_features[feature]
# total_score += score * weight
# total_weight += weight
# return total_score, total_weight
#
# def adjust_score(self, parse_node: 'trees.TreeNodeInterface', target: float) -> None:
# if not 0 <= target <= 1:
# raise ValueError("Score target must be in the interval [0, 1].")
# default_score, default_weight, count = self._scoring_features[None]
# count += 1
# error = (target - default_score) ** 2
# weight_target = 1 - error
# default_score += (target - default_score) / count
# default_weight += (weight_target - default_weight) / count
# self._scoring_features[None] = (default_score, default_weight, count)
# for feature in self.iter_scoring_features(parse_node):
# if feature in self._scoring_features:
# score, weight, count = self._scoring_features[feature]
# count += 1
# else:
# score, weight, _ = self._scoring_features[None]
# count = 2 # Default is counted as 1, plus one new measurement
# error = (target - score) ** 2
# weight_target = 1 - error
# score += (target - score) / count
# weight += (weight_target - weight) / count
# self._scoring_features[feature] = (score, weight, count)
#
# def get_score(self, feature: scoring.ScoringFeature) -> Tuple[float, float, int]:
# if feature in self._scoring_features:
# return self._scoring_features[feature]
# else:
# return 0, 0, 0
#
# def set_score(self, feature: Union[scoring.ScoringKey, scoring.ScoringFeature], score: float,
# accuracy: float, count: int) -> None:
# if not isinstance(feature, scoring.ScoringFeature):
# feature = scoring.ScoringFeature(feature)
# score = float(score)
# accuracy = float(accuracy)
# if not 0 <= score <= 1:
# raise ValueError("Score must be in the interval [0, 1].")
# if not 0 <= accuracy <= 1:
# raise ValueError("Accuracy must be in the interval [0, 1].")
# if count < 0:
# raise ValueError("Count must be non-negative.")
# # noinspection PyTypeChecker
# self._scoring_features[feature] = (score, accuracy, count)
#
# def iter_all_scoring_features(self) -> Iterator[Optional[scoring.ScoringFeature]]:
# return iter(self._scoring_features)
#
# def iter_scoring_features(self, parse_node: 'trees.TreeNodeInterface') \
# -> Iterator[Optional[scoring.ScoringFeature]]:
# raise NotImplementedError()
#
# Path: pyramids/scoring.py
# class ScoringFeature:
# def validate_key(cls, key: ScoringKey):
# def __init__(self, key: ScoringKey):
# def __hash__(self) -> int:
# def __eq__(self, other: 'ScoringFeature') -> bool:
# def __ne__(self, other: 'ScoringFeature') -> bool:
# def __str__(self) -> str:
# def __repr__(self) -> str:
# def key(self) -> ScoringKey:
which might include code, classes, or functions. Output only the next line. | @property |
Predict the next line for this snippet: <|code_start|>
if TYPE_CHECKING:
class BranchRule(ParseRule, metaclass=ABCMeta):
""""Used by Parser to identify higher-level (composite) structures,
which are the branches in a parse tree."""
@abstractmethod
def __call__(self, parser_state: 'parsing.ParserState', new_node: 'trees.TreeNodeSet',
emergency: bool = False) -> None:
raise NotImplementedError()
@property
@abstractmethod
def all_link_types(self) -> FrozenSet[LinkLabel]:
raise NotImplementedError()
@abstractmethod
def get_link_types(self, parse_node: 'traversal.TraversableElement',
link_set_index: int) -> Iterable[Tuple[LinkLabel, bool, bool]]:
raise NotImplementedError()
@property
@abstractmethod
def head_category_set(self) -> FrozenSet[Category]:
raise NotImplementedError()
@property
<|code_end|>
with the help of current file imports:
from abc import ABCMeta, abstractmethod
from typing import FrozenSet, Iterable, Tuple, Iterator, Sequence, TYPE_CHECKING
from pyramids.categorization import LinkLabel, Category
from pyramids.rules.parse_rule import ParseRule
from pyramids import scoring
from pyramids import parsing, trees, traversal, model
and context from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/parse_rule.py
# class ParseRule:
# _scoring_features: Dict[Optional[scoring.ScoringFeature], Tuple[float, float, int]]
#
# def __init__(self, default_score: float = None, default_accuracy: float = None):
# if default_score is None:
# default_score = .5
# if default_accuracy is None:
# default_accuracy = 0.001
# self._scoring_features = {None: (default_score, default_accuracy, 0)}
#
# # def __str__(self) -> str:
# # raise NotImplementedError()
#
# def calculate_weighted_score(self, parse_node: 'trees.TreeNodeInterface') \
# -> Tuple[float, float]:
# default_score, default_weight, count = self._scoring_features[None]
# total_score = default_score * default_weight
# total_weight = default_weight
# for feature in self.iter_scoring_features(parse_node):
# if feature is not None and feature in self._scoring_features:
# score, weight, count = self._scoring_features[feature]
# total_score += score * weight
# total_weight += weight
# return total_score, total_weight
#
# def adjust_score(self, parse_node: 'trees.TreeNodeInterface', target: float) -> None:
# if not 0 <= target <= 1:
# raise ValueError("Score target must be in the interval [0, 1].")
# default_score, default_weight, count = self._scoring_features[None]
# count += 1
# error = (target - default_score) ** 2
# weight_target = 1 - error
# default_score += (target - default_score) / count
# default_weight += (weight_target - default_weight) / count
# self._scoring_features[None] = (default_score, default_weight, count)
# for feature in self.iter_scoring_features(parse_node):
# if feature in self._scoring_features:
# score, weight, count = self._scoring_features[feature]
# count += 1
# else:
# score, weight, _ = self._scoring_features[None]
# count = 2 # Default is counted as 1, plus one new measurement
# error = (target - score) ** 2
# weight_target = 1 - error
# score += (target - score) / count
# weight += (weight_target - weight) / count
# self._scoring_features[feature] = (score, weight, count)
#
# def get_score(self, feature: scoring.ScoringFeature) -> Tuple[float, float, int]:
# if feature in self._scoring_features:
# return self._scoring_features[feature]
# else:
# return 0, 0, 0
#
# def set_score(self, feature: Union[scoring.ScoringKey, scoring.ScoringFeature], score: float,
# accuracy: float, count: int) -> None:
# if not isinstance(feature, scoring.ScoringFeature):
# feature = scoring.ScoringFeature(feature)
# score = float(score)
# accuracy = float(accuracy)
# if not 0 <= score <= 1:
# raise ValueError("Score must be in the interval [0, 1].")
# if not 0 <= accuracy <= 1:
# raise ValueError("Accuracy must be in the interval [0, 1].")
# if count < 0:
# raise ValueError("Count must be non-negative.")
# # noinspection PyTypeChecker
# self._scoring_features[feature] = (score, accuracy, count)
#
# def iter_all_scoring_features(self) -> Iterator[Optional[scoring.ScoringFeature]]:
# return iter(self._scoring_features)
#
# def iter_scoring_features(self, parse_node: 'trees.TreeNodeInterface') \
# -> Iterator[Optional[scoring.ScoringFeature]]:
# raise NotImplementedError()
#
# Path: pyramids/scoring.py
# class ScoringFeature:
# def validate_key(cls, key: ScoringKey):
# def __init__(self, key: ScoringKey):
# def __hash__(self) -> int:
# def __eq__(self, other: 'ScoringFeature') -> bool:
# def __ne__(self, other: 'ScoringFeature') -> bool:
# def __str__(self) -> str:
# def __repr__(self) -> str:
# def key(self) -> ScoringKey:
, which may contain function names, class names, or code. Output only the next line. | @abstractmethod |
Using the snippet: <|code_start|>
if TYPE_CHECKING:
class BranchRule(ParseRule, metaclass=ABCMeta):
""""Used by Parser to identify higher-level (composite) structures,
which are the branches in a parse tree."""
@abstractmethod
def __call__(self, parser_state: 'parsing.ParserState', new_node: 'trees.TreeNodeSet',
emergency: bool = False) -> None:
raise NotImplementedError()
@property
@abstractmethod
def all_link_types(self) -> FrozenSet[LinkLabel]:
raise NotImplementedError()
<|code_end|>
, determine the next line of code. You have imports:
from abc import ABCMeta, abstractmethod
from typing import FrozenSet, Iterable, Tuple, Iterator, Sequence, TYPE_CHECKING
from pyramids.categorization import LinkLabel, Category
from pyramids.rules.parse_rule import ParseRule
from pyramids import scoring
from pyramids import parsing, trees, traversal, model
and context (class names, function names, or code) available:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/parse_rule.py
# class ParseRule:
# _scoring_features: Dict[Optional[scoring.ScoringFeature], Tuple[float, float, int]]
#
# def __init__(self, default_score: float = None, default_accuracy: float = None):
# if default_score is None:
# default_score = .5
# if default_accuracy is None:
# default_accuracy = 0.001
# self._scoring_features = {None: (default_score, default_accuracy, 0)}
#
# # def __str__(self) -> str:
# # raise NotImplementedError()
#
# def calculate_weighted_score(self, parse_node: 'trees.TreeNodeInterface') \
# -> Tuple[float, float]:
# default_score, default_weight, count = self._scoring_features[None]
# total_score = default_score * default_weight
# total_weight = default_weight
# for feature in self.iter_scoring_features(parse_node):
# if feature is not None and feature in self._scoring_features:
# score, weight, count = self._scoring_features[feature]
# total_score += score * weight
# total_weight += weight
# return total_score, total_weight
#
# def adjust_score(self, parse_node: 'trees.TreeNodeInterface', target: float) -> None:
# if not 0 <= target <= 1:
# raise ValueError("Score target must be in the interval [0, 1].")
# default_score, default_weight, count = self._scoring_features[None]
# count += 1
# error = (target - default_score) ** 2
# weight_target = 1 - error
# default_score += (target - default_score) / count
# default_weight += (weight_target - default_weight) / count
# self._scoring_features[None] = (default_score, default_weight, count)
# for feature in self.iter_scoring_features(parse_node):
# if feature in self._scoring_features:
# score, weight, count = self._scoring_features[feature]
# count += 1
# else:
# score, weight, _ = self._scoring_features[None]
# count = 2 # Default is counted as 1, plus one new measurement
# error = (target - score) ** 2
# weight_target = 1 - error
# score += (target - score) / count
# weight += (weight_target - weight) / count
# self._scoring_features[feature] = (score, weight, count)
#
# def get_score(self, feature: scoring.ScoringFeature) -> Tuple[float, float, int]:
# if feature in self._scoring_features:
# return self._scoring_features[feature]
# else:
# return 0, 0, 0
#
# def set_score(self, feature: Union[scoring.ScoringKey, scoring.ScoringFeature], score: float,
# accuracy: float, count: int) -> None:
# if not isinstance(feature, scoring.ScoringFeature):
# feature = scoring.ScoringFeature(feature)
# score = float(score)
# accuracy = float(accuracy)
# if not 0 <= score <= 1:
# raise ValueError("Score must be in the interval [0, 1].")
# if not 0 <= accuracy <= 1:
# raise ValueError("Accuracy must be in the interval [0, 1].")
# if count < 0:
# raise ValueError("Count must be non-negative.")
# # noinspection PyTypeChecker
# self._scoring_features[feature] = (score, accuracy, count)
#
# def iter_all_scoring_features(self) -> Iterator[Optional[scoring.ScoringFeature]]:
# return iter(self._scoring_features)
#
# def iter_scoring_features(self, parse_node: 'trees.TreeNodeInterface') \
# -> Iterator[Optional[scoring.ScoringFeature]]:
# raise NotImplementedError()
#
# Path: pyramids/scoring.py
# class ScoringFeature:
# def validate_key(cls, key: ScoringKey):
# def __init__(self, key: ScoringKey):
# def __hash__(self) -> int:
# def __eq__(self, other: 'ScoringFeature') -> bool:
# def __ne__(self, other: 'ScoringFeature') -> bool:
# def __str__(self) -> str:
# def __repr__(self) -> str:
# def key(self) -> ScoringKey:
. Output only the next line. | @abstractmethod |
Predict the next line after this snippet: <|code_start|>
class PropertyInheritanceRule:
def __init__(self, category: Category, positive_additions: Iterable[Property],
negative_additions: Iterable[Property]):
self._category = category
self._positive_additions = make_property_set(positive_additions)
self._negative_additions = make_property_set(negative_additions)
def __call__(self, category_name: str, positive: Iterable[Property],
negative: Iterable[Property]) -> Optional[Tuple[FrozenSet[Property],
FrozenSet[Property]]]:
category = Category(category_name, positive, negative)
if ((self.category.is_wildcard() or self.category.name is category.name) and
self.category.positive_properties <= category.positive_properties and
self.category.negative_properties <= category.negative_properties):
return self.positive_additions, self.negative_additions
else:
return None
def __str__(self) -> str:
result = str(self.category) + ":"
<|code_end|>
using the current file's imports:
from typing import Iterable, Optional, Tuple, FrozenSet
from pyramids.categorization import make_property_set, Category, Property
and any relevant context from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
. Output only the next line. | if self._positive_additions: |
Predict the next line after this snippet: <|code_start|>
class PropertyInheritanceRule:
def __init__(self, category: Category, positive_additions: Iterable[Property],
negative_additions: Iterable[Property]):
self._category = category
self._positive_additions = make_property_set(positive_additions)
self._negative_additions = make_property_set(negative_additions)
def __call__(self, category_name: str, positive: Iterable[Property],
negative: Iterable[Property]) -> Optional[Tuple[FrozenSet[Property],
FrozenSet[Property]]]:
category = Category(category_name, positive, negative)
if ((self.category.is_wildcard() or self.category.name is category.name) and
self.category.positive_properties <= category.positive_properties and
self.category.negative_properties <= category.negative_properties):
return self.positive_additions, self.negative_additions
else:
return None
def __str__(self) -> str:
result = str(self.category) + ":"
<|code_end|>
using the current file's imports:
from typing import Iterable, Optional, Tuple, FrozenSet
from pyramids.categorization import make_property_set, Category, Property
and any relevant context from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
. Output only the next line. | if self._positive_additions: |
Predict the next line for this snippet: <|code_start|>
class PropertyInheritanceRule:
def __init__(self, category: Category, positive_additions: Iterable[Property],
negative_additions: Iterable[Property]):
self._category = category
self._positive_additions = make_property_set(positive_additions)
self._negative_additions = make_property_set(negative_additions)
def __call__(self, category_name: str, positive: Iterable[Property],
negative: Iterable[Property]) -> Optional[Tuple[FrozenSet[Property],
FrozenSet[Property]]]:
category = Category(category_name, positive, negative)
if ((self.category.is_wildcard() or self.category.name is category.name) and
self.category.positive_properties <= category.positive_properties and
<|code_end|>
with the help of current file imports:
from typing import Iterable, Optional, Tuple, FrozenSet
from pyramids.categorization import make_property_set, Category, Property
and context from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
, which may contain function names, class names, or code. Output only the next line. | self.category.negative_properties <= category.negative_properties): |
Continue the code snippet: <|code_start|>
# last_term()
class LastTermMatchRule(SubtreeMatchRule):
def __str__(self) -> str:
return str(categorization.Category('last_term', self._positive_properties,
<|code_end|>
. Use current file imports:
from typing import Sequence
from pyramids import categorization
from pyramids.categorization import Category
from pyramids.rules.subtree_match import SubtreeMatchRule
and context (classes, functions, or code) from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/subtree_match.py
# class SubtreeMatchRule:
#
# def __init__(self, positive_properties: Iterable[Property],
# negative_properties: Iterable[Property]):
# self._positive_properties = make_property_set(positive_properties)
# self._negative_properties = make_property_set(negative_properties)
#
# @property
# def positive_properties(self) -> FrozenSet[Property]:
# return self._positive_properties
#
# @property
# def negative_properties(self) -> FrozenSet[Property]:
# return self._negative_properties
#
# def __str__(self) -> str:
# raise NotImplementedError()
#
# def __repr__(self) -> str:
# return (type(self).__name__ + "(" + repr(self._positive_properties) + ", " +
# repr(self._negative_properties) + ")")
#
# # def __eq__(self, other):
# # raise NotImplementedError()
# #
# # def __ne__(self, other):
# # raise NotImplementedError()
# #
# # def __le__(self, other):
# # raise NotImplementedError()
# #
# # def __ge__(self, other):
# # raise NotImplementedError()
# #
# # def __lt__(self, other):
# # raise NotImplementedError()
# #
# # def __gt__(self, other):
# # raise NotImplementedError()
#
# def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
# raise NotImplementedError()
. Output only the next line. | self._negative_properties)) |
Predict the next line for this snippet: <|code_start|>
# last_term()
class LastTermMatchRule(SubtreeMatchRule):
def __str__(self) -> str:
return str(categorization.Category('last_term', self._positive_properties,
self._negative_properties))
def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
return ((self._positive_properties <= category_list[-1].positive_properties) and
<|code_end|>
with the help of current file imports:
from typing import Sequence
from pyramids import categorization
from pyramids.categorization import Category
from pyramids.rules.subtree_match import SubtreeMatchRule
and context from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/subtree_match.py
# class SubtreeMatchRule:
#
# def __init__(self, positive_properties: Iterable[Property],
# negative_properties: Iterable[Property]):
# self._positive_properties = make_property_set(positive_properties)
# self._negative_properties = make_property_set(negative_properties)
#
# @property
# def positive_properties(self) -> FrozenSet[Property]:
# return self._positive_properties
#
# @property
# def negative_properties(self) -> FrozenSet[Property]:
# return self._negative_properties
#
# def __str__(self) -> str:
# raise NotImplementedError()
#
# def __repr__(self) -> str:
# return (type(self).__name__ + "(" + repr(self._positive_properties) + ", " +
# repr(self._negative_properties) + ")")
#
# # def __eq__(self, other):
# # raise NotImplementedError()
# #
# # def __ne__(self, other):
# # raise NotImplementedError()
# #
# # def __le__(self, other):
# # raise NotImplementedError()
# #
# # def __ge__(self, other):
# # raise NotImplementedError()
# #
# # def __lt__(self, other):
# # raise NotImplementedError()
# #
# # def __gt__(self, other):
# # raise NotImplementedError()
#
# def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
# raise NotImplementedError()
, which may contain function names, class names, or code. Output only the next line. | not (self._negative_properties & category_list[-1].positive_properties)) |
Based on the snippet: <|code_start|>
# last_term()
class LastTermMatchRule(SubtreeMatchRule):
def __str__(self) -> str:
return str(categorization.Category('last_term', self._positive_properties,
self._negative_properties))
def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
return ((self._positive_properties <= category_list[-1].positive_properties) and
<|code_end|>
, predict the immediate next line with the help of imports:
from typing import Sequence
from pyramids import categorization
from pyramids.categorization import Category
from pyramids.rules.subtree_match import SubtreeMatchRule
and context (classes, functions, sometimes code) from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
#
# Path: pyramids/rules/subtree_match.py
# class SubtreeMatchRule:
#
# def __init__(self, positive_properties: Iterable[Property],
# negative_properties: Iterable[Property]):
# self._positive_properties = make_property_set(positive_properties)
# self._negative_properties = make_property_set(negative_properties)
#
# @property
# def positive_properties(self) -> FrozenSet[Property]:
# return self._positive_properties
#
# @property
# def negative_properties(self) -> FrozenSet[Property]:
# return self._negative_properties
#
# def __str__(self) -> str:
# raise NotImplementedError()
#
# def __repr__(self) -> str:
# return (type(self).__name__ + "(" + repr(self._positive_properties) + ", " +
# repr(self._negative_properties) + ")")
#
# # def __eq__(self, other):
# # raise NotImplementedError()
# #
# # def __ne__(self, other):
# # raise NotImplementedError()
# #
# # def __le__(self, other):
# # raise NotImplementedError()
# #
# # def __ge__(self, other):
# # raise NotImplementedError()
# #
# # def __lt__(self, other):
# # raise NotImplementedError()
# #
# # def __gt__(self, other):
# # raise NotImplementedError()
#
# def __call__(self, category_list: Sequence[Category], head_index: int) -> bool:
# raise NotImplementedError()
. Output only the next line. | not (self._negative_properties & category_list[-1].positive_properties)) |
Based on the snippet: <|code_start|> for link in json_data['links']:
source = link['source']
sink = link['sink']
label = LinkLabel.get(link['label'])
if sink in links[source]:
links[source][sink].add(label)
else:
links[source] = {sink: {label}}
phrases = [[] for _ in tokens]
for index, phrase_stack in enumerate(json_data['phrases']):
for phrase in phrase_stack:
category = GrammarParser.parse_category(phrase['category'])
phrase_links = [(link['source'], link['sink']) for link in phrase['links']]
phrases[index].append((category, phrase_links))
return cls(root, tokens, links, phrases)
def __init__(self, root: int, tokens: Sequence[Token], links: List[Dict[int, Set[str]]],
phrases: List[List[Tuple[Category, List[Tuple[int, int]]]]]):
self._root = root
self._tokens = tuple(tokens)
self._links = tuple({sink: frozenset(labels) for sink, labels in dict(sink_map).items()}
for sink_map in links)
self._phrases = tuple(tuple((category, frozenset((source, sink)
for source, sink in phrase_links))
for category, phrase_links in phrase_stack)
for phrase_stack in phrases)
assert self._phrases and self._phrases[-1]
self._reversed_links = tuple({source: self._links[source][sink]
for source in range(len(self._tokens))
<|code_end|>
, predict the immediate next line with the help of imports:
from typing import NamedTuple, Sequence, Set, FrozenSet, List, Tuple, Optional, Iterator, Union, \
Dict
from graphviz import Digraph
from pyramids.categorization import Category, LinkLabel
from pyramids.grammar import GrammarParser
from pyramids.grammar import GrammarParser
and context (classes, functions, sometimes code) from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
. Output only the next line. | if sink in self._links[source]} |
Predict the next line for this snippet: <|code_start|> phrase_map[index] = phrase
return ['%s: %s' % (self.get_phrase_category(index), phrase_map[index])
for index in sorted(self.find_roots())]
def find_roots(self) -> Set[int]:
roots = set(range(len(self._tokens)))
for index, outbound in enumerate(self._links):
roots -= outbound.keys()
return roots
def find_leaves(self) -> Set[int]:
return {index for index in range(len(self._tokens)) if not self._links[index]}
def _is_forest(self, roots: Set[int]) -> bool:
visited = roots
added = list(visited)
to_add = []
while added:
for source in added:
for sink in self.get_sinks(source):
if sink in visited:
return False
visited.add(sink)
to_add.append(sink)
added, to_add = to_add, added
to_add.clear()
return len(visited) == len(self._tokens)
def is_tree(self) -> bool:
roots = self.find_roots()
<|code_end|>
with the help of current file imports:
from typing import NamedTuple, Sequence, Set, FrozenSet, List, Tuple, Optional, Iterator, Union, \
Dict
from graphviz import Digraph
from pyramids.categorization import Category, LinkLabel
from pyramids.grammar import GrammarParser
from pyramids.grammar import GrammarParser
and context from other files:
# Path: pyramids/categorization.py
# CATEGORY_WILDCARD = _CATEGORY_WILDCARD
, which may contain function names, class names, or code. Output only the next line. | return len(roots) == 1 and self._is_forest(roots) |
Based on the snippet: <|code_start|>#!/usr/bin/python
sys.path.append("..")
def test_noise():
N = 500
#rate = 1.0
w = noise.white(N)
b = noise.brown(N)
v = noise.violet(N)
p = noise.pink(N)
# check output length
assert len(w) == N
assert len(b) == N
assert len(v) == N
<|code_end|>
, predict the immediate next line with the help of imports:
import sys
import numpy
import pytest
from allantools import noise
and context (classes, functions, sometimes code) from other files:
# Path: allantools/noise.py
# def numpy_psd(x, f_sample=1.0):
# def scipy_psd(x, f_sample=1.0, nr_segments=4):
# def white(num_points=1024, b0=1.0, fs=1.0):
# def brown(num_points=1024, b_minus2=1.0, fs=1.0):
# def violet(num_points=1024, b2=1, fs=1):
# def pink(num_points=1024, depth=80):
# def iterpink(depth=20):
. Output only the next line. | assert len(p) == N |
Continue the code snippet: <|code_start|>
y_WFM_ind= noise.white(num_points= int(2e4), b0=S_y0, fs=2e4)
y_WPM_ind= noise.violet(num_points= int(2e4), b2=S_y0, fs=2e4)
f, S_y_WFM_ind= welch(y_WFM_ind,fs=2e4, nperseg=y_WFM_ind.size, window='hanning')
f, S_y_WPM_ind= welch(y_WPM_ind,fs=2e4, nperseg=y_WPM_ind.size, window='hanning')
plt.loglog(f,S_y_WFM_ind)
plt.loglog(f,S_y_WPM_ind)
plt.xlabel('$f$ [Hz]')
plt.ylabel('$S_y$')
plt.legend(('WFM direct', 'WPM direct', 'WFM indirect', 'WPM indirect'))
#(tau, sigma_WFM)= at.psd2allan(S_y_WFM, f, kind= 'a')
#(tau, sigma_WPM)= at.psd2allan(S_y_WPM, f, kind= 'a')
#(tau, modsigma_WFM)= at.psd2allan(S_y_WFM, f, kind= 'm')
#(tau, modsigma_WPM)= at.psd2allan(S_y_WPM, f, kind= 'm')
(tau, sigma_WFM)= at.psd2allan(S_y_WFM, kind= 'a')
(tau, sigma_WPM)= at.psd2allan(S_y_WPM, kind= 'a')
(tau, modsigma_WFM)= at.psd2allan(S_y_WFM, kind= 'm')
(tau, modsigma_WPM)= at.psd2allan(S_y_WPM, kind= 'm')
plt.figure(2)
plt.loglog(tau, sigma_WFM)
plt.loglog(tau, sigma_WPM)
plt.loglog(tau, modsigma_WFM)
plt.loglog(tau, modsigma_WPM)
(tau, sigma_WFM_ind)= at.psd2allan(S_y_WFM_ind, kind= 'a')
(tau, sigma_WPM_ind)= at.psd2allan(S_y_WPM_ind, kind= 'a')
(tau, modsigma_WFM_ind)= at.psd2allan(S_y_WFM_ind, kind= 'm')
<|code_end|>
. Use current file imports:
import sys
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import allantools as at
from allantools import noise
from scipy.signal import welch
and context (classes, functions, or code) from other files:
# Path: allantools/noise.py
# def numpy_psd(x, f_sample=1.0):
# def scipy_psd(x, f_sample=1.0, nr_segments=4):
# def white(num_points=1024, b0=1.0, fs=1.0):
# def brown(num_points=1024, b_minus2=1.0, fs=1.0):
# def violet(num_points=1024, b2=1, fs=1):
# def pink(num_points=1024, depth=80):
# def iterpink(depth=20):
. Output only the next line. | (tau, modsigma_WPM_ind)= at.psd2allan(S_y_WPM_ind, kind= 'm') |
Here is a snippet: <|code_start|>#!/usr/bin/python
sys.path.append("..")
def _test( function, data, rate, taus):
(taus2,devs2,errs2,ns2) = function(data, rate=rate, taus=taus)
assert( len(taus2) == len(devs2) )
<|code_end|>
. Write the next line using the current file imports:
import sys
import allantools as allan
import numpy
from allantools import noise
and context from other files:
# Path: allantools/noise.py
# def numpy_psd(x, f_sample=1.0):
# def scipy_psd(x, f_sample=1.0, nr_segments=4):
# def white(num_points=1024, b0=1.0, fs=1.0):
# def brown(num_points=1024, b_minus2=1.0, fs=1.0):
# def violet(num_points=1024, b2=1, fs=1):
# def pink(num_points=1024, depth=80):
# def iterpink(depth=20):
, which may include functions, classes, or code. Output only the next line. | assert( len(taus2) == len(errs2) ) |
Predict the next line for this snippet: <|code_start|># -*- coding: utf-8 -*-
try:
WIKI_WORD_RE = settings.WIKI_WORD_RE
except AttributeError:
WIKI_WORD_RE = r'(?:[A-Z]+[a-z]+){2,}'
wikiword_pattern = re.compile('^' + WIKI_WORD_RE + '$')
class ArticleForm(forms.ModelForm):
summary = forms.CharField(widget=forms.Textarea)
comment = forms.CharField(required=False)
user_ip = forms.CharField(widget=forms.HiddenInput)
<|code_end|>
with the help of current file imports:
import re
from django import forms
from django.forms import widgets
from django.conf import settings
from django.contrib.contenttypes.models import ContentType
from django.utils.translation import ugettext_lazy as _
from wiki.models import Article
and context from other files:
# Path: wiki/models.py
# class Article(models.Model):
# """ A wiki page.
# """
# title = models.CharField(_(u"Title"), max_length=50)
# content = models.TextField(_(u"Content"))
# summary = models.CharField(_(u"Summary"), max_length=150,
# null=True, blank=True)
# markup = models.CharField(_(u"Content Markup"), max_length=3,
# choices=markup_choices,
# null=True, blank=True)
# creator = models.ForeignKey(User, verbose_name=_('Article Creator'),
# null=True)
# creator_ip = models.IPAddressField(_("IP Address of the Article Creator"),
# blank=True, null=True)
# created_at = models.DateTimeField(default=datetime.now)
# last_update = models.DateTimeField(blank=True, null=True)
# removed = models.BooleanField(_("Is removed?"), default=False)
#
# content_type = models.ForeignKey(ContentType, null=True)
# object_id = models.PositiveIntegerField(null=True)
# group = generic.GenericForeignKey('content_type', 'object_id')
#
# tags = TagField()
#
# objects = QuerySetManager()
#
# non_removed_objects = NonRemovedArticleManager()
#
# class QuerySet(QuerySet):
#
# def get_by(self, title, group=None):
# if group is None:
# return self.get(title=title)
# return group.get_related_objects(self.filter(title=title)).get()
#
# class Meta:
# verbose_name = _(u'Article')
# verbose_name_plural = _(u'Articles')
#
# def get_absolute_url(self):
# if self.group is None:
# return reverse('wiki_article', args=(self.title,))
# return self.group.get_absolute_url() + 'wiki/' + self.title
#
# def save(self, force_insert=False, force_update=False):
# self.last_update = datetime.now()
# super(Article, self).save(force_insert, force_update)
#
# def remove(self):
# """ Mark the Article as 'removed'. If the article is
# already removed, delete it.
# Returns True if the article was deleted, False when just marked
# as removed.
# """
# if self.removed:
# self.delete()
# return True
# else:
# self.removed = True
# self.save()
# return False
#
# def latest_changeset(self):
# try:
# return self.changeset_set.filter(
# reverted=False).order_by('-revision')[0]
# except IndexError:
# return ChangeSet.objects.none()
#
# def new_revision(self, old_content, old_title, old_markup,
# comment, editor_ip, editor):
# '''Create a new ChangeSet with the old content.'''
#
# content_diff = diff(self.content, old_content)
#
# cs = ChangeSet.objects.create(
# article=self,
# comment=comment,
# editor_ip=editor_ip,
# editor=editor,
# old_title=old_title,
# old_markup=old_markup,
# content_diff=content_diff)
#
# if None not in (notification, self.creator):
# if editor is None:
# editor = editor_ip
# notification.send([self.creator], "wiki_article_edited",
# {'article': self, 'user': editor})
#
# return cs
#
# def revert_to(self, revision, editor_ip, editor=None):
# """ Revert the article to a previuos state, by revision number.
# """
# changeset = self.changeset_set.get(revision=revision)
# changeset.reapply(editor_ip, editor)
#
#
# def __unicode__(self):
# return self.title
, which may contain function names, class names, or code. Output only the next line. | content_type = forms.ModelChoiceField( |
Given the code snippet: <|code_start|># -*- coding: utf-8 -*-
LOG = logging.getLogger(__name__)
__name__ = "mbot"
__author__ = "Michael Kuty"
DATA_PATH = appdirs.user_data_dir(__name__, __author__)
CONFIG_PATH = appdirs.user_config_dir(__name__, __author__)
CONFIG_FORMAT = "yaml"
DEFAULT_CONFIG = """
core:
data_path: {data_path}
config_path: {config_path}
backends:
- slack
slack:
token: {slack_token}
engine: mbot.backends.slack.Slack
<|code_end|>
, generate the next line using the imports in this file:
import logging
import os
import anyconfig
import appdirs
from mbot.utils.packages import install_package
from raven import Client
from cryptography.fernet import Fernet
from cryptography.fernet import Fernet
and context (functions, classes, or occasionally code) from other files:
# Path: mbot/utils/packages.py
# def install_package(package, upgrade=True,
# target=None):
# """Install a package on PyPi. Accepts pip compatible package strings.
# Return boolean if install successful.
# """
# # Not using 'import pip; pip.main([])' because it breaks the logger
# with INSTALL_LOCK:
# if check_package_exists(package, target):
# return True
#
# _LOGGER.info('Attempting install of %s', package)
# args = [sys.executable, '-m', 'pip', 'install', '--quiet', package]
# if upgrade:
# args.append('--upgrade')
# if target:
# args += ['--target', os.path.abspath(target)]
#
# try:
# return subprocess.call(args) == 0
# except subprocess.SubprocessError:
# _LOGGER.exception('Unable to install pacakge %s', package)
# return False
. Output only the next line. | middlewares: |
Based on the snippet: <|code_start|># Copyright Contributors to the Numpyro project.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
class IterativeUTurnState(NamedTuple):
momentum: Array
momentum_sum: Array
<|code_end|>
, predict the immediate next line with the help of imports:
from typing import NamedTuple
from blackjax.types import Array
import jax
import jax.numpy as jnp
and context (classes, functions, sometimes code) from other files:
# Path: blackjax/types.py
. Output only the next line. | idx_min: int |
Next line prediction: <|code_start|>
def kernel_generator(step_size: float):
return functools.partial(
kernel,
logprob_fn=logprob_fn,
step_size=step_size,
inverse_mass_matrix=inv_mass_matrix,
num_integration_steps=10,
)
# Test that the algorithm actually does something
_find_step_size = self.variant(
functools.partial(
find_reasonable_step_size, kernel_generator=kernel_generator
)
)
epsilon_1 = _find_step_size(
run_key0,
reference_state=reference_state,
initial_step_size=0.01,
target_accept=0.95,
)
assert not epsilon_1 == 1.0
assert not epsilon_1 == np.inf
# Different target acceptance rate
epsilon_2 = _find_step_size(
run_key1,
reference_state=reference_state,
initial_step_size=1.0,
<|code_end|>
. Use current file imports:
(import functools
import chex
import jax
import jax.numpy as jnp
import numpy as np
import blackjax.mcmc.hmc as hmc
from absl.testing import absltest
from blackjax.adaptation.step_size import find_reasonable_step_size)
and context including class names, function names, or small code snippets from other files:
# Path: blackjax/adaptation/step_size.py
# def find_reasonable_step_size(
# rng_key: PRNGKey,
# kernel_generator: Callable[[float], Callable],
# reference_state: HMCState,
# initial_step_size: float,
# target_accept: float = 0.65,
# ) -> float:
# """Find a reasonable initial step size during warmup.
#
# While the dual averaging scheme is guaranteed to converge to a reasonable
# value for the step size starting from any value, choosing a good first
# value can speed up the convergence. This heuristics doubles and halves the
# step size until the acceptance probability of the HMC proposal crosses the
# target value [Hoffman2014b]_.
#
# Parameters
# ----------
# rng_key
# Key used by JAX's random number generator.
# kernel_generator
# A function that takes a step size as an input and returns the corresponding
# sampling kernel.
# reference_hmc_state
# The location (HMC state) where this first step size must be found. This function
# never advances the chain.
# inverse_mass_matrix
# The inverse mass matrix relative to which the step size must be found.
# initial_step_size
# The first step size used to start the search.
# target_accept
# Once that value of the metropolis acceptance probability is reached we
# estimate that we have found a "reasonable" first step size.
#
# Returns
# -------
# float
# A reasonable first value for the step size.
#
# References
# ----------
# .. [Hoffman2014b] Hoffman, Matthew D., and Andrew Gelman. "The No-U-Turn sampler:
# adaptively setting path lengths in Hamiltonian Monte Carlo." Journal
# of Machine Learning Research 15.1 (2014): 1593-1623.
#
# """
# fp_limit = jnp.finfo(jax.lax.dtype(initial_step_size))
#
# def do_continue(rss_state: ReasonableStepSizeState) -> bool:
# """Decides whether the search should continue.
#
# The search stops when it crosses the `target_accept` threshold, i.e.
# when the current direction is opposite to the previous direction.
#
# Note
# ----
# Per JAX's documentation [1]_ the `jnp.finfo` object is cached so we do not
# occur any performance penalty when calling it repeatedly inside this
# function.
#
# References
# ----------
# .. [1] jax.numpy.finfo documentation. https://jax.readthedocs.io/en/latest/_autosummary/jax.numpy.finfo.html
#
# """
# _, direction, previous_direction, step_size = rss_state
#
# not_too_large = (step_size < fp_limit.max) | (direction <= 0)
# not_too_small = (step_size > fp_limit.tiny) | (direction >= 0)
# is_step_size_not_extreme = not_too_large & not_too_small
# has_acceptance_rate_not_crossed_threshold = (previous_direction == 0) | (
# direction == previous_direction
# )
# return is_step_size_not_extreme & has_acceptance_rate_not_crossed_threshold
#
# def update(rss_state: ReasonableStepSizeState) -> Tuple:
# """Perform one step of the step size search."""
# rng_key, direction, _, step_size = rss_state
# _, rng_key = jax.random.split(rng_key)
#
# step_size = (2.0 ** direction) * step_size
# kernel = kernel_generator(step_size)
# _, info = kernel(rng_key, reference_state)
#
# new_direction = jnp.where(target_accept < info.acceptance_probability, 1, -1)
# return ReasonableStepSizeState(rng_key, new_direction, direction, step_size)
#
# rss_state = ReasonableStepSizeState(rng_key, 0, 0, initial_step_size)
# rss_state = jax.lax.while_loop(do_continue, update, rss_state)
#
# return rss_state.step_size
. Output only the next line. | target_accept=0.05, |
Continue the code snippet: <|code_start|>
class GaussianEuclideanMetricsTest(chex.TestCase):
def setUp(self):
super().setUp()
self.key = random.PRNGKey(0)
self.dtype = "float32"
@parameterized.named_parameters(
<|code_end|>
. Use current file imports:
import chex
import jax.numpy as jnp
import numpy as np
from absl.testing import absltest, parameterized
from jax import random
from blackjax.mcmc import metrics
and context (classes, functions, or code) from other files:
# Path: blackjax/mcmc/metrics.py
# def gaussian_euclidean(
# inverse_mass_matrix: Array,
# ) -> Tuple[Callable, EuclideanKineticEnergy, Callable]:
# def momentum_generator(rng_key: PRNGKey, position: PyTree) -> PyTree:
# def kinetic_energy(momentum: PyTree) -> float:
# def is_turning(
# momentum_left: PyTree, momentum_right: PyTree, momentum_sum: PyTree
# ) -> bool:
. Output only the next line. | {"testcase_name": "0d", "shape": ()}, |
Using the snippet: <|code_start|>""" All things resampling. """
def _resampling_func(func, name, desc="", additional_params="") -> Callable:
# Decorator for resampling function
doc = f"""
{name} resampling. {desc}
Parameters
----------
weights: jnp.ndarray
Weights to resample
key: jnp.ndarray
<|code_end|>
, determine the next line of code. You have imports:
from functools import partial
from typing import Callable
from blackjax.types import PRNGKey
import jax
import jax.numpy as jnp
and context (class names, function names, or code) available:
# Path: blackjax/types.py
. Output only the next line. | PRNGKey to use in resampling |
Continue the code snippet: <|code_start|>r"""Metric space in which the Hamiltonian dynamic is embedded.
An important particular case (and the most used in practice) of metric for the
position space in the Euclidean metric. It is defined by a definite positive
matrix :math:`M` with fixed value so that the kinetic energy of the hamiltonian
<|code_end|>
. Use current file imports:
from typing import Callable, Tuple
from jax.flatten_util import ravel_pytree
from blackjax.types import Array, PRNGKey, PyTree
import jax
import jax.numpy as jnp
import jax.scipy as jscipy
and context (classes, functions, or code) from other files:
# Path: blackjax/types.py
. Output only the next line. | dynamic is independent of the position and only depends on the momentum |
Continue the code snippet: <|code_start|>r"""Metric space in which the Hamiltonian dynamic is embedded.
An important particular case (and the most used in practice) of metric for the
position space in the Euclidean metric. It is defined by a definite positive
matrix :math:`M` with fixed value so that the kinetic energy of the hamiltonian
dynamic is independent of the position and only depends on the momentum
:math:`p` [1]_.
For a Newtonian hamiltonian dynamic the kinetic energy is given by:
.. math::
K(p) = \frac{1}{2} p^T M^{-1} p
We can also generate a relativistic dynamic [2]_.
References
----------
.. [1]: Betancourt, Michael, et al. "The geometric foundations of hamiltonian
<|code_end|>
. Use current file imports:
from typing import Callable, Tuple
from jax.flatten_util import ravel_pytree
from blackjax.types import Array, PRNGKey, PyTree
import jax
import jax.numpy as jnp
import jax.scipy as jscipy
and context (classes, functions, or code) from other files:
# Path: blackjax/types.py
. Output only the next line. | monte carlo." Bernoulli 23.4A (2017): 2257-2298. |
Predict the next line after this snippet: <|code_start|>r"""Metric space in which the Hamiltonian dynamic is embedded.
An important particular case (and the most used in practice) of metric for the
position space in the Euclidean metric. It is defined by a definite positive
<|code_end|>
using the current file's imports:
from typing import Callable, Tuple
from jax.flatten_util import ravel_pytree
from blackjax.types import Array, PRNGKey, PyTree
import jax
import jax.numpy as jnp
import jax.scipy as jscipy
and any relevant context from other files:
# Path: blackjax/types.py
. Output only the next line. | matrix :math:`M` with fixed value so that the kinetic energy of the hamiltonian |
Predict the next line after this snippet: <|code_start|>def kernel(
logprior_fn: Callable,
loglikelihood_fn: Callable,
mcmc_kernel_factory: Callable,
make_mcmc_state: Callable,
resampling_fn: Callable,
target_ess: float,
root_solver: Callable = solver.dichotomy,
use_log_ess: bool = True,
mcmc_iter: int = 10,
) -> Callable:
r"""Build a Tempered SMC step using an adaptive schedule.
Parameters
----------
logprior_fn: Callable
A function that computes the log-prior density.
loglikelihood_fn: Callable
A function that returns the log-likelihood density.
mcmc_kernel_factory: Callable
A callable function that creates a mcmc kernel from a log-probability
density function.
make_mcmc_state: Callable
A function that creates a new mcmc state from a position and a
log-probability density function.
resampling_fn: Callable
A random function that resamples generated particles based of weights
target_ess: float
The target ESS for the adaptive MCMC tempering
root_solver: Callable, optional
<|code_end|>
using the current file's imports:
from typing import Callable, Tuple
from blackjax.types import PRNGKey
import jax
import jax.numpy as jnp
import blackjax.smc.base as base
import blackjax.smc.ess as ess
import blackjax.smc.solver as solver
import blackjax.smc.tempered as tempered
and any relevant context from other files:
# Path: blackjax/types.py
. Output only the next line. | A solver utility to find delta matching the target ESS. Signature is |
Next line prediction: <|code_start|>
__all__ = [
"adaptive_tempered_smc",
"hmc",
"nuts",
"rmh",
<|code_end|>
. Use current file imports:
(from typing import Callable, Dict, Union
from blackjax.base import AdaptationAlgorithm, SamplingAlgorithm
from blackjax.types import Array, PRNGKey, PyTree
import jax
import blackjax.adaptation as adaptation
import blackjax.mcmc as mcmc
import blackjax.smc as smc)
and context including class names, function names, or small code snippets from other files:
# Path: blackjax/base.py
# class AdaptationAlgorithm(NamedTuple):
# """A function that implements an adaptation algorithm."""
#
# run: RunFn
#
# class SamplingAlgorithm(NamedTuple):
# """A pair of functions that implement a sampling algorithm.
#
# Blackjax sampling algorithms are implemented as a pair of pure functions: a
# kernel, that takes a new samples starting from the current state, and an
# initialization function that creates a kernel state from a chain position.
#
# As they represent Markov kernels, the kernel functions are pure functions
# and do not have internal state. To save computation time they also operate
# on states which contain the chain state and additional information that
# needs to be carried over for the next step.
#
# Attributes
# ---------
# init:
# A pure function which when called with the initial position and the
# target density probability function will return the kernel's initial
# state.
#
# step:
# A pure function that takes a rng key, a state and possibly some
# parameters and returns a new state and some information about the
# transition.
#
# """
#
# init: InitFn
# step: UpdateFn
#
# Path: blackjax/types.py
. Output only the next line. | "tempered_smc", |
Given snippet: <|code_start|>
__all__ = [
"adaptive_tempered_smc",
"hmc",
"nuts",
"rmh",
"tempered_smc",
"window_adaptation",
]
# -----------------------------------------------------------------------------
# SEQUENTIAL MONTE CARLO
# -----------------------------------------------------------------------------
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from typing import Callable, Dict, Union
from blackjax.base import AdaptationAlgorithm, SamplingAlgorithm
from blackjax.types import Array, PRNGKey, PyTree
import jax
import blackjax.adaptation as adaptation
import blackjax.mcmc as mcmc
import blackjax.smc as smc
and context:
# Path: blackjax/base.py
# class AdaptationAlgorithm(NamedTuple):
# """A function that implements an adaptation algorithm."""
#
# run: RunFn
#
# class SamplingAlgorithm(NamedTuple):
# """A pair of functions that implement a sampling algorithm.
#
# Blackjax sampling algorithms are implemented as a pair of pure functions: a
# kernel, that takes a new samples starting from the current state, and an
# initialization function that creates a kernel state from a chain position.
#
# As they represent Markov kernels, the kernel functions are pure functions
# and do not have internal state. To save computation time they also operate
# on states which contain the chain state and additional information that
# needs to be carried over for the next step.
#
# Attributes
# ---------
# init:
# A pure function which when called with the initial position and the
# target density probability function will return the kernel's initial
# state.
#
# step:
# A pure function that takes a rng key, a state and possibly some
# parameters and returns a new state and some information about the
# transition.
#
# """
#
# init: InitFn
# step: UpdateFn
#
# Path: blackjax/types.py
which might include code, classes, or functions. Output only the next line. | class adaptive_tempered_smc: |
Predict the next line for this snippet: <|code_start|>
__all__ = [
"adaptive_tempered_smc",
"hmc",
"nuts",
"rmh",
"tempered_smc",
"window_adaptation",
]
# -----------------------------------------------------------------------------
# SEQUENTIAL MONTE CARLO
# -----------------------------------------------------------------------------
<|code_end|>
with the help of current file imports:
from typing import Callable, Dict, Union
from blackjax.base import AdaptationAlgorithm, SamplingAlgorithm
from blackjax.types import Array, PRNGKey, PyTree
import jax
import blackjax.adaptation as adaptation
import blackjax.mcmc as mcmc
import blackjax.smc as smc
and context from other files:
# Path: blackjax/base.py
# class AdaptationAlgorithm(NamedTuple):
# """A function that implements an adaptation algorithm."""
#
# run: RunFn
#
# class SamplingAlgorithm(NamedTuple):
# """A pair of functions that implement a sampling algorithm.
#
# Blackjax sampling algorithms are implemented as a pair of pure functions: a
# kernel, that takes a new samples starting from the current state, and an
# initialization function that creates a kernel state from a chain position.
#
# As they represent Markov kernels, the kernel functions are pure functions
# and do not have internal state. To save computation time they also operate
# on states which contain the chain state and additional information that
# needs to be carried over for the next step.
#
# Attributes
# ---------
# init:
# A pure function which when called with the initial position and the
# target density probability function will return the kernel's initial
# state.
#
# step:
# A pure function that takes a rng key, a state and possibly some
# parameters and returns a new state and some information about the
# transition.
#
# """
#
# init: InitFn
# step: UpdateFn
#
# Path: blackjax/types.py
, which may contain function names, class names, or code. Output only the next line. | class adaptive_tempered_smc: |
Given snippet: <|code_start|># -*- coding: utf-8 -*-
@pytest.fixture()
def model(request):
model = Model()
return model
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pywr
import pandas
import datetime
import pytest
from pywr.core import (
Model,
Input,
Output,
Link,
Storage,
AggregatedStorage,
AggregatedNode,
)
from helpers import load_model
and context:
# Path: pywr/core.py
which might include code, classes, or functions. Output only the next line. | @pytest.fixture() |
Using the snippet: <|code_start|># -*- coding: utf-8 -*-
@pytest.fixture()
def model(request):
model = Model()
return model
<|code_end|>
, determine the next line of code. You have imports:
import pywr
import pandas
import datetime
import pytest
from pywr.core import (
Model,
Input,
Output,
Link,
Storage,
AggregatedStorage,
AggregatedNode,
)
from helpers import load_model
and context (class names, function names, or code) available:
# Path: pywr/core.py
. Output only the next line. | @pytest.fixture() |
Here is a snippet: <|code_start|># -*- coding: utf-8 -*-
@pytest.fixture()
def model(request):
model = Model()
return model
<|code_end|>
. Write the next line using the current file imports:
import pywr
import pandas
import datetime
import pytest
from pywr.core import (
Model,
Input,
Output,
Link,
Storage,
AggregatedStorage,
AggregatedNode,
)
from helpers import load_model
and context from other files:
# Path: pywr/core.py
, which may include functions, classes, or code. Output only the next line. | @pytest.fixture() |
Next line prediction: <|code_start|>#!/usr/bin/env python
def test_base_license():
with pytest.raises(TypeError):
lic = License()
<|code_end|>
. Use current file imports:
(import pytest
import numpy as np
import pandas
import pandas as pd
import datetime, calendar
from datetime import datetime
from pywr.core import Timestep, ScenarioIndex, Model
from pywr.parameters.licenses import (
License,
TimestepLicense,
AnnualLicense,
AnnualExponentialLicense,
AnnualHyperbolaLicense,
)
from pywr.recorders import NumpyArrayNodeRecorder
from fixtures import simple_linear_model
from helpers import load_model
from numpy.testing import assert_allclose)
and context including class names, function names, or small code snippets from other files:
# Path: pywr/core.py
#
# Path: pywr/parameters/licenses.py
# class License(BaseParameter):
# """Base license class from which others inherit
#
# This class should not be instantiated directly. Instead, use one of the
# subclasses (e.g. DailyLicense).
# """
#
# def __new__(cls, *args, **kwargs):
# if cls is License:
# raise TypeError("License cannot be instantiated directly")
# else:
# return BaseParameter.__new__(cls)
#
# def __init__(self, model, node, **kwargs):
# super(License, self).__init__(model, **kwargs)
# self._node = node
#
# def resource_state(self, timestep):
# raise NotImplementedError()
#
# class TimestepLicense(License):
# """License limiting volume for a single timestep
#
# This is the simplest kind of license. The volume available each timestep
# is a fixed value. There is no resource state, as use today does not
# impact availability tomorrow.
# """
#
# def __init__(self, model, node, amount, **kwargs):
# """Initialise a new TimestepLicense
#
# Parameters
# ----------
# amount : float
# The maximum volume available in each timestep
# """
# super(TimestepLicense, self).__init__(model, node, **kwargs)
# self._amount = amount
#
# def value(self, timestep, scenario_index):
# return self._amount
#
# def resource_state(self, timestep):
# return None
#
# class AnnualLicense(StorageLicense):
# """An annual license that apportions remaining volume equally for the rest of the year
#
# value = (volume remaining) / (days remaining) * (timestep length)
#
# Parameters
# ----------
# node : Node
# The node that consumes the licence
# amount : float
# The total annual volume for this license
# """
#
# def __init__(self, *args, **kwargs):
# super(AnnualLicense, self).__init__(*args, **kwargs)
# # Record year ready to reset licence when the year changes.
# self._prev_year = None
#
# def value(self, timestep, scenario_index):
# i = scenario_index.global_id
# day_of_year = timestep.dayofyear
# days_in_year = 365 + int(calendar.isleap(timestep.year))
# if day_of_year == days_in_year:
# return self._remaining[i]
# else:
# days_remaining = days_in_year - (day_of_year - 1)
# return self._remaining[i] / days_remaining
#
# def before(self):
# # Reset licence if year changes.
# timestep = self.model.timestepper.current
# if self._prev_year != timestep.year:
# self.reset()
#
# # The number of days in the year before the first timestep of that year
# days_before_reset = timestep.dayofyear - 1
# # Adjust the license by the rate in previous timestep. This is needed for timesteps greater
# # than 1 day where the license reset is not exactly on the anniversary
# self._remaining[...] -= days_before_reset * self._node.prev_flow
#
# self._prev_year = timestep.year
#
# class AnnualExponentialLicense(AnnualLicense):
# """An annual license that returns a value based on an exponential function of the license's current state.
#
# The exponential function takes the form,
#
# .. math::
# f(t) = \mathit{max_value}e^{-x/k}
#
# Where :math:`x` is the ratio of actual daily averaged remaining license (as calculated by AnnualLicense) to the
# expected daily averaged remaining licence. I.e. if the license is on track the ratio is 1.0.
# """
#
# def __init__(self, model, node, amount, max_value, k=1.0, **kwargs):
# """
#
# Parameters
# ----------
# amount : float
# The total annual volume for this license
# max_value : float
# The maximum value that can be returned. This is used to scale the exponential function
# k : float
# A scale factor for the exponent of the exponential function
# """
# super(AnnualExponentialLicense, self).__init__(model, node, amount, **kwargs)
# self._max_value = max_value
# self._k = k
#
# def value(self, timestep, scenario_index):
# remaining = super(AnnualExponentialLicense, self).value(
# timestep, scenario_index
# )
# expected = self._amount / (365 + int(calendar.isleap(timestep.year)))
# x = remaining / expected
# return self._max_value * np.exp(-x / self._k)
#
# class AnnualHyperbolaLicense(AnnualLicense):
# """An annual license that returns a value based on an hyperbola (1/x) function of the license's current state.
#
# The hyperbola function takes the form,
#
# .. math::
# f(t) = \mathit{value}/x
#
# Where :math:`x` is the ratio of actual daily averaged remaining license (as calculated by AnnualLicense) to the
# expected daily averaged remaining licence. I.e. if the license is on track the ratio is 1.0.
# """
#
# def __init__(self, model, node, amount, value, **kwargs):
# """
#
# Parameters
# ----------
# amount : float
# The total annual volume for this license
# value : float
# The value used to scale the hyperbola function
# """
# super(AnnualHyperbolaLicense, self).__init__(model, node, amount, **kwargs)
# self._value = value
#
# def value(self, timestep, scenario_index):
# remaining = super(AnnualHyperbolaLicense, self).value(timestep, scenario_index)
# expected = self._amount / (365 + int(calendar.isleap(timestep.year)))
# x = remaining / expected
# try:
# return self._value / x
# except ZeroDivisionError:
# return inf
. Output only the next line. | def test_daily_license(simple_linear_model): |
Given the code snippet: <|code_start|>#!/usr/bin/env python
def test_base_license():
with pytest.raises(TypeError):
lic = License()
<|code_end|>
, generate the next line using the imports in this file:
import pytest
import numpy as np
import pandas
import pandas as pd
import datetime, calendar
from datetime import datetime
from pywr.core import Timestep, ScenarioIndex, Model
from pywr.parameters.licenses import (
License,
TimestepLicense,
AnnualLicense,
AnnualExponentialLicense,
AnnualHyperbolaLicense,
)
from pywr.recorders import NumpyArrayNodeRecorder
from fixtures import simple_linear_model
from helpers import load_model
from numpy.testing import assert_allclose
and context (functions, classes, or occasionally code) from other files:
# Path: pywr/core.py
#
# Path: pywr/parameters/licenses.py
# class License(BaseParameter):
# """Base license class from which others inherit
#
# This class should not be instantiated directly. Instead, use one of the
# subclasses (e.g. DailyLicense).
# """
#
# def __new__(cls, *args, **kwargs):
# if cls is License:
# raise TypeError("License cannot be instantiated directly")
# else:
# return BaseParameter.__new__(cls)
#
# def __init__(self, model, node, **kwargs):
# super(License, self).__init__(model, **kwargs)
# self._node = node
#
# def resource_state(self, timestep):
# raise NotImplementedError()
#
# class TimestepLicense(License):
# """License limiting volume for a single timestep
#
# This is the simplest kind of license. The volume available each timestep
# is a fixed value. There is no resource state, as use today does not
# impact availability tomorrow.
# """
#
# def __init__(self, model, node, amount, **kwargs):
# """Initialise a new TimestepLicense
#
# Parameters
# ----------
# amount : float
# The maximum volume available in each timestep
# """
# super(TimestepLicense, self).__init__(model, node, **kwargs)
# self._amount = amount
#
# def value(self, timestep, scenario_index):
# return self._amount
#
# def resource_state(self, timestep):
# return None
#
# class AnnualLicense(StorageLicense):
# """An annual license that apportions remaining volume equally for the rest of the year
#
# value = (volume remaining) / (days remaining) * (timestep length)
#
# Parameters
# ----------
# node : Node
# The node that consumes the licence
# amount : float
# The total annual volume for this license
# """
#
# def __init__(self, *args, **kwargs):
# super(AnnualLicense, self).__init__(*args, **kwargs)
# # Record year ready to reset licence when the year changes.
# self._prev_year = None
#
# def value(self, timestep, scenario_index):
# i = scenario_index.global_id
# day_of_year = timestep.dayofyear
# days_in_year = 365 + int(calendar.isleap(timestep.year))
# if day_of_year == days_in_year:
# return self._remaining[i]
# else:
# days_remaining = days_in_year - (day_of_year - 1)
# return self._remaining[i] / days_remaining
#
# def before(self):
# # Reset licence if year changes.
# timestep = self.model.timestepper.current
# if self._prev_year != timestep.year:
# self.reset()
#
# # The number of days in the year before the first timestep of that year
# days_before_reset = timestep.dayofyear - 1
# # Adjust the license by the rate in previous timestep. This is needed for timesteps greater
# # than 1 day where the license reset is not exactly on the anniversary
# self._remaining[...] -= days_before_reset * self._node.prev_flow
#
# self._prev_year = timestep.year
#
# class AnnualExponentialLicense(AnnualLicense):
# """An annual license that returns a value based on an exponential function of the license's current state.
#
# The exponential function takes the form,
#
# .. math::
# f(t) = \mathit{max_value}e^{-x/k}
#
# Where :math:`x` is the ratio of actual daily averaged remaining license (as calculated by AnnualLicense) to the
# expected daily averaged remaining licence. I.e. if the license is on track the ratio is 1.0.
# """
#
# def __init__(self, model, node, amount, max_value, k=1.0, **kwargs):
# """
#
# Parameters
# ----------
# amount : float
# The total annual volume for this license
# max_value : float
# The maximum value that can be returned. This is used to scale the exponential function
# k : float
# A scale factor for the exponent of the exponential function
# """
# super(AnnualExponentialLicense, self).__init__(model, node, amount, **kwargs)
# self._max_value = max_value
# self._k = k
#
# def value(self, timestep, scenario_index):
# remaining = super(AnnualExponentialLicense, self).value(
# timestep, scenario_index
# )
# expected = self._amount / (365 + int(calendar.isleap(timestep.year)))
# x = remaining / expected
# return self._max_value * np.exp(-x / self._k)
#
# class AnnualHyperbolaLicense(AnnualLicense):
# """An annual license that returns a value based on an hyperbola (1/x) function of the license's current state.
#
# The hyperbola function takes the form,
#
# .. math::
# f(t) = \mathit{value}/x
#
# Where :math:`x` is the ratio of actual daily averaged remaining license (as calculated by AnnualLicense) to the
# expected daily averaged remaining licence. I.e. if the license is on track the ratio is 1.0.
# """
#
# def __init__(self, model, node, amount, value, **kwargs):
# """
#
# Parameters
# ----------
# amount : float
# The total annual volume for this license
# value : float
# The value used to scale the hyperbola function
# """
# super(AnnualHyperbolaLicense, self).__init__(model, node, amount, **kwargs)
# self._value = value
#
# def value(self, timestep, scenario_index):
# remaining = super(AnnualHyperbolaLicense, self).value(timestep, scenario_index)
# expected = self._amount / (365 + int(calendar.isleap(timestep.year)))
# x = remaining / expected
# try:
# return self._value / x
# except ZeroDivisionError:
# return inf
. Output only the next line. | def test_daily_license(simple_linear_model): |
Given snippet: <|code_start|>#!/usr/bin/env python
def test_base_license():
with pytest.raises(TypeError):
lic = License()
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pytest
import numpy as np
import pandas
import pandas as pd
import datetime, calendar
from datetime import datetime
from pywr.core import Timestep, ScenarioIndex, Model
from pywr.parameters.licenses import (
License,
TimestepLicense,
AnnualLicense,
AnnualExponentialLicense,
AnnualHyperbolaLicense,
)
from pywr.recorders import NumpyArrayNodeRecorder
from fixtures import simple_linear_model
from helpers import load_model
from numpy.testing import assert_allclose
and context:
# Path: pywr/core.py
#
# Path: pywr/parameters/licenses.py
# class License(BaseParameter):
# """Base license class from which others inherit
#
# This class should not be instantiated directly. Instead, use one of the
# subclasses (e.g. DailyLicense).
# """
#
# def __new__(cls, *args, **kwargs):
# if cls is License:
# raise TypeError("License cannot be instantiated directly")
# else:
# return BaseParameter.__new__(cls)
#
# def __init__(self, model, node, **kwargs):
# super(License, self).__init__(model, **kwargs)
# self._node = node
#
# def resource_state(self, timestep):
# raise NotImplementedError()
#
# class TimestepLicense(License):
# """License limiting volume for a single timestep
#
# This is the simplest kind of license. The volume available each timestep
# is a fixed value. There is no resource state, as use today does not
# impact availability tomorrow.
# """
#
# def __init__(self, model, node, amount, **kwargs):
# """Initialise a new TimestepLicense
#
# Parameters
# ----------
# amount : float
# The maximum volume available in each timestep
# """
# super(TimestepLicense, self).__init__(model, node, **kwargs)
# self._amount = amount
#
# def value(self, timestep, scenario_index):
# return self._amount
#
# def resource_state(self, timestep):
# return None
#
# class AnnualLicense(StorageLicense):
# """An annual license that apportions remaining volume equally for the rest of the year
#
# value = (volume remaining) / (days remaining) * (timestep length)
#
# Parameters
# ----------
# node : Node
# The node that consumes the licence
# amount : float
# The total annual volume for this license
# """
#
# def __init__(self, *args, **kwargs):
# super(AnnualLicense, self).__init__(*args, **kwargs)
# # Record year ready to reset licence when the year changes.
# self._prev_year = None
#
# def value(self, timestep, scenario_index):
# i = scenario_index.global_id
# day_of_year = timestep.dayofyear
# days_in_year = 365 + int(calendar.isleap(timestep.year))
# if day_of_year == days_in_year:
# return self._remaining[i]
# else:
# days_remaining = days_in_year - (day_of_year - 1)
# return self._remaining[i] / days_remaining
#
# def before(self):
# # Reset licence if year changes.
# timestep = self.model.timestepper.current
# if self._prev_year != timestep.year:
# self.reset()
#
# # The number of days in the year before the first timestep of that year
# days_before_reset = timestep.dayofyear - 1
# # Adjust the license by the rate in previous timestep. This is needed for timesteps greater
# # than 1 day where the license reset is not exactly on the anniversary
# self._remaining[...] -= days_before_reset * self._node.prev_flow
#
# self._prev_year = timestep.year
#
# class AnnualExponentialLicense(AnnualLicense):
# """An annual license that returns a value based on an exponential function of the license's current state.
#
# The exponential function takes the form,
#
# .. math::
# f(t) = \mathit{max_value}e^{-x/k}
#
# Where :math:`x` is the ratio of actual daily averaged remaining license (as calculated by AnnualLicense) to the
# expected daily averaged remaining licence. I.e. if the license is on track the ratio is 1.0.
# """
#
# def __init__(self, model, node, amount, max_value, k=1.0, **kwargs):
# """
#
# Parameters
# ----------
# amount : float
# The total annual volume for this license
# max_value : float
# The maximum value that can be returned. This is used to scale the exponential function
# k : float
# A scale factor for the exponent of the exponential function
# """
# super(AnnualExponentialLicense, self).__init__(model, node, amount, **kwargs)
# self._max_value = max_value
# self._k = k
#
# def value(self, timestep, scenario_index):
# remaining = super(AnnualExponentialLicense, self).value(
# timestep, scenario_index
# )
# expected = self._amount / (365 + int(calendar.isleap(timestep.year)))
# x = remaining / expected
# return self._max_value * np.exp(-x / self._k)
#
# class AnnualHyperbolaLicense(AnnualLicense):
# """An annual license that returns a value based on an hyperbola (1/x) function of the license's current state.
#
# The hyperbola function takes the form,
#
# .. math::
# f(t) = \mathit{value}/x
#
# Where :math:`x` is the ratio of actual daily averaged remaining license (as calculated by AnnualLicense) to the
# expected daily averaged remaining licence. I.e. if the license is on track the ratio is 1.0.
# """
#
# def __init__(self, model, node, amount, value, **kwargs):
# """
#
# Parameters
# ----------
# amount : float
# The total annual volume for this license
# value : float
# The value used to scale the hyperbola function
# """
# super(AnnualHyperbolaLicense, self).__init__(model, node, amount, **kwargs)
# self._value = value
#
# def value(self, timestep, scenario_index):
# remaining = super(AnnualHyperbolaLicense, self).value(timestep, scenario_index)
# expected = self._amount / (365 + int(calendar.isleap(timestep.year)))
# x = remaining / expected
# try:
# return self._value / x
# except ZeroDivisionError:
# return inf
which might include code, classes, or functions. Output only the next line. | def test_daily_license(simple_linear_model): |
Given the code snippet: <|code_start|>
class Item:
def __init__(self, name):
self.name = name
@pytest.fixture
def items():
return [
Item("Hello"),
Item("World"),
Item("River Thames"),
]
@pytest.fixture
def iterator(items):
i = NamedIterator()
for item in items:
i[item.name] = item
return i
def test_iterator_keys_and_values(items, iterator):
expected_names = {"Hello", "World", "River Thames"}
assert set(iterator.keys()) == expected_names
assert set(iterator.values()) == set(items)
<|code_end|>
, generate the next line using the imports in this file:
import pytest
from pywr.model import NamedIterator
and context (functions, classes, or occasionally code) from other files:
# Path: pywr/model.py
. Output only the next line. | def test_iterator_contains(items, iterator): |
Continue the code snippet: <|code_start|>
def pytest_report_header(config):
headers = []
solver_name = Model().solver.name
headers.append("solver: {}".format(solver_name))
<|code_end|>
. Use current file imports:
import os
from pywr.model import Model
and context (classes, functions, or code) from other files:
# Path: pywr/model.py
. Output only the next line. | return "\n".join(headers) |
Here is a snippet: <|code_start|>
def make_df(freq, start="2015-01-01", end="2015-12-31"):
# Daily time-step
index = pd.period_range(start, end, freq=freq)
series = pd.DataFrame(np.arange(len(index), dtype=np.float64), index=index)
<|code_end|>
. Write the next line using the current file imports:
from pywr.dataframe_tools import align_and_resample_dataframe, ResamplingError
import numpy as np
import pandas as pd
import pytest
and context from other files:
# Path: pywr/dataframe_tools.py
# def align_and_resample_dataframe(df, target_index, resample_func="mean"):
# """Align and resample a DataFrame to the provided index.
#
# This function attempts to align an input dataframe to a target index. The
# index of the incoming dataframe must be time based and will be cast to a
# `PeriodIndex` (using `to_period()`). Up or down sampling is selected based
# on the relative frequencies of the two indexes. The exact method depends
# also on the type of frequencies (offsets) involved (e.g. `Tick` or
# `DataOffset`). Up-sampling uses forward filling. Whereas down-sampling
# uses the provided `resample_func`.
#
# Parameters
# ==========
#
# df : `pandas.DataFrame`
# The input data that needs to be aligned and/or resampled.
# target_index : `pandas.PeriodIndex`
# The target index that the input should be aligned and resampled to match.
# resample_func : str, func
# Function to be used when down-sampling from high frequency data to lower
# frequency.
#
# """
# # Must resample and align the DataFrame to the model.
# start = target_index[0]
# end = target_index[-1]
#
# if not isinstance(df.index, pandas.PeriodIndex):
# # Converting to period is sometimes unreliable. E.g. with freq='7D'
# # If the target frequency is passed explicitly this can help, but
# # not all Timestamp frequencies convert to Period frequencies. Therefore,
# # this can not be the default.
# try:
# df = df.to_period()
# except AttributeError:
# df = df.to_period(df.index.freq.freqstr)
#
# if not isinstance(target_index, pandas.PeriodIndex):
# raise ValueError("Period index expected.")
#
# model_freq = target_index.freq
# df_freq = df.index.freq
#
# # Determine how to do the resampling based on the frequency type
# # and whether to do up or down sampling.
# if isinstance(model_freq, Tick):
# # Model is tick based e.g. daily or hourly
# if isinstance(df_freq, Tick):
# # Dataframe is also tick based
# if model_freq >= df_freq:
# # Down sampling (i.e. from high freq to lower model freq)
# df = _down_sample_tick_to_tick(df, target_index, resample_func)
# else:
# df = _up_sample_tick_to_tick(df, target_index)
# else:
# # Dataframe must be offset based
# # Generally this is going to be up sampling to a higher model freq
# df = _resample_date_offset_to_tick(df, target_index, resample_func)
#
# elif isinstance(model_freq, DateOffset):
# # Model is based on date offsets.
# if isinstance(df_freq, Tick):
# # Dataframe is tick based
# # Generally this is going to be down sampling to a lower model freq
# df = _down_sample_tick_to_date_offset(df, target_index, resample_func)
# else:
# # Dataframe must be offset based
# # Down sampling (i.e. from high freq to lower model freq)
# try:
# df = _resample_date_offset_to_date_offset(
# df, target_index, resample_func
# )
# except IncompatibleFrequency:
# raise ResamplingError(df, target_index)
#
# df = df[start:end]
#
# if not df.index.equals(target_index):
# raise ResamplingError(df, target_index)
#
# if df.isnull().values.any():
# raise ValueError("Missing values detected after resampling dataframe.")
#
# return df
#
# class ResamplingError(Exception):
# def __init__(self, original_dataframe, target_index):
# self.original_dataframe = original_dataframe
# self.target_index = target_index
# message = (
# f'Failed to convert input dataframe with index "{original_dataframe.index}" to model index '
# f'"{target_index}".'
# )
# super().__init__(message)
, which may include functions, classes, or code. Output only the next line. | return series |
Given the following code snippet before the placeholder: <|code_start|>
def make_df(freq, start="2015-01-01", end="2015-12-31"):
# Daily time-step
index = pd.period_range(start, end, freq=freq)
series = pd.DataFrame(np.arange(len(index), dtype=np.float64), index=index)
return series
def make_model_index(freq, start="2015-01-01", end="2015-12-31"):
<|code_end|>
, predict the next line using imports from the current file:
from pywr.dataframe_tools import align_and_resample_dataframe, ResamplingError
import numpy as np
import pandas as pd
import pytest
and context including class names, function names, and sometimes code from other files:
# Path: pywr/dataframe_tools.py
# def align_and_resample_dataframe(df, target_index, resample_func="mean"):
# """Align and resample a DataFrame to the provided index.
#
# This function attempts to align an input dataframe to a target index. The
# index of the incoming dataframe must be time based and will be cast to a
# `PeriodIndex` (using `to_period()`). Up or down sampling is selected based
# on the relative frequencies of the two indexes. The exact method depends
# also on the type of frequencies (offsets) involved (e.g. `Tick` or
# `DataOffset`). Up-sampling uses forward filling. Whereas down-sampling
# uses the provided `resample_func`.
#
# Parameters
# ==========
#
# df : `pandas.DataFrame`
# The input data that needs to be aligned and/or resampled.
# target_index : `pandas.PeriodIndex`
# The target index that the input should be aligned and resampled to match.
# resample_func : str, func
# Function to be used when down-sampling from high frequency data to lower
# frequency.
#
# """
# # Must resample and align the DataFrame to the model.
# start = target_index[0]
# end = target_index[-1]
#
# if not isinstance(df.index, pandas.PeriodIndex):
# # Converting to period is sometimes unreliable. E.g. with freq='7D'
# # If the target frequency is passed explicitly this can help, but
# # not all Timestamp frequencies convert to Period frequencies. Therefore,
# # this can not be the default.
# try:
# df = df.to_period()
# except AttributeError:
# df = df.to_period(df.index.freq.freqstr)
#
# if not isinstance(target_index, pandas.PeriodIndex):
# raise ValueError("Period index expected.")
#
# model_freq = target_index.freq
# df_freq = df.index.freq
#
# # Determine how to do the resampling based on the frequency type
# # and whether to do up or down sampling.
# if isinstance(model_freq, Tick):
# # Model is tick based e.g. daily or hourly
# if isinstance(df_freq, Tick):
# # Dataframe is also tick based
# if model_freq >= df_freq:
# # Down sampling (i.e. from high freq to lower model freq)
# df = _down_sample_tick_to_tick(df, target_index, resample_func)
# else:
# df = _up_sample_tick_to_tick(df, target_index)
# else:
# # Dataframe must be offset based
# # Generally this is going to be up sampling to a higher model freq
# df = _resample_date_offset_to_tick(df, target_index, resample_func)
#
# elif isinstance(model_freq, DateOffset):
# # Model is based on date offsets.
# if isinstance(df_freq, Tick):
# # Dataframe is tick based
# # Generally this is going to be down sampling to a lower model freq
# df = _down_sample_tick_to_date_offset(df, target_index, resample_func)
# else:
# # Dataframe must be offset based
# # Down sampling (i.e. from high freq to lower model freq)
# try:
# df = _resample_date_offset_to_date_offset(
# df, target_index, resample_func
# )
# except IncompatibleFrequency:
# raise ResamplingError(df, target_index)
#
# df = df[start:end]
#
# if not df.index.equals(target_index):
# raise ResamplingError(df, target_index)
#
# if df.isnull().values.any():
# raise ValueError("Missing values detected after resampling dataframe.")
#
# return df
#
# class ResamplingError(Exception):
# def __init__(self, original_dataframe, target_index):
# self.original_dataframe = original_dataframe
# self.target_index = target_index
# message = (
# f'Failed to convert input dataframe with index "{original_dataframe.index}" to model index '
# f'"{target_index}".'
# )
# super().__init__(message)
. Output only the next line. | return pd.period_range(start, end, freq=freq) |
Next line prediction: <|code_start|>
model = simple_linear_model
def test_keys_and_values(model):
expected_names = {"Input", "Link", "Output"}
assert set(model.nodes.keys()) == expected_names
nodes = {node for node in model.nodes}
assert len(nodes) == 3
assert set(model.nodes.values()) == nodes
<|code_end|>
. Use current file imports:
(from pywr.nodes import Node
from fixtures import simple_linear_model, simple_storage_model)
and context including class names, function names, or small code snippets from other files:
# Path: pywr/nodes.py
# class Node(Loadable, Drawable, Connectable, BaseNode, metaclass=NodeMeta):
# """Base object from which all other nodes inherit
#
# This BaseNode is not connectable by default, and the Node class should
# be used for actual Nodes in the model. The BaseNode provides an abstract
# class for other Node types (e.g. StorageInput) that are not directly
# Connectable.
# """
#
# __parameter_attributes__ = ("cost", "min_flow", "max_flow")
#
# def __init__(self, model, name, **kwargs):
# """Initialise a new Node object
#
# Parameters
# ----------
# model : Model
# The model the node belongs to
# name : string
# A unique name for the node
# """
# color = kwargs.pop("color", "black")
# min_flow = pop_kwarg_parameter(kwargs, "min_flow", 0.0)
# if min_flow is None:
# min_flow = 0.0
# max_flow = pop_kwarg_parameter(kwargs, "max_flow", float("inf"))
# cost = pop_kwarg_parameter(kwargs, "cost", 0.0)
# conversion_factor = pop_kwarg_parameter(kwargs, "conversion_factor", 1.0)
#
# super(Node, self).__init__(model, name, **kwargs)
#
# self.slots = {}
# self.color = color
# self.min_flow = min_flow
# self.max_flow = max_flow
# self.cost = cost
# self.conversion_factor = conversion_factor
#
# def check(self):
# """Check the node is valid
#
# Raises an exception if the node is invalid
# """
# pass
. Output only the next line. | def test_contains(model): |
Given the following code snippet before the placeholder: <|code_start|>
class TestNotification(TestCase):
def setUp(self):
account = AccountFactory.create()
self.user = account.user
def test_access_notification_list(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('notifications'))
<|code_end|>
, predict the next line using imports from the current file:
from django.test import TestCase
from django.core.urlresolvers import reverse
from account.factories import AccountFactory, DEFAULT_PASSWORD
and context including class names, function names, and sometimes code from other files:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# DEFAULT_PASSWORD = 'abc@123'
. Output only the next line. | self.assertEqual(response.status_code, 200) |
Given snippet: <|code_start|>
urlpatterns = [
url(r'^$', LinkView.new, name='link_new'),
url(r'^(?P<post_id>[0-9]+)/add/$', LinkView.add, name='link_add'),
url(r'^(?P<post_id>[0-9]+)/react/$', LinkReactionView.react, name='link_react'),
url(r'^(?P<post_id>[0-9]+)/unreact/$', LinkReactionView.unreact, name='link_unreact'),
url(r'^(?P<post_id>[0-9]+)/comment/$', LinkCommentView.comment, name='link_comment'),
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django.conf.urls import url
from link.views import LinkView, LinkReactionView, LinkCommentView
and context:
# Path: link/views.py
# class LinkView:
# @staticmethod
# def links(request, username):
# session_account = None
# notify_count = None
# profile = get_object_or_404(User, username=username)
# profile_account = Account.get_by_user(user=profile)
# profile.user_avatar = profile_account.user_avatar
# if request.user.is_authenticated:
# session_account = Account.get_by_user(request.user)
# request.user.is_following = session_account.is_following(profile_account)
# notify_count = Notification.objects.filter(owner=session_account, viewed=False).count()
# posts = Post.links_by_user(username, session_account)
# return render(request, 'link/link.html', {'profile': profile, 'posts': posts, 'links': True,
# 'notify_count': notify_count})
#
# @staticmethod
# @login_required
# def wall(request):
# posts = Post.feeds(request.user.username)
# notify_count = Notification.objects.filter(owner__user=request.user, viewed=False).count()
# return render(request, 'home.html', {'posts': posts, 'notify_count': notify_count})
#
# @staticmethod
# @login_required
# def new(request):
# form = None
# if request.method == 'POST':
# form = URLForm(request.POST)
# if form.is_valid():
# post = form.save(commit=False)
# user_account = Account.get_by_user(request.user)
# post.owner = user_account
# post.publisher = user_account
# try:
# post.set_metadata()
# post.save()
# return redirect('home')
# except LinkException as e:
# form.add_error(None, e)
# return render(request, 'home.html', {'form': form})
#
# @staticmethod
# @login_required
# def add(request, post_id):
# if request.method == 'POST':
# post = Post.objects.get(id=post_id)
# account = Account.get_by_user(request.user)
# post.add_link(account)
# Notification.add(post.publisher, account, NotificationType.ADD, post)
# redirect_path = request.GET['next']
# return redirect(redirect_path)
#
# class LinkReactionView:
# @staticmethod
# @login_required
# def react(request, post_id):
# if request.method == 'POST':
# reaction = Reaction()
# reaction.post = Post.objects.get(id=post_id)
# reaction.owner = Account.get_by_user(request.user)
# reaction.save()
# Notification.add(reaction.post.owner, reaction.owner,
# NotificationType.REACT, reaction.post)
# redirect_path = request.GET['next']
# return redirect(redirect_path)
#
# @staticmethod
# @login_required
# def unreact(request, post_id):
# if request.method == 'POST':
# reaction = Reaction.objects.filter(post__id=post_id, owner__user=request.user).first()
# reaction.delete()
# redirect_path = request.GET['next']
# return redirect(redirect_path)
#
# class LinkCommentView:
# @staticmethod
# @login_required
# def comment(request, post_id):
# if request.method == 'POST':
# form = CommentForm(request.POST)
# if form.is_valid():
# comment = form.save(commit=False)
# comment.post = Post.objects.get(id=post_id)
# comment.owner = Account.get_by_user(request.user)
# comment.save()
# Notification.add(comment.post.owner, comment.owner,
# NotificationType.COMMENT, comment.post)
# redirect_path = request.GET['next']
# return redirect(redirect_path)
which might include code, classes, or functions. Output only the next line. | ] |
Next line prediction: <|code_start|>
class NotificationView:
@staticmethod
@login_required
def list(request):
owner = request.user.accounts.first()
notifications = Notification.objects.filter(owner=owner).order_by('-created_at')
Notification.check_as_viewed(owner)
notify_count = 0
return render(request, 'notification/list.html', {'notifications': notifications,
<|code_end|>
. Use current file imports:
(from django.shortcuts import render
from django.contrib.auth.decorators import login_required
from notification.models import Notification)
and context including class names, function names, or small code snippets from other files:
# Path: notification/models.py
# class Notification(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='notifications')
# sender = models.ForeignKey(to='account.Account', related_name='sent_notifications')
# post = models.ForeignKey(to='link.Post', null=True)
# type = models.CharField(max_length=50)
# viewed = models.BooleanField(default=False)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @staticmethod
# def check_as_viewed(owner):
# Notification.objects.filter(owner=owner).update(viewed=True)
#
# @staticmethod
# def add(owner, sender, type, post=None):
# notify = Notification(owner=owner, sender=sender, type=type.value, post=post)
# notify.save()
. Output only the next line. | 'notify_count': notify_count}) |
Given the following code snippet before the placeholder: <|code_start|>
class PostFactory(factory.DjangoModelFactory):
class Meta:
model = Post
owner = factory.SubFactory(AccountFactory)
publisher = factory.SubFactory(AccountFactory)
url = 'http://test.tst'
type = 'html'
<|code_end|>
, predict the next line using imports from the current file:
import factory
from account.factories import AccountFactory
from link.models import Post, Comment, Reaction
and context including class names, function names, and sometimes code from other files:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# Path: link/models.py
# class Post(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='own_posts')
# publisher = models.ForeignKey(to='account.Account', related_name='posts')
# origin = models.ForeignKey(to='link.Post', related_name='adds', null=True)
# url = models.URLField()
# type = models.CharField(max_length=200)
# title = models.CharField(max_length=200)
# summary = models.CharField(null=True, max_length=250)
# text = models.TextField(null=True)
# image_url = models.CharField(null=True, max_length=500)
# tags = models.CharField(null=True, max_length=500)
# publish_date = models.DateTimeField(null=True)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def set_metadata(self):
# page_info = utils.get_page_info(self.url)
# self.type = page_info['type']
# self.title = page_info['title']
# self.summary = page_info['summary']
# self.text = page_info['text']
# self.image_url = page_info['image']
# self.tags = ','.join(page_info['tags'])
# self.publish_date = page_info['publish_date']
#
# def get_tags_as_list(self):
# return self.tags.split(',')
#
# def add_link(self, user):
# new_post = copy.copy(self)
# new_post.owner = user
# new_post.origin = self
# new_post.id = None
# new_post.save()
#
# @staticmethod
# def feeds(username):
# follower_ids = Relationship.objects.filter(
# owner__user__username=username).values_list('follow_id', flat=True).distinct()
# qs_reacted = Reaction.objects.filter(post=models.OuterRef('pk'),
# owner__user__username=username)
# qs_added = Post.objects.filter(origin=models.OuterRef('pk'),
# owner__user__username=username)
#
# return Post.objects.filter(
# models.Q(owner_id__in=follower_ids) |
# models.Q(owner__user__username=username)).annotate(
# is_reacted=models.Exists(queryset=qs_reacted)).annotate(
# is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
#
# @staticmethod
# def links_by_user(username, user=None):
# qs_reactions = Reaction.objects.filter(post=models.OuterRef('pk'), owner=user)
# qs_added = Post.objects.filter(origin=models.OuterRef('pk'), owner=user)
#
# return Post.objects.filter(owner__user__username=username).annotate(
# is_reacted=models.Exists(queryset=qs_reactions)).annotate(
# is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
#
# def __str__(self):
# return self.title
#
# class Comment(models.Model):
# owner = models.ForeignKey(to='account.Account')
# post = models.ForeignKey(to='link.Post', related_name='comments')
# text = models.CharField(max_length=1000)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def __str__(self):
# return self.text
#
# class Reaction(models.Model):
# owner = models.ForeignKey(to='account.Account')
# post = models.ForeignKey(to='link.Post', related_name='reactions')
# type = models.CharField(max_length=50, default='LIKE')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def __str__(self):
# return self.owner.user.first_name + ' ' + self.owner.user.last_name
. Output only the next line. | title = factory.sequence(lambda n: 'Title Link Test {}'.format(n)) |
Given the code snippet: <|code_start|>
class PostFactory(factory.DjangoModelFactory):
class Meta:
model = Post
owner = factory.SubFactory(AccountFactory)
publisher = factory.SubFactory(AccountFactory)
url = 'http://test.tst'
type = 'html'
title = factory.sequence(lambda n: 'Title Link Test {}'.format(n))
summary = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
text = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
image_url = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
class CommentFactory(factory.DjangoModelFactory):
class Meta:
model = Comment
owner = factory.SubFactory(AccountFactory)
post = factory.SubFactory(PostFactory)
class ReactionFactory(factory.DjangoModelFactory):
class Meta:
model = Reaction
owner = factory.SubFactory(AccountFactory)
<|code_end|>
, generate the next line using the imports in this file:
import factory
from account.factories import AccountFactory
from link.models import Post, Comment, Reaction
and context (functions, classes, or occasionally code) from other files:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# Path: link/models.py
# class Post(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='own_posts')
# publisher = models.ForeignKey(to='account.Account', related_name='posts')
# origin = models.ForeignKey(to='link.Post', related_name='adds', null=True)
# url = models.URLField()
# type = models.CharField(max_length=200)
# title = models.CharField(max_length=200)
# summary = models.CharField(null=True, max_length=250)
# text = models.TextField(null=True)
# image_url = models.CharField(null=True, max_length=500)
# tags = models.CharField(null=True, max_length=500)
# publish_date = models.DateTimeField(null=True)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def set_metadata(self):
# page_info = utils.get_page_info(self.url)
# self.type = page_info['type']
# self.title = page_info['title']
# self.summary = page_info['summary']
# self.text = page_info['text']
# self.image_url = page_info['image']
# self.tags = ','.join(page_info['tags'])
# self.publish_date = page_info['publish_date']
#
# def get_tags_as_list(self):
# return self.tags.split(',')
#
# def add_link(self, user):
# new_post = copy.copy(self)
# new_post.owner = user
# new_post.origin = self
# new_post.id = None
# new_post.save()
#
# @staticmethod
# def feeds(username):
# follower_ids = Relationship.objects.filter(
# owner__user__username=username).values_list('follow_id', flat=True).distinct()
# qs_reacted = Reaction.objects.filter(post=models.OuterRef('pk'),
# owner__user__username=username)
# qs_added = Post.objects.filter(origin=models.OuterRef('pk'),
# owner__user__username=username)
#
# return Post.objects.filter(
# models.Q(owner_id__in=follower_ids) |
# models.Q(owner__user__username=username)).annotate(
# is_reacted=models.Exists(queryset=qs_reacted)).annotate(
# is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
#
# @staticmethod
# def links_by_user(username, user=None):
# qs_reactions = Reaction.objects.filter(post=models.OuterRef('pk'), owner=user)
# qs_added = Post.objects.filter(origin=models.OuterRef('pk'), owner=user)
#
# return Post.objects.filter(owner__user__username=username).annotate(
# is_reacted=models.Exists(queryset=qs_reactions)).annotate(
# is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
#
# def __str__(self):
# return self.title
#
# class Comment(models.Model):
# owner = models.ForeignKey(to='account.Account')
# post = models.ForeignKey(to='link.Post', related_name='comments')
# text = models.CharField(max_length=1000)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def __str__(self):
# return self.text
#
# class Reaction(models.Model):
# owner = models.ForeignKey(to='account.Account')
# post = models.ForeignKey(to='link.Post', related_name='reactions')
# type = models.CharField(max_length=50, default='LIKE')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def __str__(self):
# return self.owner.user.first_name + ' ' + self.owner.user.last_name
. Output only the next line. | post = factory.SubFactory(PostFactory) |
Predict the next line for this snippet: <|code_start|>
class PostFactory(factory.DjangoModelFactory):
class Meta:
model = Post
owner = factory.SubFactory(AccountFactory)
publisher = factory.SubFactory(AccountFactory)
url = 'http://test.tst'
type = 'html'
title = factory.sequence(lambda n: 'Title Link Test {}'.format(n))
summary = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
text = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
<|code_end|>
with the help of current file imports:
import factory
from account.factories import AccountFactory
from link.models import Post, Comment, Reaction
and context from other files:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# Path: link/models.py
# class Post(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='own_posts')
# publisher = models.ForeignKey(to='account.Account', related_name='posts')
# origin = models.ForeignKey(to='link.Post', related_name='adds', null=True)
# url = models.URLField()
# type = models.CharField(max_length=200)
# title = models.CharField(max_length=200)
# summary = models.CharField(null=True, max_length=250)
# text = models.TextField(null=True)
# image_url = models.CharField(null=True, max_length=500)
# tags = models.CharField(null=True, max_length=500)
# publish_date = models.DateTimeField(null=True)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def set_metadata(self):
# page_info = utils.get_page_info(self.url)
# self.type = page_info['type']
# self.title = page_info['title']
# self.summary = page_info['summary']
# self.text = page_info['text']
# self.image_url = page_info['image']
# self.tags = ','.join(page_info['tags'])
# self.publish_date = page_info['publish_date']
#
# def get_tags_as_list(self):
# return self.tags.split(',')
#
# def add_link(self, user):
# new_post = copy.copy(self)
# new_post.owner = user
# new_post.origin = self
# new_post.id = None
# new_post.save()
#
# @staticmethod
# def feeds(username):
# follower_ids = Relationship.objects.filter(
# owner__user__username=username).values_list('follow_id', flat=True).distinct()
# qs_reacted = Reaction.objects.filter(post=models.OuterRef('pk'),
# owner__user__username=username)
# qs_added = Post.objects.filter(origin=models.OuterRef('pk'),
# owner__user__username=username)
#
# return Post.objects.filter(
# models.Q(owner_id__in=follower_ids) |
# models.Q(owner__user__username=username)).annotate(
# is_reacted=models.Exists(queryset=qs_reacted)).annotate(
# is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
#
# @staticmethod
# def links_by_user(username, user=None):
# qs_reactions = Reaction.objects.filter(post=models.OuterRef('pk'), owner=user)
# qs_added = Post.objects.filter(origin=models.OuterRef('pk'), owner=user)
#
# return Post.objects.filter(owner__user__username=username).annotate(
# is_reacted=models.Exists(queryset=qs_reactions)).annotate(
# is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
#
# def __str__(self):
# return self.title
#
# class Comment(models.Model):
# owner = models.ForeignKey(to='account.Account')
# post = models.ForeignKey(to='link.Post', related_name='comments')
# text = models.CharField(max_length=1000)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def __str__(self):
# return self.text
#
# class Reaction(models.Model):
# owner = models.ForeignKey(to='account.Account')
# post = models.ForeignKey(to='link.Post', related_name='reactions')
# type = models.CharField(max_length=50, default='LIKE')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def __str__(self):
# return self.owner.user.first_name + ' ' + self.owner.user.last_name
, which may contain function names, class names, or code. Output only the next line. | image_url = factory.sequence(lambda n: 'Summary Link Test {}'.format(n)) |
Continue the code snippet: <|code_start|>
class PostFactory(factory.DjangoModelFactory):
class Meta:
model = Post
owner = factory.SubFactory(AccountFactory)
publisher = factory.SubFactory(AccountFactory)
url = 'http://test.tst'
type = 'html'
title = factory.sequence(lambda n: 'Title Link Test {}'.format(n))
<|code_end|>
. Use current file imports:
import factory
from account.factories import AccountFactory
from link.models import Post, Comment, Reaction
and context (classes, functions, or code) from other files:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# Path: link/models.py
# class Post(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='own_posts')
# publisher = models.ForeignKey(to='account.Account', related_name='posts')
# origin = models.ForeignKey(to='link.Post', related_name='adds', null=True)
# url = models.URLField()
# type = models.CharField(max_length=200)
# title = models.CharField(max_length=200)
# summary = models.CharField(null=True, max_length=250)
# text = models.TextField(null=True)
# image_url = models.CharField(null=True, max_length=500)
# tags = models.CharField(null=True, max_length=500)
# publish_date = models.DateTimeField(null=True)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def set_metadata(self):
# page_info = utils.get_page_info(self.url)
# self.type = page_info['type']
# self.title = page_info['title']
# self.summary = page_info['summary']
# self.text = page_info['text']
# self.image_url = page_info['image']
# self.tags = ','.join(page_info['tags'])
# self.publish_date = page_info['publish_date']
#
# def get_tags_as_list(self):
# return self.tags.split(',')
#
# def add_link(self, user):
# new_post = copy.copy(self)
# new_post.owner = user
# new_post.origin = self
# new_post.id = None
# new_post.save()
#
# @staticmethod
# def feeds(username):
# follower_ids = Relationship.objects.filter(
# owner__user__username=username).values_list('follow_id', flat=True).distinct()
# qs_reacted = Reaction.objects.filter(post=models.OuterRef('pk'),
# owner__user__username=username)
# qs_added = Post.objects.filter(origin=models.OuterRef('pk'),
# owner__user__username=username)
#
# return Post.objects.filter(
# models.Q(owner_id__in=follower_ids) |
# models.Q(owner__user__username=username)).annotate(
# is_reacted=models.Exists(queryset=qs_reacted)).annotate(
# is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
#
# @staticmethod
# def links_by_user(username, user=None):
# qs_reactions = Reaction.objects.filter(post=models.OuterRef('pk'), owner=user)
# qs_added = Post.objects.filter(origin=models.OuterRef('pk'), owner=user)
#
# return Post.objects.filter(owner__user__username=username).annotate(
# is_reacted=models.Exists(queryset=qs_reactions)).annotate(
# is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
#
# def __str__(self):
# return self.title
#
# class Comment(models.Model):
# owner = models.ForeignKey(to='account.Account')
# post = models.ForeignKey(to='link.Post', related_name='comments')
# text = models.CharField(max_length=1000)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def __str__(self):
# return self.text
#
# class Reaction(models.Model):
# owner = models.ForeignKey(to='account.Account')
# post = models.ForeignKey(to='link.Post', related_name='reactions')
# type = models.CharField(max_length=50, default='LIKE')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def __str__(self):
# return self.owner.user.first_name + ' ' + self.owner.user.last_name
. Output only the next line. | summary = factory.sequence(lambda n: 'Summary Link Test {}'.format(n)) |
Predict the next line for this snippet: <|code_start|>
class TestAccount(TestCase):
def setUp(self):
new_user = AccountFactory.build().user
self.account = AccountFactory.create()
self.user = self.account.user
<|code_end|>
with the help of current file imports:
from unittest.mock import patch, MagicMock
from django.test import TestCase
from django.core.urlresolvers import reverse
from django.core.files.uploadedfile import SimpleUploadedFile
from account.factories import AccountFactory, RelationshipFactory, DEFAULT_PASSWORD
and context from other files:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# class RelationshipFactory(factory.DjangoModelFactory):
# class Meta:
# model = Relationship
#
# owner = factory.SubFactory(AccountFactory)
# follow = factory.SubFactory(AccountFactory)
#
# DEFAULT_PASSWORD = 'abc@123'
, which may contain function names, class names, or code. Output only the next line. | self.form_login = { |
Predict the next line after this snippet: <|code_start|> def test_settings_update_password(self):
settings_info = {'first_name': self.user.first_name, 'last_name': self.user.last_name,
'password': 'new', 'confirm_password': 'new'}
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.post(reverse('account_settings'), data=settings_info)
self.assertEqual(response.status_code, 200)
self.assertTrue(response.context['form'].is_valid())
def test_settings_update_password_fails_confirmation(self):
settings_info = {'first_name': self.user.first_name, 'last_name': self.user.last_name,
'password': 'new', 'confirm_password': 'old'}
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.post(reverse('account_settings'), data=settings_info)
self.assertFormError(response, 'form', None,
'Password confirmation does not equal with password.')
@patch('account.views.FileSystemStorage')
@patch('account.models.FileSystemStorage')
def test_settings_new_upload_image(self, mock_views_fs, mock_models_fs):
mock_views_fs.return_value.exists = MagicMock(return_value=False)
mock_models_fs.return_value.exists = MagicMock(return_value=False)
file = SimpleUploadedFile('image.jpg', content=None, content_type='image/jpg')
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.post(reverse('account_settings_upload'), data={'user_avatar': file})
self.assertRedirects(response, reverse('account_settings'))
@patch('account.views.FileSystemStorage')
@patch('account.models.FileSystemStorage')
def test_settings_change_upload_image(self, mock_views_fs, mock_models_fs):
<|code_end|>
using the current file's imports:
from unittest.mock import patch, MagicMock
from django.test import TestCase
from django.core.urlresolvers import reverse
from django.core.files.uploadedfile import SimpleUploadedFile
from account.factories import AccountFactory, RelationshipFactory, DEFAULT_PASSWORD
and any relevant context from other files:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# class RelationshipFactory(factory.DjangoModelFactory):
# class Meta:
# model = Relationship
#
# owner = factory.SubFactory(AccountFactory)
# follow = factory.SubFactory(AccountFactory)
#
# DEFAULT_PASSWORD = 'abc@123'
. Output only the next line. | mock_views_fs.return_value.exists = MagicMock(return_value=True) |
Given snippet: <|code_start|> 'password': 'invalid',
}
response = self.client.post(reverse('account_login'), data=invalid_login)
self.assertFormError(response, 'form', None, errors=None)
def test_login_fails_identity_and_password_empty(self):
response = self.client.post(reverse('account_login'), data={})
self.assertFormError(response, 'form', 'identity', 'This field is required.')
self.assertFormError(response, 'form', 'password', 'This field is required.')
def test_signup_with_success(self):
response = self.client.post(reverse('account_signup'), data=self.form_user)
self.assertEqual(response.status_code, 200)
self.assertTrue(response.context['formSignUp'].is_valid())
def test_signup_fails_username_with_special_character(self):
username_special_char = self.form_user['username'] + '/'
self.form_user['username'] = username_special_char
response = self.client.post(reverse('account_signup'), data=self.form_user)
self.assertFormError(response, 'formSignUp', 'username',
'Username does not allow special characters.')
def test_signup_fails_with_empty_form(self):
response = self.client.post(reverse('account_signup'), data={})
self.assertFormError(response, 'formSignUp', 'email', 'This field is required.')
self.assertFormError(response, 'formSignUp', 'password', 'This field is required.')
self.assertFormError(response, 'formSignUp', 'username', 'This field is required.')
self.assertFormError(response, 'formSignUp', 'first_name', 'This field is required.')
self.assertFormError(response, 'formSignUp', 'last_name', 'This field is required.')
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from unittest.mock import patch, MagicMock
from django.test import TestCase
from django.core.urlresolvers import reverse
from django.core.files.uploadedfile import SimpleUploadedFile
from account.factories import AccountFactory, RelationshipFactory, DEFAULT_PASSWORD
and context:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# class RelationshipFactory(factory.DjangoModelFactory):
# class Meta:
# model = Relationship
#
# owner = factory.SubFactory(AccountFactory)
# follow = factory.SubFactory(AccountFactory)
#
# DEFAULT_PASSWORD = 'abc@123'
which might include code, classes, or functions. Output only the next line. | def test_access_profile_anonymous(self): |
Given the code snippet: <|code_start|>
class Search:
def __init__(self, query, owner=None):
self.owner = owner
self.adv_separator = ':'
self.results = []
self.query_value = query
self.words = query.lower().split(' ')
def process(self):
if self.is_advanced():
self.advanced()
else:
self.query_level(self.filter_links(), self.filter_users())
def is_advanced(self):
return self.adv_separator in self.words[0]
def advanced(self):
attr, word = self.words.pop(0).split(self.adv_separator)
if word:
self.words = [word] + self.words
if attr == 'user':
self.query_level(q_filter_user=self.filter_users())
elif attr == 'title':
self.query_level(q_filter_link=self.filter_links_by_title())
elif attr == 'tag':
self.query_level(q_filter_link=self.filter_links_by_tag())
else:
<|code_end|>
, generate the next line using the imports in this file:
from django.db.models import Q, Value, CharField
from account.models import Account
from link.models import Post
and context (functions, classes, or occasionally code) from other files:
# Path: account/models.py
# class Account(models.Model):
# user = models.ForeignKey(to='auth.User', related_name='accounts')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @property
# def user_avatar(self):
# fs = FileSystemStorage()
# if fs.exists(self.user.username + '.jpg'):
# return '/static/avatar/' + self.user.username + '.jpg'
# else:
# return '/static/img/profile/default.jpg'
#
# def is_following(self, follow):
# return self.following.filter(follow=follow).exists()
#
# def unfollow(self, follow):
# relationship = self.following.filter(follow=follow).first()
# relationship.delete()
#
# @staticmethod
# def get_by_user(user):
# return Account.objects.filter(user=user).first()
#
# @staticmethod
# def get_by_username(username):
# return Account.objects.filter(user__username=username).first()
#
# Path: link/models.py
# class Post(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='own_posts')
# publisher = models.ForeignKey(to='account.Account', related_name='posts')
# origin = models.ForeignKey(to='link.Post', related_name='adds', null=True)
# url = models.URLField()
# type = models.CharField(max_length=200)
# title = models.CharField(max_length=200)
# summary = models.CharField(null=True, max_length=250)
# text = models.TextField(null=True)
# image_url = models.CharField(null=True, max_length=500)
# tags = models.CharField(null=True, max_length=500)
# publish_date = models.DateTimeField(null=True)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def set_metadata(self):
# page_info = utils.get_page_info(self.url)
# self.type = page_info['type']
# self.title = page_info['title']
# self.summary = page_info['summary']
# self.text = page_info['text']
# self.image_url = page_info['image']
# self.tags = ','.join(page_info['tags'])
# self.publish_date = page_info['publish_date']
#
# def get_tags_as_list(self):
# return self.tags.split(',')
#
# def add_link(self, user):
# new_post = copy.copy(self)
# new_post.owner = user
# new_post.origin = self
# new_post.id = None
# new_post.save()
#
# @staticmethod
# def feeds(username):
# follower_ids = Relationship.objects.filter(
# owner__user__username=username).values_list('follow_id', flat=True).distinct()
# qs_reacted = Reaction.objects.filter(post=models.OuterRef('pk'),
# owner__user__username=username)
# qs_added = Post.objects.filter(origin=models.OuterRef('pk'),
# owner__user__username=username)
#
# return Post.objects.filter(
# models.Q(owner_id__in=follower_ids) |
# models.Q(owner__user__username=username)).annotate(
# is_reacted=models.Exists(queryset=qs_reacted)).annotate(
# is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
#
# @staticmethod
# def links_by_user(username, user=None):
# qs_reactions = Reaction.objects.filter(post=models.OuterRef('pk'), owner=user)
# qs_added = Post.objects.filter(origin=models.OuterRef('pk'), owner=user)
#
# return Post.objects.filter(owner__user__username=username).annotate(
# is_reacted=models.Exists(queryset=qs_reactions)).annotate(
# is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
#
# def __str__(self):
# return self.title
. Output only the next line. | raise SearchException('Attr not supported! try: user, title or tag') |
Predict the next line after this snippet: <|code_start|>
class Search:
def __init__(self, query, owner=None):
self.owner = owner
self.adv_separator = ':'
self.results = []
self.query_value = query
self.words = query.lower().split(' ')
def process(self):
if self.is_advanced():
self.advanced()
else:
self.query_level(self.filter_links(), self.filter_users())
def is_advanced(self):
return self.adv_separator in self.words[0]
def advanced(self):
<|code_end|>
using the current file's imports:
from django.db.models import Q, Value, CharField
from account.models import Account
from link.models import Post
and any relevant context from other files:
# Path: account/models.py
# class Account(models.Model):
# user = models.ForeignKey(to='auth.User', related_name='accounts')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @property
# def user_avatar(self):
# fs = FileSystemStorage()
# if fs.exists(self.user.username + '.jpg'):
# return '/static/avatar/' + self.user.username + '.jpg'
# else:
# return '/static/img/profile/default.jpg'
#
# def is_following(self, follow):
# return self.following.filter(follow=follow).exists()
#
# def unfollow(self, follow):
# relationship = self.following.filter(follow=follow).first()
# relationship.delete()
#
# @staticmethod
# def get_by_user(user):
# return Account.objects.filter(user=user).first()
#
# @staticmethod
# def get_by_username(username):
# return Account.objects.filter(user__username=username).first()
#
# Path: link/models.py
# class Post(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='own_posts')
# publisher = models.ForeignKey(to='account.Account', related_name='posts')
# origin = models.ForeignKey(to='link.Post', related_name='adds', null=True)
# url = models.URLField()
# type = models.CharField(max_length=200)
# title = models.CharField(max_length=200)
# summary = models.CharField(null=True, max_length=250)
# text = models.TextField(null=True)
# image_url = models.CharField(null=True, max_length=500)
# tags = models.CharField(null=True, max_length=500)
# publish_date = models.DateTimeField(null=True)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def set_metadata(self):
# page_info = utils.get_page_info(self.url)
# self.type = page_info['type']
# self.title = page_info['title']
# self.summary = page_info['summary']
# self.text = page_info['text']
# self.image_url = page_info['image']
# self.tags = ','.join(page_info['tags'])
# self.publish_date = page_info['publish_date']
#
# def get_tags_as_list(self):
# return self.tags.split(',')
#
# def add_link(self, user):
# new_post = copy.copy(self)
# new_post.owner = user
# new_post.origin = self
# new_post.id = None
# new_post.save()
#
# @staticmethod
# def feeds(username):
# follower_ids = Relationship.objects.filter(
# owner__user__username=username).values_list('follow_id', flat=True).distinct()
# qs_reacted = Reaction.objects.filter(post=models.OuterRef('pk'),
# owner__user__username=username)
# qs_added = Post.objects.filter(origin=models.OuterRef('pk'),
# owner__user__username=username)
#
# return Post.objects.filter(
# models.Q(owner_id__in=follower_ids) |
# models.Q(owner__user__username=username)).annotate(
# is_reacted=models.Exists(queryset=qs_reacted)).annotate(
# is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
#
# @staticmethod
# def links_by_user(username, user=None):
# qs_reactions = Reaction.objects.filter(post=models.OuterRef('pk'), owner=user)
# qs_added = Post.objects.filter(origin=models.OuterRef('pk'), owner=user)
#
# return Post.objects.filter(owner__user__username=username).annotate(
# is_reacted=models.Exists(queryset=qs_reactions)).annotate(
# is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
#
# def __str__(self):
# return self.title
. Output only the next line. | attr, word = self.words.pop(0).split(self.adv_separator) |
Here is a snippet: <|code_start|>
class AuthView:
@staticmethod
def signup(request):
form = None
if request.method == 'POST':
form = SignUpForm(request.POST)
if form.is_valid():
form_user = form.save(commit=False)
<|code_end|>
. Write the next line using the current file imports:
import os
from django.shortcuts import redirect, render, get_object_or_404
from django.urls import reverse
from django.contrib.auth import login, logout
from django.contrib.auth.models import User
from django.core.files.storage import FileSystemStorage
from django.contrib.auth.decorators import login_required
from account.forms import SignUpForm, LoginForm, SettingsForm
from account.models import Account, Relationship
from notification.models import Notification, NotificationType
and context from other files:
# Path: account/forms.py
# class SignUpForm(forms.ModelForm):
# class Meta:
# model = User
# fields = ('first_name', 'last_name', 'username', 'email', 'password',)
# User._meta.get_field('email')._unique = True
# User._meta.get_field('email').blank = False
# User._meta.get_field('email').null = False
# User._meta.get_field('first_name').blank = False
# User._meta.get_field('first_name').null = False
# User._meta.get_field('last_name').blank = False
# User._meta.get_field('last_name').null = False
#
# def clean_username(self):
# username = self.cleaned_data['username']
# if not re.match(r'^[A-Za-z0-9]+$', username):
# raise forms.ValidationError('Username does not allow special characters.')
# return username.lower()
#
# def clean_email(self):
# email = self.cleaned_data['email']
# return email.lower()
#
# class LoginForm(forms.Form):
# identity = forms.CharField(min_length=3, required=True)
# password = forms.CharField(min_length=3, required=True)
# keep_connected = forms.BooleanField(initial=False, required=False)
#
# class SettingsForm(forms.Form):
# first_name = forms.CharField(min_length=3, required=True)
# last_name = forms.CharField(min_length=3, required=True)
# password = forms.CharField(min_length=3, required=False)
# confirm_password = forms.CharField(min_length=3, required=False)
#
# def clean(self):
# cleaned_data = super(SettingsForm, self).clean()
# password = cleaned_data.get("password")
# confirm_password = cleaned_data.get("confirm_password")
# if password != confirm_password:
# raise forms.ValidationError('Password confirmation does not equal with password.',)
# return password
#
# Path: account/models.py
# class Account(models.Model):
# user = models.ForeignKey(to='auth.User', related_name='accounts')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @property
# def user_avatar(self):
# fs = FileSystemStorage()
# if fs.exists(self.user.username + '.jpg'):
# return '/static/avatar/' + self.user.username + '.jpg'
# else:
# return '/static/img/profile/default.jpg'
#
# def is_following(self, follow):
# return self.following.filter(follow=follow).exists()
#
# def unfollow(self, follow):
# relationship = self.following.filter(follow=follow).first()
# relationship.delete()
#
# @staticmethod
# def get_by_user(user):
# return Account.objects.filter(user=user).first()
#
# @staticmethod
# def get_by_username(username):
# return Account.objects.filter(user__username=username).first()
#
# class Relationship(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='following')
# follow = models.ForeignKey(to='account.Account', related_name='followers')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# class Meta:
# unique_together = ('owner', 'follow',)
#
# Path: notification/models.py
# class Notification(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='notifications')
# sender = models.ForeignKey(to='account.Account', related_name='sent_notifications')
# post = models.ForeignKey(to='link.Post', null=True)
# type = models.CharField(max_length=50)
# viewed = models.BooleanField(default=False)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @staticmethod
# def check_as_viewed(owner):
# Notification.objects.filter(owner=owner).update(viewed=True)
#
# @staticmethod
# def add(owner, sender, type, post=None):
# notify = Notification(owner=owner, sender=sender, type=type.value, post=post)
# notify.save()
#
# class NotificationType(Enum):
# ADD = 'ADD'
# REACT = 'LIKE'
# COMMENT = 'COMMENT'
# FOLLOW = 'FOLLOW'
, which may include functions, classes, or code. Output only the next line. | user = User.objects.create_user(username=form_user.username, email=form_user.email, |
Predict the next line for this snippet: <|code_start|> data = form.data
if '@' in data['identity']:
kwargs = {'email': data['identity'].lower()}
else:
kwargs = {'username': data['identity'].lower()}
try:
user = User.objects.get(**kwargs)
if user is not None and user.check_password(data['password']):
login(request, user)
if 'keep_connected' in data:
request.session.set_expiry(0)
next_page = request.GET.get('next', None)
redirect_path = reverse('home')
if next_page is not None and next_page != '':
redirect_path = next_page
user_account = Account.get_by_user(user=user)
request.session['user_avatar'] = user_account.user_avatar
request.session.save()
return redirect(redirect_path)
except User.DoesNotExist:
pass
return render(request, 'index.html', {'form': form})
@staticmethod
def home_redirect(request):
if request.user.is_authenticated():
return redirect(reverse('home'))
else:
return render(request, 'index.html')
<|code_end|>
with the help of current file imports:
import os
from django.shortcuts import redirect, render, get_object_or_404
from django.urls import reverse
from django.contrib.auth import login, logout
from django.contrib.auth.models import User
from django.core.files.storage import FileSystemStorage
from django.contrib.auth.decorators import login_required
from account.forms import SignUpForm, LoginForm, SettingsForm
from account.models import Account, Relationship
from notification.models import Notification, NotificationType
and context from other files:
# Path: account/forms.py
# class SignUpForm(forms.ModelForm):
# class Meta:
# model = User
# fields = ('first_name', 'last_name', 'username', 'email', 'password',)
# User._meta.get_field('email')._unique = True
# User._meta.get_field('email').blank = False
# User._meta.get_field('email').null = False
# User._meta.get_field('first_name').blank = False
# User._meta.get_field('first_name').null = False
# User._meta.get_field('last_name').blank = False
# User._meta.get_field('last_name').null = False
#
# def clean_username(self):
# username = self.cleaned_data['username']
# if not re.match(r'^[A-Za-z0-9]+$', username):
# raise forms.ValidationError('Username does not allow special characters.')
# return username.lower()
#
# def clean_email(self):
# email = self.cleaned_data['email']
# return email.lower()
#
# class LoginForm(forms.Form):
# identity = forms.CharField(min_length=3, required=True)
# password = forms.CharField(min_length=3, required=True)
# keep_connected = forms.BooleanField(initial=False, required=False)
#
# class SettingsForm(forms.Form):
# first_name = forms.CharField(min_length=3, required=True)
# last_name = forms.CharField(min_length=3, required=True)
# password = forms.CharField(min_length=3, required=False)
# confirm_password = forms.CharField(min_length=3, required=False)
#
# def clean(self):
# cleaned_data = super(SettingsForm, self).clean()
# password = cleaned_data.get("password")
# confirm_password = cleaned_data.get("confirm_password")
# if password != confirm_password:
# raise forms.ValidationError('Password confirmation does not equal with password.',)
# return password
#
# Path: account/models.py
# class Account(models.Model):
# user = models.ForeignKey(to='auth.User', related_name='accounts')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @property
# def user_avatar(self):
# fs = FileSystemStorage()
# if fs.exists(self.user.username + '.jpg'):
# return '/static/avatar/' + self.user.username + '.jpg'
# else:
# return '/static/img/profile/default.jpg'
#
# def is_following(self, follow):
# return self.following.filter(follow=follow).exists()
#
# def unfollow(self, follow):
# relationship = self.following.filter(follow=follow).first()
# relationship.delete()
#
# @staticmethod
# def get_by_user(user):
# return Account.objects.filter(user=user).first()
#
# @staticmethod
# def get_by_username(username):
# return Account.objects.filter(user__username=username).first()
#
# class Relationship(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='following')
# follow = models.ForeignKey(to='account.Account', related_name='followers')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# class Meta:
# unique_together = ('owner', 'follow',)
#
# Path: notification/models.py
# class Notification(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='notifications')
# sender = models.ForeignKey(to='account.Account', related_name='sent_notifications')
# post = models.ForeignKey(to='link.Post', null=True)
# type = models.CharField(max_length=50)
# viewed = models.BooleanField(default=False)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @staticmethod
# def check_as_viewed(owner):
# Notification.objects.filter(owner=owner).update(viewed=True)
#
# @staticmethod
# def add(owner, sender, type, post=None):
# notify = Notification(owner=owner, sender=sender, type=type.value, post=post)
# notify.save()
#
# class NotificationType(Enum):
# ADD = 'ADD'
# REACT = 'LIKE'
# COMMENT = 'COMMENT'
# FOLLOW = 'FOLLOW'
, which may contain function names, class names, or code. Output only the next line. | @staticmethod |
Given the code snippet: <|code_start|>
class AuthView:
@staticmethod
def signup(request):
<|code_end|>
, generate the next line using the imports in this file:
import os
from django.shortcuts import redirect, render, get_object_or_404
from django.urls import reverse
from django.contrib.auth import login, logout
from django.contrib.auth.models import User
from django.core.files.storage import FileSystemStorage
from django.contrib.auth.decorators import login_required
from account.forms import SignUpForm, LoginForm, SettingsForm
from account.models import Account, Relationship
from notification.models import Notification, NotificationType
and context (functions, classes, or occasionally code) from other files:
# Path: account/forms.py
# class SignUpForm(forms.ModelForm):
# class Meta:
# model = User
# fields = ('first_name', 'last_name', 'username', 'email', 'password',)
# User._meta.get_field('email')._unique = True
# User._meta.get_field('email').blank = False
# User._meta.get_field('email').null = False
# User._meta.get_field('first_name').blank = False
# User._meta.get_field('first_name').null = False
# User._meta.get_field('last_name').blank = False
# User._meta.get_field('last_name').null = False
#
# def clean_username(self):
# username = self.cleaned_data['username']
# if not re.match(r'^[A-Za-z0-9]+$', username):
# raise forms.ValidationError('Username does not allow special characters.')
# return username.lower()
#
# def clean_email(self):
# email = self.cleaned_data['email']
# return email.lower()
#
# class LoginForm(forms.Form):
# identity = forms.CharField(min_length=3, required=True)
# password = forms.CharField(min_length=3, required=True)
# keep_connected = forms.BooleanField(initial=False, required=False)
#
# class SettingsForm(forms.Form):
# first_name = forms.CharField(min_length=3, required=True)
# last_name = forms.CharField(min_length=3, required=True)
# password = forms.CharField(min_length=3, required=False)
# confirm_password = forms.CharField(min_length=3, required=False)
#
# def clean(self):
# cleaned_data = super(SettingsForm, self).clean()
# password = cleaned_data.get("password")
# confirm_password = cleaned_data.get("confirm_password")
# if password != confirm_password:
# raise forms.ValidationError('Password confirmation does not equal with password.',)
# return password
#
# Path: account/models.py
# class Account(models.Model):
# user = models.ForeignKey(to='auth.User', related_name='accounts')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @property
# def user_avatar(self):
# fs = FileSystemStorage()
# if fs.exists(self.user.username + '.jpg'):
# return '/static/avatar/' + self.user.username + '.jpg'
# else:
# return '/static/img/profile/default.jpg'
#
# def is_following(self, follow):
# return self.following.filter(follow=follow).exists()
#
# def unfollow(self, follow):
# relationship = self.following.filter(follow=follow).first()
# relationship.delete()
#
# @staticmethod
# def get_by_user(user):
# return Account.objects.filter(user=user).first()
#
# @staticmethod
# def get_by_username(username):
# return Account.objects.filter(user__username=username).first()
#
# class Relationship(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='following')
# follow = models.ForeignKey(to='account.Account', related_name='followers')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# class Meta:
# unique_together = ('owner', 'follow',)
#
# Path: notification/models.py
# class Notification(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='notifications')
# sender = models.ForeignKey(to='account.Account', related_name='sent_notifications')
# post = models.ForeignKey(to='link.Post', null=True)
# type = models.CharField(max_length=50)
# viewed = models.BooleanField(default=False)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @staticmethod
# def check_as_viewed(owner):
# Notification.objects.filter(owner=owner).update(viewed=True)
#
# @staticmethod
# def add(owner, sender, type, post=None):
# notify = Notification(owner=owner, sender=sender, type=type.value, post=post)
# notify.save()
#
# class NotificationType(Enum):
# ADD = 'ADD'
# REACT = 'LIKE'
# COMMENT = 'COMMENT'
# FOLLOW = 'FOLLOW'
. Output only the next line. | form = None |
Based on the snippet: <|code_start|> user_account = Account.get_by_user(user=user)
request.session['user_avatar'] = user_account.user_avatar
request.session.save()
return redirect(redirect_path)
except User.DoesNotExist:
pass
return render(request, 'index.html', {'form': form})
@staticmethod
def home_redirect(request):
if request.user.is_authenticated():
return redirect(reverse('home'))
else:
return render(request, 'index.html')
@staticmethod
@login_required
def logout_redirect(request):
logout(request)
return redirect(reverse('index'))
class ProfileView:
@staticmethod
def following(request, username):
notify_count = None
profile = get_object_or_404(User, username=username)
accounts = Account.objects.filter(followers__owner__user__username=username)
profile_account = Account.get_by_user(user=profile)
profile.user_avatar = profile_account.user_avatar
<|code_end|>
, predict the immediate next line with the help of imports:
import os
from django.shortcuts import redirect, render, get_object_or_404
from django.urls import reverse
from django.contrib.auth import login, logout
from django.contrib.auth.models import User
from django.core.files.storage import FileSystemStorage
from django.contrib.auth.decorators import login_required
from account.forms import SignUpForm, LoginForm, SettingsForm
from account.models import Account, Relationship
from notification.models import Notification, NotificationType
and context (classes, functions, sometimes code) from other files:
# Path: account/forms.py
# class SignUpForm(forms.ModelForm):
# class Meta:
# model = User
# fields = ('first_name', 'last_name', 'username', 'email', 'password',)
# User._meta.get_field('email')._unique = True
# User._meta.get_field('email').blank = False
# User._meta.get_field('email').null = False
# User._meta.get_field('first_name').blank = False
# User._meta.get_field('first_name').null = False
# User._meta.get_field('last_name').blank = False
# User._meta.get_field('last_name').null = False
#
# def clean_username(self):
# username = self.cleaned_data['username']
# if not re.match(r'^[A-Za-z0-9]+$', username):
# raise forms.ValidationError('Username does not allow special characters.')
# return username.lower()
#
# def clean_email(self):
# email = self.cleaned_data['email']
# return email.lower()
#
# class LoginForm(forms.Form):
# identity = forms.CharField(min_length=3, required=True)
# password = forms.CharField(min_length=3, required=True)
# keep_connected = forms.BooleanField(initial=False, required=False)
#
# class SettingsForm(forms.Form):
# first_name = forms.CharField(min_length=3, required=True)
# last_name = forms.CharField(min_length=3, required=True)
# password = forms.CharField(min_length=3, required=False)
# confirm_password = forms.CharField(min_length=3, required=False)
#
# def clean(self):
# cleaned_data = super(SettingsForm, self).clean()
# password = cleaned_data.get("password")
# confirm_password = cleaned_data.get("confirm_password")
# if password != confirm_password:
# raise forms.ValidationError('Password confirmation does not equal with password.',)
# return password
#
# Path: account/models.py
# class Account(models.Model):
# user = models.ForeignKey(to='auth.User', related_name='accounts')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @property
# def user_avatar(self):
# fs = FileSystemStorage()
# if fs.exists(self.user.username + '.jpg'):
# return '/static/avatar/' + self.user.username + '.jpg'
# else:
# return '/static/img/profile/default.jpg'
#
# def is_following(self, follow):
# return self.following.filter(follow=follow).exists()
#
# def unfollow(self, follow):
# relationship = self.following.filter(follow=follow).first()
# relationship.delete()
#
# @staticmethod
# def get_by_user(user):
# return Account.objects.filter(user=user).first()
#
# @staticmethod
# def get_by_username(username):
# return Account.objects.filter(user__username=username).first()
#
# class Relationship(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='following')
# follow = models.ForeignKey(to='account.Account', related_name='followers')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# class Meta:
# unique_together = ('owner', 'follow',)
#
# Path: notification/models.py
# class Notification(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='notifications')
# sender = models.ForeignKey(to='account.Account', related_name='sent_notifications')
# post = models.ForeignKey(to='link.Post', null=True)
# type = models.CharField(max_length=50)
# viewed = models.BooleanField(default=False)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @staticmethod
# def check_as_viewed(owner):
# Notification.objects.filter(owner=owner).update(viewed=True)
#
# @staticmethod
# def add(owner, sender, type, post=None):
# notify = Notification(owner=owner, sender=sender, type=type.value, post=post)
# notify.save()
#
# class NotificationType(Enum):
# ADD = 'ADD'
# REACT = 'LIKE'
# COMMENT = 'COMMENT'
# FOLLOW = 'FOLLOW'
. Output only the next line. | if request.user.is_authenticated: |
Predict the next line after this snippet: <|code_start|> user.first_name = form_user.first_name
user.last_name = form_user.last_name
user.save()
account = Account(user=user)
account.save()
return render(request, 'index.html', {'formSignUp': form})
@staticmethod
def login(request):
form = None
if request.method == 'POST':
form = LoginForm(request.POST)
if form.is_valid():
data = form.data
if '@' in data['identity']:
kwargs = {'email': data['identity'].lower()}
else:
kwargs = {'username': data['identity'].lower()}
try:
user = User.objects.get(**kwargs)
if user is not None and user.check_password(data['password']):
login(request, user)
if 'keep_connected' in data:
request.session.set_expiry(0)
next_page = request.GET.get('next', None)
redirect_path = reverse('home')
if next_page is not None and next_page != '':
redirect_path = next_page
user_account = Account.get_by_user(user=user)
request.session['user_avatar'] = user_account.user_avatar
<|code_end|>
using the current file's imports:
import os
from django.shortcuts import redirect, render, get_object_or_404
from django.urls import reverse
from django.contrib.auth import login, logout
from django.contrib.auth.models import User
from django.core.files.storage import FileSystemStorage
from django.contrib.auth.decorators import login_required
from account.forms import SignUpForm, LoginForm, SettingsForm
from account.models import Account, Relationship
from notification.models import Notification, NotificationType
and any relevant context from other files:
# Path: account/forms.py
# class SignUpForm(forms.ModelForm):
# class Meta:
# model = User
# fields = ('first_name', 'last_name', 'username', 'email', 'password',)
# User._meta.get_field('email')._unique = True
# User._meta.get_field('email').blank = False
# User._meta.get_field('email').null = False
# User._meta.get_field('first_name').blank = False
# User._meta.get_field('first_name').null = False
# User._meta.get_field('last_name').blank = False
# User._meta.get_field('last_name').null = False
#
# def clean_username(self):
# username = self.cleaned_data['username']
# if not re.match(r'^[A-Za-z0-9]+$', username):
# raise forms.ValidationError('Username does not allow special characters.')
# return username.lower()
#
# def clean_email(self):
# email = self.cleaned_data['email']
# return email.lower()
#
# class LoginForm(forms.Form):
# identity = forms.CharField(min_length=3, required=True)
# password = forms.CharField(min_length=3, required=True)
# keep_connected = forms.BooleanField(initial=False, required=False)
#
# class SettingsForm(forms.Form):
# first_name = forms.CharField(min_length=3, required=True)
# last_name = forms.CharField(min_length=3, required=True)
# password = forms.CharField(min_length=3, required=False)
# confirm_password = forms.CharField(min_length=3, required=False)
#
# def clean(self):
# cleaned_data = super(SettingsForm, self).clean()
# password = cleaned_data.get("password")
# confirm_password = cleaned_data.get("confirm_password")
# if password != confirm_password:
# raise forms.ValidationError('Password confirmation does not equal with password.',)
# return password
#
# Path: account/models.py
# class Account(models.Model):
# user = models.ForeignKey(to='auth.User', related_name='accounts')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @property
# def user_avatar(self):
# fs = FileSystemStorage()
# if fs.exists(self.user.username + '.jpg'):
# return '/static/avatar/' + self.user.username + '.jpg'
# else:
# return '/static/img/profile/default.jpg'
#
# def is_following(self, follow):
# return self.following.filter(follow=follow).exists()
#
# def unfollow(self, follow):
# relationship = self.following.filter(follow=follow).first()
# relationship.delete()
#
# @staticmethod
# def get_by_user(user):
# return Account.objects.filter(user=user).first()
#
# @staticmethod
# def get_by_username(username):
# return Account.objects.filter(user__username=username).first()
#
# class Relationship(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='following')
# follow = models.ForeignKey(to='account.Account', related_name='followers')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# class Meta:
# unique_together = ('owner', 'follow',)
#
# Path: notification/models.py
# class Notification(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='notifications')
# sender = models.ForeignKey(to='account.Account', related_name='sent_notifications')
# post = models.ForeignKey(to='link.Post', null=True)
# type = models.CharField(max_length=50)
# viewed = models.BooleanField(default=False)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @staticmethod
# def check_as_viewed(owner):
# Notification.objects.filter(owner=owner).update(viewed=True)
#
# @staticmethod
# def add(owner, sender, type, post=None):
# notify = Notification(owner=owner, sender=sender, type=type.value, post=post)
# notify.save()
#
# class NotificationType(Enum):
# ADD = 'ADD'
# REACT = 'LIKE'
# COMMENT = 'COMMENT'
# FOLLOW = 'FOLLOW'
. Output only the next line. | request.session.save() |
Using the snippet: <|code_start|>class SettingsView:
@staticmethod
@login_required
def settings(request):
user = request.user
form = None
if request.method == 'POST':
form = SettingsForm(request.POST)
if form.is_valid():
data = form.data
user.first_name = data['first_name']
user.last_name = data['last_name']
if data['password']:
user.set_password(data['password'])
user.save()
notify_count = Notification.objects.filter(owner__user=user, viewed=False).count()
return render(request, 'account/settings.html', {'settings': user, 'form': form,
'notify_count': notify_count})
@staticmethod
@login_required
def upload_avatar(request):
user = request.user
user_avatar = request.FILES.get('user_avatar', None)
if request.method == 'POST' and user_avatar:
ext = os.path.splitext(user_avatar.name)[1]
if ext.lower() in ['.jpg', '.jpeg', '.png']:
filename = user.username + '.jpg'
fs = FileSystemStorage()
if fs.exists(filename):
<|code_end|>
, determine the next line of code. You have imports:
import os
from django.shortcuts import redirect, render, get_object_or_404
from django.urls import reverse
from django.contrib.auth import login, logout
from django.contrib.auth.models import User
from django.core.files.storage import FileSystemStorage
from django.contrib.auth.decorators import login_required
from account.forms import SignUpForm, LoginForm, SettingsForm
from account.models import Account, Relationship
from notification.models import Notification, NotificationType
and context (class names, function names, or code) available:
# Path: account/forms.py
# class SignUpForm(forms.ModelForm):
# class Meta:
# model = User
# fields = ('first_name', 'last_name', 'username', 'email', 'password',)
# User._meta.get_field('email')._unique = True
# User._meta.get_field('email').blank = False
# User._meta.get_field('email').null = False
# User._meta.get_field('first_name').blank = False
# User._meta.get_field('first_name').null = False
# User._meta.get_field('last_name').blank = False
# User._meta.get_field('last_name').null = False
#
# def clean_username(self):
# username = self.cleaned_data['username']
# if not re.match(r'^[A-Za-z0-9]+$', username):
# raise forms.ValidationError('Username does not allow special characters.')
# return username.lower()
#
# def clean_email(self):
# email = self.cleaned_data['email']
# return email.lower()
#
# class LoginForm(forms.Form):
# identity = forms.CharField(min_length=3, required=True)
# password = forms.CharField(min_length=3, required=True)
# keep_connected = forms.BooleanField(initial=False, required=False)
#
# class SettingsForm(forms.Form):
# first_name = forms.CharField(min_length=3, required=True)
# last_name = forms.CharField(min_length=3, required=True)
# password = forms.CharField(min_length=3, required=False)
# confirm_password = forms.CharField(min_length=3, required=False)
#
# def clean(self):
# cleaned_data = super(SettingsForm, self).clean()
# password = cleaned_data.get("password")
# confirm_password = cleaned_data.get("confirm_password")
# if password != confirm_password:
# raise forms.ValidationError('Password confirmation does not equal with password.',)
# return password
#
# Path: account/models.py
# class Account(models.Model):
# user = models.ForeignKey(to='auth.User', related_name='accounts')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @property
# def user_avatar(self):
# fs = FileSystemStorage()
# if fs.exists(self.user.username + '.jpg'):
# return '/static/avatar/' + self.user.username + '.jpg'
# else:
# return '/static/img/profile/default.jpg'
#
# def is_following(self, follow):
# return self.following.filter(follow=follow).exists()
#
# def unfollow(self, follow):
# relationship = self.following.filter(follow=follow).first()
# relationship.delete()
#
# @staticmethod
# def get_by_user(user):
# return Account.objects.filter(user=user).first()
#
# @staticmethod
# def get_by_username(username):
# return Account.objects.filter(user__username=username).first()
#
# class Relationship(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='following')
# follow = models.ForeignKey(to='account.Account', related_name='followers')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# class Meta:
# unique_together = ('owner', 'follow',)
#
# Path: notification/models.py
# class Notification(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='notifications')
# sender = models.ForeignKey(to='account.Account', related_name='sent_notifications')
# post = models.ForeignKey(to='link.Post', null=True)
# type = models.CharField(max_length=50)
# viewed = models.BooleanField(default=False)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @staticmethod
# def check_as_viewed(owner):
# Notification.objects.filter(owner=owner).update(viewed=True)
#
# @staticmethod
# def add(owner, sender, type, post=None):
# notify = Notification(owner=owner, sender=sender, type=type.value, post=post)
# notify.save()
#
# class NotificationType(Enum):
# ADD = 'ADD'
# REACT = 'LIKE'
# COMMENT = 'COMMENT'
# FOLLOW = 'FOLLOW'
. Output only the next line. | fs.delete(filename) |
Using the snippet: <|code_start|> @staticmethod
@login_required
def follow(request, username):
if request.method == 'POST':
relationship = Relationship()
relationship.owner = Account.get_by_user(request.user)
relationship.follow = Account.get_by_username(username)
if not relationship.owner.is_following(relationship.follow):
relationship.save()
Notification.add(relationship.follow, relationship.owner, NotificationType.FOLLOW)
return redirect('profile', username)
@staticmethod
@login_required
def unfollow(request, username):
if request.method == 'POST':
owner = Account.get_by_user(request.user)
follow = Account.get_by_username(username)
owner.unfollow(follow)
return redirect('profile', username)
class SettingsView:
@staticmethod
@login_required
def settings(request):
user = request.user
form = None
if request.method == 'POST':
form = SettingsForm(request.POST)
<|code_end|>
, determine the next line of code. You have imports:
import os
from django.shortcuts import redirect, render, get_object_or_404
from django.urls import reverse
from django.contrib.auth import login, logout
from django.contrib.auth.models import User
from django.core.files.storage import FileSystemStorage
from django.contrib.auth.decorators import login_required
from account.forms import SignUpForm, LoginForm, SettingsForm
from account.models import Account, Relationship
from notification.models import Notification, NotificationType
and context (class names, function names, or code) available:
# Path: account/forms.py
# class SignUpForm(forms.ModelForm):
# class Meta:
# model = User
# fields = ('first_name', 'last_name', 'username', 'email', 'password',)
# User._meta.get_field('email')._unique = True
# User._meta.get_field('email').blank = False
# User._meta.get_field('email').null = False
# User._meta.get_field('first_name').blank = False
# User._meta.get_field('first_name').null = False
# User._meta.get_field('last_name').blank = False
# User._meta.get_field('last_name').null = False
#
# def clean_username(self):
# username = self.cleaned_data['username']
# if not re.match(r'^[A-Za-z0-9]+$', username):
# raise forms.ValidationError('Username does not allow special characters.')
# return username.lower()
#
# def clean_email(self):
# email = self.cleaned_data['email']
# return email.lower()
#
# class LoginForm(forms.Form):
# identity = forms.CharField(min_length=3, required=True)
# password = forms.CharField(min_length=3, required=True)
# keep_connected = forms.BooleanField(initial=False, required=False)
#
# class SettingsForm(forms.Form):
# first_name = forms.CharField(min_length=3, required=True)
# last_name = forms.CharField(min_length=3, required=True)
# password = forms.CharField(min_length=3, required=False)
# confirm_password = forms.CharField(min_length=3, required=False)
#
# def clean(self):
# cleaned_data = super(SettingsForm, self).clean()
# password = cleaned_data.get("password")
# confirm_password = cleaned_data.get("confirm_password")
# if password != confirm_password:
# raise forms.ValidationError('Password confirmation does not equal with password.',)
# return password
#
# Path: account/models.py
# class Account(models.Model):
# user = models.ForeignKey(to='auth.User', related_name='accounts')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @property
# def user_avatar(self):
# fs = FileSystemStorage()
# if fs.exists(self.user.username + '.jpg'):
# return '/static/avatar/' + self.user.username + '.jpg'
# else:
# return '/static/img/profile/default.jpg'
#
# def is_following(self, follow):
# return self.following.filter(follow=follow).exists()
#
# def unfollow(self, follow):
# relationship = self.following.filter(follow=follow).first()
# relationship.delete()
#
# @staticmethod
# def get_by_user(user):
# return Account.objects.filter(user=user).first()
#
# @staticmethod
# def get_by_username(username):
# return Account.objects.filter(user__username=username).first()
#
# class Relationship(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='following')
# follow = models.ForeignKey(to='account.Account', related_name='followers')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# class Meta:
# unique_together = ('owner', 'follow',)
#
# Path: notification/models.py
# class Notification(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='notifications')
# sender = models.ForeignKey(to='account.Account', related_name='sent_notifications')
# post = models.ForeignKey(to='link.Post', null=True)
# type = models.CharField(max_length=50)
# viewed = models.BooleanField(default=False)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @staticmethod
# def check_as_viewed(owner):
# Notification.objects.filter(owner=owner).update(viewed=True)
#
# @staticmethod
# def add(owner, sender, type, post=None):
# notify = Notification(owner=owner, sender=sender, type=type.value, post=post)
# notify.save()
#
# class NotificationType(Enum):
# ADD = 'ADD'
# REACT = 'LIKE'
# COMMENT = 'COMMENT'
# FOLLOW = 'FOLLOW'
. Output only the next line. | if form.is_valid(): |
Here is a snippet: <|code_start|>
DEFAULT_PASSWORD = 'abc@123'
class UserFactory(factory.DjangoModelFactory):
class Meta:
model = User
username = factory.sequence(lambda n: 'user{}'.format(n))
email = factory.lazy_attribute(lambda n: '{}@test.com'.format(n.username.lower()))
password = factory.PostGenerationMethodCall('set_password', DEFAULT_PASSWORD)
first_name = factory.sequence(lambda n: 'First User Name {}'.format(n))
last_name = factory.sequence(lambda n: 'Last User Name {}'.format(n))
class AccountFactory(factory.DjangoModelFactory):
class Meta:
model = Account
user = factory.SubFactory(UserFactory)
<|code_end|>
. Write the next line using the current file imports:
import factory
from django.contrib.auth.models import User
from account.models import Account, Relationship
and context from other files:
# Path: account/models.py
# class Account(models.Model):
# user = models.ForeignKey(to='auth.User', related_name='accounts')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @property
# def user_avatar(self):
# fs = FileSystemStorage()
# if fs.exists(self.user.username + '.jpg'):
# return '/static/avatar/' + self.user.username + '.jpg'
# else:
# return '/static/img/profile/default.jpg'
#
# def is_following(self, follow):
# return self.following.filter(follow=follow).exists()
#
# def unfollow(self, follow):
# relationship = self.following.filter(follow=follow).first()
# relationship.delete()
#
# @staticmethod
# def get_by_user(user):
# return Account.objects.filter(user=user).first()
#
# @staticmethod
# def get_by_username(username):
# return Account.objects.filter(user__username=username).first()
#
# class Relationship(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='following')
# follow = models.ForeignKey(to='account.Account', related_name='followers')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# class Meta:
# unique_together = ('owner', 'follow',)
, which may include functions, classes, or code. Output only the next line. | class RelationshipFactory(factory.DjangoModelFactory): |
Given the code snippet: <|code_start|>
DEFAULT_PASSWORD = 'abc@123'
class UserFactory(factory.DjangoModelFactory):
class Meta:
model = User
username = factory.sequence(lambda n: 'user{}'.format(n))
email = factory.lazy_attribute(lambda n: '{}@test.com'.format(n.username.lower()))
password = factory.PostGenerationMethodCall('set_password', DEFAULT_PASSWORD)
<|code_end|>
, generate the next line using the imports in this file:
import factory
from django.contrib.auth.models import User
from account.models import Account, Relationship
and context (functions, classes, or occasionally code) from other files:
# Path: account/models.py
# class Account(models.Model):
# user = models.ForeignKey(to='auth.User', related_name='accounts')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# @property
# def user_avatar(self):
# fs = FileSystemStorage()
# if fs.exists(self.user.username + '.jpg'):
# return '/static/avatar/' + self.user.username + '.jpg'
# else:
# return '/static/img/profile/default.jpg'
#
# def is_following(self, follow):
# return self.following.filter(follow=follow).exists()
#
# def unfollow(self, follow):
# relationship = self.following.filter(follow=follow).first()
# relationship.delete()
#
# @staticmethod
# def get_by_user(user):
# return Account.objects.filter(user=user).first()
#
# @staticmethod
# def get_by_username(username):
# return Account.objects.filter(user__username=username).first()
#
# class Relationship(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='following')
# follow = models.ForeignKey(to='account.Account', related_name='followers')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# class Meta:
# unique_together = ('owner', 'follow',)
. Output only the next line. | first_name = factory.sequence(lambda n: 'First User Name {}'.format(n)) |
Predict the next line for this snippet: <|code_start|> return self.tags.split(',')
def add_link(self, user):
new_post = copy.copy(self)
new_post.owner = user
new_post.origin = self
new_post.id = None
new_post.save()
@staticmethod
def feeds(username):
follower_ids = Relationship.objects.filter(
owner__user__username=username).values_list('follow_id', flat=True).distinct()
qs_reacted = Reaction.objects.filter(post=models.OuterRef('pk'),
owner__user__username=username)
qs_added = Post.objects.filter(origin=models.OuterRef('pk'),
owner__user__username=username)
return Post.objects.filter(
models.Q(owner_id__in=follower_ids) |
models.Q(owner__user__username=username)).annotate(
is_reacted=models.Exists(queryset=qs_reacted)).annotate(
is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
@staticmethod
def links_by_user(username, user=None):
qs_reactions = Reaction.objects.filter(post=models.OuterRef('pk'), owner=user)
qs_added = Post.objects.filter(origin=models.OuterRef('pk'), owner=user)
return Post.objects.filter(owner__user__username=username).annotate(
<|code_end|>
with the help of current file imports:
import copy
from django.db import models
from link import utils
from account.models import Relationship
and context from other files:
# Path: link/utils.py
# def get_page_info(url):
# def get_page_head():
# def get_title_from_url():
# def summary_from_text(txt, size=250):
# def build_tags(*args):
# def __init__(self, html=None):
# def __contains__(self, item):
# def __getattr__(self, name):
# def _parse(self, html):
# class OpenGraph:
# class LinkException(Exception):
#
# Path: account/models.py
# class Relationship(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='following')
# follow = models.ForeignKey(to='account.Account', related_name='followers')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# class Meta:
# unique_together = ('owner', 'follow',)
, which may contain function names, class names, or code. Output only the next line. | is_reacted=models.Exists(queryset=qs_reactions)).annotate( |
Here is a snippet: <|code_start|> page_info = utils.get_page_info(self.url)
self.type = page_info['type']
self.title = page_info['title']
self.summary = page_info['summary']
self.text = page_info['text']
self.image_url = page_info['image']
self.tags = ','.join(page_info['tags'])
self.publish_date = page_info['publish_date']
def get_tags_as_list(self):
return self.tags.split(',')
def add_link(self, user):
new_post = copy.copy(self)
new_post.owner = user
new_post.origin = self
new_post.id = None
new_post.save()
@staticmethod
def feeds(username):
follower_ids = Relationship.objects.filter(
owner__user__username=username).values_list('follow_id', flat=True).distinct()
qs_reacted = Reaction.objects.filter(post=models.OuterRef('pk'),
owner__user__username=username)
qs_added = Post.objects.filter(origin=models.OuterRef('pk'),
owner__user__username=username)
return Post.objects.filter(
models.Q(owner_id__in=follower_ids) |
<|code_end|>
. Write the next line using the current file imports:
import copy
from django.db import models
from link import utils
from account.models import Relationship
and context from other files:
# Path: link/utils.py
# def get_page_info(url):
# def get_page_head():
# def get_title_from_url():
# def summary_from_text(txt, size=250):
# def build_tags(*args):
# def __init__(self, html=None):
# def __contains__(self, item):
# def __getattr__(self, name):
# def _parse(self, html):
# class OpenGraph:
# class LinkException(Exception):
#
# Path: account/models.py
# class Relationship(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='following')
# follow = models.ForeignKey(to='account.Account', related_name='followers')
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# class Meta:
# unique_together = ('owner', 'follow',)
, which may include functions, classes, or code. Output only the next line. | models.Q(owner__user__username=username)).annotate( |
Using the snippet: <|code_start|> RelationshipFactory.create(owner=account0, follow=account1)
RelationshipFactory.create(owner=account1, follow=account2)
[PostFactory.create(owner=account0, publisher=account0,
title='Search A', tags='search') for _ in range(2)]
[PostFactory.create(owner=account1, publisher=account1,
title='Search B', tags='search') for _ in range(2)]
[PostFactory.create(owner=account2, publisher=account2,
title='Search C', tags='search') for _ in range(2)]
[PostFactory.create(title='Search D', tags='search') for _ in range(2)]
self.user = account0.user
def test_standard_search_anonymous(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('search'), {'q': 'search', 'anonymous': 1})
search = response.context['search']
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'search/list.html')
self.assertEqual(len(search.results), 11)
def test_standard_search(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('search'), {'q': 'search'})
search = response.context['search']
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'search/list.html')
self.assertEqual(len(search.results), 11)
def test_advanced_search_anonymous_by_user(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('search'), {'q': 'user:search', 'anonymous': 1})
<|code_end|>
, determine the next line of code. You have imports:
from django.test import TestCase
from django.core.urlresolvers import reverse
from account.factories import AccountFactory, RelationshipFactory, DEFAULT_PASSWORD
from link.factories import PostFactory
and context (class names, function names, or code) available:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# class RelationshipFactory(factory.DjangoModelFactory):
# class Meta:
# model = Relationship
#
# owner = factory.SubFactory(AccountFactory)
# follow = factory.SubFactory(AccountFactory)
#
# DEFAULT_PASSWORD = 'abc@123'
#
# Path: link/factories.py
# class PostFactory(factory.DjangoModelFactory):
# class Meta:
# model = Post
#
# owner = factory.SubFactory(AccountFactory)
# publisher = factory.SubFactory(AccountFactory)
# url = 'http://test.tst'
# type = 'html'
# title = factory.sequence(lambda n: 'Title Link Test {}'.format(n))
# summary = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# text = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# image_url = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
. Output only the next line. | search = response.context['search'] |
Next line prediction: <|code_start|> self.assertEqual(len(search.results), 8)
def test_advanced_search_by_user(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('search'), {'q': 'user:search'})
search = response.context['search']
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'search/list.html')
self.assertEqual(len(search.results), 3)
def test_advanced_search_by_title(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('search'), {'q': 'title:search'})
search = response.context['search']
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'search/list.html')
self.assertEqual(len(search.results), 8)
def test_advanced_search_by_tag(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('search'), {'q': 'tag:search'})
search = response.context['search']
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'search/list.html')
self.assertEqual(len(search.results), 8)
def test_advanced_search_by_not_supported_key(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('search'), {'q': 'type:search'})
search = response.context['search']
<|code_end|>
. Use current file imports:
(from django.test import TestCase
from django.core.urlresolvers import reverse
from account.factories import AccountFactory, RelationshipFactory, DEFAULT_PASSWORD
from link.factories import PostFactory)
and context including class names, function names, or small code snippets from other files:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# class RelationshipFactory(factory.DjangoModelFactory):
# class Meta:
# model = Relationship
#
# owner = factory.SubFactory(AccountFactory)
# follow = factory.SubFactory(AccountFactory)
#
# DEFAULT_PASSWORD = 'abc@123'
#
# Path: link/factories.py
# class PostFactory(factory.DjangoModelFactory):
# class Meta:
# model = Post
#
# owner = factory.SubFactory(AccountFactory)
# publisher = factory.SubFactory(AccountFactory)
# url = 'http://test.tst'
# type = 'html'
# title = factory.sequence(lambda n: 'Title Link Test {}'.format(n))
# summary = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# text = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# image_url = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
. Output only the next line. | self.assertEqual(response.status_code, 200) |
Continue the code snippet: <|code_start|> account2 = AccountFactory.create(user__first_name='Search 2')
RelationshipFactory.create(owner=account0, follow=account1)
RelationshipFactory.create(owner=account1, follow=account2)
[PostFactory.create(owner=account0, publisher=account0,
title='Search A', tags='search') for _ in range(2)]
[PostFactory.create(owner=account1, publisher=account1,
title='Search B', tags='search') for _ in range(2)]
[PostFactory.create(owner=account2, publisher=account2,
title='Search C', tags='search') for _ in range(2)]
[PostFactory.create(title='Search D', tags='search') for _ in range(2)]
self.user = account0.user
def test_standard_search_anonymous(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('search'), {'q': 'search', 'anonymous': 1})
search = response.context['search']
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'search/list.html')
self.assertEqual(len(search.results), 11)
def test_standard_search(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('search'), {'q': 'search'})
search = response.context['search']
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'search/list.html')
self.assertEqual(len(search.results), 11)
def test_advanced_search_anonymous_by_user(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
<|code_end|>
. Use current file imports:
from django.test import TestCase
from django.core.urlresolvers import reverse
from account.factories import AccountFactory, RelationshipFactory, DEFAULT_PASSWORD
from link.factories import PostFactory
and context (classes, functions, or code) from other files:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# class RelationshipFactory(factory.DjangoModelFactory):
# class Meta:
# model = Relationship
#
# owner = factory.SubFactory(AccountFactory)
# follow = factory.SubFactory(AccountFactory)
#
# DEFAULT_PASSWORD = 'abc@123'
#
# Path: link/factories.py
# class PostFactory(factory.DjangoModelFactory):
# class Meta:
# model = Post
#
# owner = factory.SubFactory(AccountFactory)
# publisher = factory.SubFactory(AccountFactory)
# url = 'http://test.tst'
# type = 'html'
# title = factory.sequence(lambda n: 'Title Link Test {}'.format(n))
# summary = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# text = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# image_url = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
. Output only the next line. | response = self.client.get(reverse('search'), {'q': 'user:search', 'anonymous': 1}) |
Using the snippet: <|code_start|> [PostFactory.create(owner=account0, publisher=account0,
title='Search A', tags='search') for _ in range(2)]
[PostFactory.create(owner=account1, publisher=account1,
title='Search B', tags='search') for _ in range(2)]
[PostFactory.create(owner=account2, publisher=account2,
title='Search C', tags='search') for _ in range(2)]
[PostFactory.create(title='Search D', tags='search') for _ in range(2)]
self.user = account0.user
def test_standard_search_anonymous(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('search'), {'q': 'search', 'anonymous': 1})
search = response.context['search']
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'search/list.html')
self.assertEqual(len(search.results), 11)
def test_standard_search(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('search'), {'q': 'search'})
search = response.context['search']
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'search/list.html')
self.assertEqual(len(search.results), 11)
def test_advanced_search_anonymous_by_user(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('search'), {'q': 'user:search', 'anonymous': 1})
search = response.context['search']
self.assertEqual(response.status_code, 200)
<|code_end|>
, determine the next line of code. You have imports:
from django.test import TestCase
from django.core.urlresolvers import reverse
from account.factories import AccountFactory, RelationshipFactory, DEFAULT_PASSWORD
from link.factories import PostFactory
and context (class names, function names, or code) available:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# class RelationshipFactory(factory.DjangoModelFactory):
# class Meta:
# model = Relationship
#
# owner = factory.SubFactory(AccountFactory)
# follow = factory.SubFactory(AccountFactory)
#
# DEFAULT_PASSWORD = 'abc@123'
#
# Path: link/factories.py
# class PostFactory(factory.DjangoModelFactory):
# class Meta:
# model = Post
#
# owner = factory.SubFactory(AccountFactory)
# publisher = factory.SubFactory(AccountFactory)
# url = 'http://test.tst'
# type = 'html'
# title = factory.sequence(lambda n: 'Title Link Test {}'.format(n))
# summary = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# text = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# image_url = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
. Output only the next line. | self.assertTemplateUsed(response, 'search/list.html') |
Given the code snippet: <|code_start|>
img_url = 'https://test.fleeg/valid-image-link'
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.post(reverse('link_new'), data={'url': img_url})
self.assertRedirects(response, reverse('home'))
self.assertEqual(self.account.posts.all().count(), 3)
@patch('link.utils.requests.head')
@patch('link.utils.Article')
def test_post_new_link_news_success(self, mock_article, mock_req):
html = '''
<html>
<head>
<meta content="2015-04-09T10:25:24Z" property="og:pubdate"/>
<meta content="http://www.cnn.com/2015/04/09/entertainment/
feat-monty-python-holy-grail-40-years/index.html" property="og:url"/>
<meta content="40 years of 'Holy Grail': The best of Monty Python - CNN"
property="og:title"/><meta content='"Monty Python and the Holy Grail,"
premiered 40 years ago. The timing was right for the
British comedians (along with their token American, Terry Gilliam). '
property="og:description"/>
<meta property="og:empty_tag"/>
<meta content="abc,123" property="og:tags"/>
<meta content="CNN" property="og:site_name"/>
<meta content="article" property="og:type"/>
<meta content="http://i2.cdn.cnn.com/cnnnext/dam/assets/
150407084310-01-monty-python-super-169.jpg" property="og:image"/>
<meta content="1100" property="og:image:width"/>
<meta content="619" property="og:image:height"/>
</head>
<|code_end|>
, generate the next line using the imports in this file:
import requests
from unittest.mock import patch
from django.test import TestCase
from django.core.urlresolvers import reverse
from account.factories import AccountFactory, DEFAULT_PASSWORD
from link.factories import PostFactory, ReactionFactory
and context (functions, classes, or occasionally code) from other files:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# DEFAULT_PASSWORD = 'abc@123'
#
# Path: link/factories.py
# class PostFactory(factory.DjangoModelFactory):
# class Meta:
# model = Post
#
# owner = factory.SubFactory(AccountFactory)
# publisher = factory.SubFactory(AccountFactory)
# url = 'http://test.tst'
# type = 'html'
# title = factory.sequence(lambda n: 'Title Link Test {}'.format(n))
# summary = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# text = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# image_url = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
#
# class ReactionFactory(factory.DjangoModelFactory):
# class Meta:
# model = Reaction
#
# owner = factory.SubFactory(AccountFactory)
# post = factory.SubFactory(PostFactory)
. Output only the next line. | </html> |
Given the following code snippet before the placeholder: <|code_start|>
class TestLink(TestCase):
def setUp(self):
self.other_user = AccountFactory.create()
self.other_user_post = PostFactory.create(owner=self.other_user, publisher=self.other_user)
self.account = AccountFactory.create()
self.user = self.account.user
[PostFactory.create(owner=self.account, publisher=self.account) for _ in range(2)]
def test_access_links_anonymous(self):
response = self.client.get(reverse('links', args=[self.user.username]))
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'link/link.html')
def test_access_profile_logged_in(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('links', args=[self.user.username]))
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'link/link.html')
def test_access_home_logged_in(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.get(reverse('home'))
<|code_end|>
, predict the next line using imports from the current file:
import requests
from unittest.mock import patch
from django.test import TestCase
from django.core.urlresolvers import reverse
from account.factories import AccountFactory, DEFAULT_PASSWORD
from link.factories import PostFactory, ReactionFactory
and context including class names, function names, and sometimes code from other files:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# DEFAULT_PASSWORD = 'abc@123'
#
# Path: link/factories.py
# class PostFactory(factory.DjangoModelFactory):
# class Meta:
# model = Post
#
# owner = factory.SubFactory(AccountFactory)
# publisher = factory.SubFactory(AccountFactory)
# url = 'http://test.tst'
# type = 'html'
# title = factory.sequence(lambda n: 'Title Link Test {}'.format(n))
# summary = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# text = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# image_url = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
#
# class ReactionFactory(factory.DjangoModelFactory):
# class Meta:
# model = Reaction
#
# owner = factory.SubFactory(AccountFactory)
# post = factory.SubFactory(PostFactory)
. Output only the next line. | self.assertEqual(response.status_code, 200) |
Using the snippet: <|code_start|> self.assertTrue(response.context['posts'].count())
def test_post_new_link_fails_url_empty(self):
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.post(reverse('link_new'), data={})
self.assertFormError(response, 'form', 'url', 'This field is required.')
@patch('link.utils.requests.head')
def test_post_new_fails_invalid_link(self, mock_req):
mock_req.side_effect = requests.exceptions.RequestException
url_post = 'http://test.fleeg/invalid-link'
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
response = self.client.post(reverse('link_new'), data={'url': url_post})
self.assertFormError(response, 'form', None, 'Failed to read link.')
@patch('link.utils.requests.head')
@patch('link.utils.Article')
def test_post_new_link_success(self, mock_article, mock_req):
mock_req.return_value.headers = {'Content-Type': 'text/plain'}
mock_article.return_value.html = ''
mock_article.return_value.text = 'text mock page'
mock_article.return_value.title = 'title mock page'
mock_article.return_value.meta_img = 'http://url-to-image/img.jpg'
mock_article.return_value.meta_description = None
mock_article.return_value.publish_date = None
url_post = 'https://test.fleeg/valid-link'
self.client.login(username=self.user.username, password=DEFAULT_PASSWORD)
<|code_end|>
, determine the next line of code. You have imports:
import requests
from unittest.mock import patch
from django.test import TestCase
from django.core.urlresolvers import reverse
from account.factories import AccountFactory, DEFAULT_PASSWORD
from link.factories import PostFactory, ReactionFactory
and context (class names, function names, or code) available:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# DEFAULT_PASSWORD = 'abc@123'
#
# Path: link/factories.py
# class PostFactory(factory.DjangoModelFactory):
# class Meta:
# model = Post
#
# owner = factory.SubFactory(AccountFactory)
# publisher = factory.SubFactory(AccountFactory)
# url = 'http://test.tst'
# type = 'html'
# title = factory.sequence(lambda n: 'Title Link Test {}'.format(n))
# summary = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# text = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# image_url = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
#
# class ReactionFactory(factory.DjangoModelFactory):
# class Meta:
# model = Reaction
#
# owner = factory.SubFactory(AccountFactory)
# post = factory.SubFactory(PostFactory)
. Output only the next line. | response = self.client.post(reverse('link_new'), data={'url': url_post}) |
Predict the next line after this snippet: <|code_start|>
class TestLink(TestCase):
def setUp(self):
self.other_user = AccountFactory.create()
self.other_user_post = PostFactory.create(owner=self.other_user, publisher=self.other_user)
self.account = AccountFactory.create()
self.user = self.account.user
[PostFactory.create(owner=self.account, publisher=self.account) for _ in range(2)]
def test_access_links_anonymous(self):
response = self.client.get(reverse('links', args=[self.user.username]))
self.assertEqual(response.status_code, 200)
<|code_end|>
using the current file's imports:
import requests
from unittest.mock import patch
from django.test import TestCase
from django.core.urlresolvers import reverse
from account.factories import AccountFactory, DEFAULT_PASSWORD
from link.factories import PostFactory, ReactionFactory
and any relevant context from other files:
# Path: account/factories.py
# class AccountFactory(factory.DjangoModelFactory):
# class Meta:
# model = Account
#
# user = factory.SubFactory(UserFactory)
#
# DEFAULT_PASSWORD = 'abc@123'
#
# Path: link/factories.py
# class PostFactory(factory.DjangoModelFactory):
# class Meta:
# model = Post
#
# owner = factory.SubFactory(AccountFactory)
# publisher = factory.SubFactory(AccountFactory)
# url = 'http://test.tst'
# type = 'html'
# title = factory.sequence(lambda n: 'Title Link Test {}'.format(n))
# summary = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# text = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
# image_url = factory.sequence(lambda n: 'Summary Link Test {}'.format(n))
#
# class ReactionFactory(factory.DjangoModelFactory):
# class Meta:
# model = Reaction
#
# owner = factory.SubFactory(AccountFactory)
# post = factory.SubFactory(PostFactory)
. Output only the next line. | self.assertTemplateUsed(response, 'link/link.html') |
Given snippet: <|code_start|>
class URLForm(forms.ModelForm):
class Meta:
model = Post
fields = ('url',)
class CommentForm(forms.ModelForm):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from django import forms
from link.models import Post, Comment
and context:
# Path: link/models.py
# class Post(models.Model):
# owner = models.ForeignKey(to='account.Account', related_name='own_posts')
# publisher = models.ForeignKey(to='account.Account', related_name='posts')
# origin = models.ForeignKey(to='link.Post', related_name='adds', null=True)
# url = models.URLField()
# type = models.CharField(max_length=200)
# title = models.CharField(max_length=200)
# summary = models.CharField(null=True, max_length=250)
# text = models.TextField(null=True)
# image_url = models.CharField(null=True, max_length=500)
# tags = models.CharField(null=True, max_length=500)
# publish_date = models.DateTimeField(null=True)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def set_metadata(self):
# page_info = utils.get_page_info(self.url)
# self.type = page_info['type']
# self.title = page_info['title']
# self.summary = page_info['summary']
# self.text = page_info['text']
# self.image_url = page_info['image']
# self.tags = ','.join(page_info['tags'])
# self.publish_date = page_info['publish_date']
#
# def get_tags_as_list(self):
# return self.tags.split(',')
#
# def add_link(self, user):
# new_post = copy.copy(self)
# new_post.owner = user
# new_post.origin = self
# new_post.id = None
# new_post.save()
#
# @staticmethod
# def feeds(username):
# follower_ids = Relationship.objects.filter(
# owner__user__username=username).values_list('follow_id', flat=True).distinct()
# qs_reacted = Reaction.objects.filter(post=models.OuterRef('pk'),
# owner__user__username=username)
# qs_added = Post.objects.filter(origin=models.OuterRef('pk'),
# owner__user__username=username)
#
# return Post.objects.filter(
# models.Q(owner_id__in=follower_ids) |
# models.Q(owner__user__username=username)).annotate(
# is_reacted=models.Exists(queryset=qs_reacted)).annotate(
# is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
#
# @staticmethod
# def links_by_user(username, user=None):
# qs_reactions = Reaction.objects.filter(post=models.OuterRef('pk'), owner=user)
# qs_added = Post.objects.filter(origin=models.OuterRef('pk'), owner=user)
#
# return Post.objects.filter(owner__user__username=username).annotate(
# is_reacted=models.Exists(queryset=qs_reactions)).annotate(
# is_added=models.Exists(queryset=qs_added)).order_by('-created_at')
#
# def __str__(self):
# return self.title
#
# class Comment(models.Model):
# owner = models.ForeignKey(to='account.Account')
# post = models.ForeignKey(to='link.Post', related_name='comments')
# text = models.CharField(max_length=1000)
# created_at = models.DateTimeField(auto_now_add=True)
# updated_at = models.DateTimeField(auto_now=True)
#
# def __str__(self):
# return self.text
which might include code, classes, or functions. Output only the next line. | class Meta: |
Using the snippet: <|code_start|>
class general_train(datasets_base):
def __init__(self, path, img_size=64, flip=1, crop_to=0, random_brightness=0):
self._paths = glob.glob(path + "/*.jpg")
#self._img_size=img_size
super(general_train, self).__init__(flip=1, resize_to=img_size, crop_to=crop_to, random_brightness=random_brightness)
def __len__(self):
return len(self._paths)
<|code_end|>
, determine the next line of code. You have imports:
import numpy as np
import chainer
import os
import glob
import cv2
from chainer import cuda, optimizers, serializers, Variable
from .datasets_base import datasets_base
and context (class names, function names, or code) available:
# Path: common/datasets/datasets_base.py
# class datasets_base(dataset_mixin.DatasetMixin):
# def __init__(self, flip=1, resize_to=64, crop_to=0, random_brightness=0):
# self.flip = flip
# self.resize_to = resize_to
# self.crop_to = crop_to
# self.random_brightness = random_brightness
#
# def preprocess_image(self, img):
# img = img.astype("f")
# img = img / 127.5 - 1
# img = img.transpose((2, 0, 1))
# return img
#
# def postprocess_image(self, img):
# img = (img + 1) *127.5
# img = np.clip(img, 0, 255)
# img = img.astype(np.uint8)
# img.transpose((1, 2, 0))
# return img
#
# def read_image_key_file_plaintext(self, file):
# with open(file,'r') as f:
# lines = f.readlines()
# return [i.strip() for i in lines]
#
# def read_image_key_file_json(self, file):
# return json.load(open(file ,"r"))
#
# # ensure the image is square before doing random crop
# def do_random_crop(self, img, crop_to):
# sz = img.shape[0]
# if sz > crop_to:
# lim = sz - crop_to
# x = np.random.randint(0,lim)
# y = np.random.randint(0,lim)
# img = img[x:x+crop_to, y:y+crop_to]
# return img
#
# def do_resize(self, img, resize_to):
# img = cv2.resize(img, (resize_to, resize_to), interpolation=cv2.INTER_AREA)
# return img
#
# def do_flip(self, img):
# if np.random.rand() > 0.5:
# img = cv2.flip(img, 1)
# return img
#
# def do_random_brightness(self, img):
# if np.random.rand() > 0.7:
# return img
# hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV).astype(np.int)
# hsv[:,:,2] += np.random.randint(-40,70)
# hsv = np.clip(hsv, 0, 255).astype(np.uint8)
# img = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
# return img
#
# def do_augmentation(self, img):
# if self.flip > 0:
# img = self.do_flip(img)
#
# if self.random_brightness > 0:
# img = self.do_random_brightness(img)
#
# if self.resize_to > 0:
# img = self.do_resize(img, self.resize_to)
#
# if self.crop_to > 0:
# img = self.do_random_crop(img, self.crop_to)
#
# return img
. Output only the next line. | def get_example(self, i): |
Here is a snippet: <|code_start|> if img.shape[0] < 64:
return None
return img
def get_example(self, i):
np.random.seed(None)
while True:
img = self.try_get_example()
if not img is None:
break
img = self.do_augmentation(img)
img = self.preprocess_image(img)
return img
class game_faces_tags_train(datasets_base):
def __init__(self, path, img_size=64, flip=1, crop_to=0, random_brightness=0, threshold=0.25):
self._paths = glob.glob(path + "/images/*.jpg")
self._datapath = path
with open(path + "/games.pickle", 'rb') as f:
self._gamedata=pickle.load(f)
with open(path + "/tags.pickle", 'rb') as f:
self._tags = pickle.load(f)
with open(path + "/attr.json") as f:
self._attr = json.load(f)
self._len_attr = len(self._attr)
self._threshold = threshold
super(game_faces_tags_train, self).__init__(flip=1, resize_to=img_size, crop_to=crop_to, random_brightness=random_brightness)
def __len__(self):
<|code_end|>
. Write the next line using the current file imports:
import numpy as np
import chainer
import os
import glob
import pandas
import pickle
import cv2
import datetime
import json
import pickle
from chainer import cuda, optimizers, serializers, Variable
from .datasets_base import datasets_base
and context from other files:
# Path: common/datasets/datasets_base.py
# class datasets_base(dataset_mixin.DatasetMixin):
# def __init__(self, flip=1, resize_to=64, crop_to=0, random_brightness=0):
# self.flip = flip
# self.resize_to = resize_to
# self.crop_to = crop_to
# self.random_brightness = random_brightness
#
# def preprocess_image(self, img):
# img = img.astype("f")
# img = img / 127.5 - 1
# img = img.transpose((2, 0, 1))
# return img
#
# def postprocess_image(self, img):
# img = (img + 1) *127.5
# img = np.clip(img, 0, 255)
# img = img.astype(np.uint8)
# img.transpose((1, 2, 0))
# return img
#
# def read_image_key_file_plaintext(self, file):
# with open(file,'r') as f:
# lines = f.readlines()
# return [i.strip() for i in lines]
#
# def read_image_key_file_json(self, file):
# return json.load(open(file ,"r"))
#
# # ensure the image is square before doing random crop
# def do_random_crop(self, img, crop_to):
# sz = img.shape[0]
# if sz > crop_to:
# lim = sz - crop_to
# x = np.random.randint(0,lim)
# y = np.random.randint(0,lim)
# img = img[x:x+crop_to, y:y+crop_to]
# return img
#
# def do_resize(self, img, resize_to):
# img = cv2.resize(img, (resize_to, resize_to), interpolation=cv2.INTER_AREA)
# return img
#
# def do_flip(self, img):
# if np.random.rand() > 0.5:
# img = cv2.flip(img, 1)
# return img
#
# def do_random_brightness(self, img):
# if np.random.rand() > 0.7:
# return img
# hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV).astype(np.int)
# hsv[:,:,2] += np.random.randint(-40,70)
# hsv = np.clip(hsv, 0, 255).astype(np.uint8)
# img = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
# return img
#
# def do_augmentation(self, img):
# if self.flip > 0:
# img = self.do_flip(img)
#
# if self.random_brightness > 0:
# img = self.do_random_brightness(img)
#
# if self.resize_to > 0:
# img = self.do_resize(img, self.resize_to)
#
# if self.crop_to > 0:
# img = self.do_random_crop(img, self.crop_to)
#
# return img
, which may include functions, classes, or code. Output only the next line. | return len(self._paths) |
Using the snippet: <|code_start|>
class mnist_train(datasets_base):
def __init__(self, path=None, img_size=64):
self.train, _ = chainer.datasets.get_mnist(withlabel=False, ndim=2, scale=255)
super(mnist_train, self).__init__(flip=1, resize_to=img_size, crop_to=0)
def __len__(self):
return self.train.__len__()
def do_resize(self, img, resize_to=32):
return cv2.resize(img, (resize_to, resize_to), interpolation=cv2.INTER_AREA)
def get_example(self, i):
img = self.train.__getitem__(i)
img = self.do_resize(img)
img = np.expand_dims(img, axis=2)
<|code_end|>
, determine the next line of code. You have imports:
import numpy as np
import chainer
import os
import glob
import cv2
from chainer import cuda, optimizers, serializers, Variable
from .datasets_base import datasets_base
and context (class names, function names, or code) available:
# Path: common/datasets/datasets_base.py
# class datasets_base(dataset_mixin.DatasetMixin):
# def __init__(self, flip=1, resize_to=64, crop_to=0, random_brightness=0):
# self.flip = flip
# self.resize_to = resize_to
# self.crop_to = crop_to
# self.random_brightness = random_brightness
#
# def preprocess_image(self, img):
# img = img.astype("f")
# img = img / 127.5 - 1
# img = img.transpose((2, 0, 1))
# return img
#
# def postprocess_image(self, img):
# img = (img + 1) *127.5
# img = np.clip(img, 0, 255)
# img = img.astype(np.uint8)
# img.transpose((1, 2, 0))
# return img
#
# def read_image_key_file_plaintext(self, file):
# with open(file,'r') as f:
# lines = f.readlines()
# return [i.strip() for i in lines]
#
# def read_image_key_file_json(self, file):
# return json.load(open(file ,"r"))
#
# # ensure the image is square before doing random crop
# def do_random_crop(self, img, crop_to):
# sz = img.shape[0]
# if sz > crop_to:
# lim = sz - crop_to
# x = np.random.randint(0,lim)
# y = np.random.randint(0,lim)
# img = img[x:x+crop_to, y:y+crop_to]
# return img
#
# def do_resize(self, img, resize_to):
# img = cv2.resize(img, (resize_to, resize_to), interpolation=cv2.INTER_AREA)
# return img
#
# def do_flip(self, img):
# if np.random.rand() > 0.5:
# img = cv2.flip(img, 1)
# return img
#
# def do_random_brightness(self, img):
# if np.random.rand() > 0.7:
# return img
# hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV).astype(np.int)
# hsv[:,:,2] += np.random.randint(-40,70)
# hsv = np.clip(hsv, 0, 255).astype(np.uint8)
# img = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
# return img
#
# def do_augmentation(self, img):
# if self.flip > 0:
# img = self.do_flip(img)
#
# if self.random_brightness > 0:
# img = self.do_random_brightness(img)
#
# if self.resize_to > 0:
# img = self.do_resize(img, self.resize_to)
#
# if self.crop_to > 0:
# img = self.do_random_crop(img, self.crop_to)
#
# return img
. Output only the next line. | img = self.preprocess_image(img) |
Here is a snippet: <|code_start|>
class celeba_train(datasets_base):
def __init__(self, path, img_size=64):
self._paths = glob.glob(path + "/img_align_celeba/*.jpg")
#self._img_size=img_size
<|code_end|>
. Write the next line using the current file imports:
import numpy as np
import chainer
import os
import glob
import cv2
from chainer import cuda, optimizers, serializers, Variable
from .datasets_base import datasets_base
and context from other files:
# Path: common/datasets/datasets_base.py
# class datasets_base(dataset_mixin.DatasetMixin):
# def __init__(self, flip=1, resize_to=64, crop_to=0, random_brightness=0):
# self.flip = flip
# self.resize_to = resize_to
# self.crop_to = crop_to
# self.random_brightness = random_brightness
#
# def preprocess_image(self, img):
# img = img.astype("f")
# img = img / 127.5 - 1
# img = img.transpose((2, 0, 1))
# return img
#
# def postprocess_image(self, img):
# img = (img + 1) *127.5
# img = np.clip(img, 0, 255)
# img = img.astype(np.uint8)
# img.transpose((1, 2, 0))
# return img
#
# def read_image_key_file_plaintext(self, file):
# with open(file,'r') as f:
# lines = f.readlines()
# return [i.strip() for i in lines]
#
# def read_image_key_file_json(self, file):
# return json.load(open(file ,"r"))
#
# # ensure the image is square before doing random crop
# def do_random_crop(self, img, crop_to):
# sz = img.shape[0]
# if sz > crop_to:
# lim = sz - crop_to
# x = np.random.randint(0,lim)
# y = np.random.randint(0,lim)
# img = img[x:x+crop_to, y:y+crop_to]
# return img
#
# def do_resize(self, img, resize_to):
# img = cv2.resize(img, (resize_to, resize_to), interpolation=cv2.INTER_AREA)
# return img
#
# def do_flip(self, img):
# if np.random.rand() > 0.5:
# img = cv2.flip(img, 1)
# return img
#
# def do_random_brightness(self, img):
# if np.random.rand() > 0.7:
# return img
# hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV).astype(np.int)
# hsv[:,:,2] += np.random.randint(-40,70)
# hsv = np.clip(hsv, 0, 255).astype(np.uint8)
# img = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
# return img
#
# def do_augmentation(self, img):
# if self.flip > 0:
# img = self.do_flip(img)
#
# if self.random_brightness > 0:
# img = self.do_random_brightness(img)
#
# if self.resize_to > 0:
# img = self.do_resize(img, self.resize_to)
#
# if self.crop_to > 0:
# img = self.do_random_crop(img, self.crop_to)
#
# return img
, which may include functions, classes, or code. Output only the next line. | super(celeba_train, self).__init__(flip=1, resize_to=img_size, crop_to=0) |
Based on the snippet: <|code_start|> return tags
def get_fake_tag_batch():
xp = gen.xp
batch = rows*cols
tags = xp.zeros((batch, attr_len)).astype("f")
for i in range(batch):
tags[i] = xp.asarray(get_fake_tag())
return tags
def samples_generation(trainer):
if not os.path.exists(eval_folder):
os.makedirs(eval_folder)
z = np.random.normal(size=(rows*cols, latent_len)).astype("f")
if gpu>=0:
z = cuda.to_gpu(z)
tags =get_fake_tag_batch()
z = Variable(z, volatile=True)
tags = Variable(tags, volatile=True)
imgs = gen(F.concat([z,tags]), test=True)
save_images_grid(imgs, path=eval_folder+"/iter_"+str(trainer.updater.iteration)+".jpg",
grid_w=rows, grid_h=cols)
return samples_generation
def ae_reconstruction(enc, dec, eval_folder, gpu, data_iter, batch_size=32, img_chan=3, img_size=64):
@chainer.training.make_extension()
def sample_reconstruction(trainer):
xp = enc.xp
batch = data_iter.next()
<|code_end|>
, predict the immediate next line with the help of imports:
import os
import chainer
import chainer.functions as F
import numpy as np
import os
import cv2
from chainer.training import extension
from chainer import Variable, cuda
from .save_images import save_images_grid
and context (classes, functions, sometimes code) from other files:
# Path: common/utils/save_images.py
# def save_images_grid(imgs, path, grid_w=4, grid_h=4, post_processing=postprocessing_tanh, transposed=False):
# imgs = copy_to_cpu(imgs)
# if post_processing is not None:
# imgs = post_processing(imgs)
# b, ch, w, h = imgs.shape
# assert b == grid_w*grid_h
#
# imgs = imgs.reshape((grid_w, grid_h, ch, w, h))
# imgs = imgs.transpose(0, 1, 3, 4, 2)
# if transposed:
# imgs = imgs.reshape((grid_w, grid_h, w, h, ch)).transpose(1, 2, 0, 3, 4).reshape((grid_h*w, grid_w*h, ch))
# else:
# imgs = imgs.reshape((grid_w, grid_h, w, h, ch)).transpose(0, 2, 1, 3, 4).reshape((grid_w*w, grid_h*h, ch))
# if ch==1:
# imgs = imgs.reshape((grid_w*w, grid_h*h))
# cv2.imwrite(path, imgs)
. Output only the next line. | d_real = xp.zeros((batch_size, img_chan, img_size, img_size)).astype("f") |
Continue the code snippet: <|code_start|>
approach = Group(
murta2014a, pimentel2015a,
_display="no Work flow",
_approach_name="noWorkflow",
_cite=False,
<|code_end|>
. Use current file imports:
from snowballing.approaches import Group
from ..constants import *
from ...work.y2014 import murta2014a
from ...work.y2015 import pimentel2015a
and context (classes, functions, or code) from other files:
# Path: snowballing/approaches.py
# class Group:
# """Represent an Approach or a Group of work.
#
# Arguments:
#
# * `args` -- list of work that represents the group
#
# * `kwargs` -- map of attributes to be applied for the group and its works
#
# * Exception: the keyword `dont_cite=` also represents a list of works that
# belong to the group
#
#
# Expected attributes:
#
# * _cite: cite group by authors
#
# * True indicates that the approach must be referenced by its authors
# * False indicates that the approach can referenced by name
#
# * _meta: list of dicts with attributes for comparing approaches
#
# * A single approach can have more than one meta dict
# * It is possible to use the distinct meta dicts to describe different
# aspects
#
# * _about: HTML describing the approach
#
# Doctest:
#
# .. doctest::
#
# >>> from .operations import reload, work_by_varname
# >>> reload()
# >>> murta2014a = work_by_varname("murta2014a")
# >>> pimentel2015a = work_by_varname("pimentel2015a")
# >>> pimentel2015a.display == "now"
# False
# >>> APPROACHES.clear()
# >>> len(APPROACHES)
# 0
# >>> group = Group(
# ... murta2014a, pimentel2015a,
# ... display="now",
# ... _cite=True,
# ... _meta=[dict(
# ... scripts=True
# ... )]
# ... )
# >>> group.display
# 'now'
# >>> pimentel2015a.display == "now"
# True
# >>> len(APPROACHES)
# 1
# """
# _category = config.APPROACH_RELATED_CATEGORY
# def __init__(self, *args ,**kwargs):
# work = list(args)
# if dhas(kwargs, "approach_dont_cite"):
# work += dget(kwargs, "approach_dont_cite")
# oset(self, "approach_dont_cite", dget(kwargs, "approach_dont_cite"))
# ddel(kwargs, "approach_dont_cite")
# oset(self, "approach_work", work)
#
# for key, item in kwargs.items():
# for arg in work:
# if not hasattr(arg, config.APPROACH_FORCE_PREFIX + key):
# setattr(arg, key, item)
# setattr(self, key, item)
#
# if self._category == config.APPROACH_RELATED_CATEGORY:
# APPROACHES.append(self)
#
# Path: snowballing/bibtex/database/work/y2014.py
#
# Path: snowballing/bibtex/database/work/y2015.py
. Output only the next line. | _meta=[dict( |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.