Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Next line prediction: <|code_start|>
class BidirectionalIndex:
NOT_FOUND = -2
def __init__(self, goals: Iterable[int]):
self.m = {g: i + 1 for i, g in enumerate(sorted(g for g in goals if g > 0))}
self.length = len(self.m)
def forward(self, goal_id: int) -> int:
if goal_id < 0:
return goal_id
goal_id = self.m[goal_id]
new_id = goal_id % 10
if self.length > 10:
new_id += 10 * ((goal_id - 1) // 10 + 1)
if self.length > 90:
<|code_end|>
. Use current file imports:
(import math
from typing import List, Dict, Tuple, Any, Set, Iterable
from siebenapp.domain import Graph, Select)
and context including class names, function names, or small code snippets from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
. Output only the next line. | new_id += 100 * ((goal_id - 1) // 100 + 1) |
Predict the next line after this snippet: <|code_start|> self.m = {g: i + 1 for i, g in enumerate(sorted(g for g in goals if g > 0))}
self.length = len(self.m)
def forward(self, goal_id: int) -> int:
if goal_id < 0:
return goal_id
goal_id = self.m[goal_id]
new_id = goal_id % 10
if self.length > 10:
new_id += 10 * ((goal_id - 1) // 10 + 1)
if self.length > 90:
new_id += 100 * ((goal_id - 1) // 100 + 1)
if self.length > 900:
new_id += 1000 * ((goal_id - 1) // 1000 + 1)
return new_id
def backward(self, goal_id: int) -> int:
possible_selections: List[int] = [
g for g in self.m if self.forward(g) == goal_id
]
if len(possible_selections) == 1:
return possible_selections[0]
return BidirectionalIndex.NOT_FOUND
class Enumeration(Graph):
def __init__(self, goaltree: Graph) -> None:
super().__init__(goaltree)
self.selection_cache: List[int] = []
self._goal_filter: Set[int] = set()
<|code_end|>
using the current file's imports:
import math
from typing import List, Dict, Tuple, Any, Set, Iterable
from siebenapp.domain import Graph, Select
and any relevant context from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
. Output only the next line. | self._update_mapping() |
Given the following code snippet before the placeholder: <|code_start|>
@fixture
def goaltree():
return ProgressView(
build_goaltree(
open_(1, "Root", [2, 3], select=selected),
open_(2, "With blocker", [], [4]),
open_(3, "With subgoal", [4]),
open_(4, "Top goal"),
)
)
def test_no_progress_by_default(goaltree):
assert goaltree.q("name") == {
1: {"name": "Root"},
2: {"name": "With blocker"},
3: {"name": "With subgoal"},
4: {"name": "Top goal"},
}
def test_show_progress(goaltree):
goaltree.accept(ToggleProgress())
assert goaltree.q("name") == {
1: {"name": "[0/4] Root"},
2: {"name": "[0/1] With blocker"},
3: {"name": "[0/2] With subgoal"},
<|code_end|>
, predict the next line using imports from the current file:
from _pytest.fixtures import fixture
from siebenapp.domain import Select, ToggleClose
from siebenapp.progress_view import ProgressView, ToggleProgress
from siebenapp.tests.dsl import build_goaltree, selected, open_
and context including class names, function names, and sometimes code from other files:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# Path: siebenapp/progress_view.py
# class ProgressView(Graph):
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self.show_progress = False
#
# def accept_ToggleProgress(self, command: ToggleProgress) -> None:
# self.show_progress = not self.show_progress
#
# def settings(self, key: str) -> Any:
# if key == "filter_progress":
# return self.show_progress
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# self.show_progress = origin.settings("filter_progress")
#
# @with_key("name")
# @with_key("open")
# @with_key("edge")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# if not self.show_progress:
# return self.goaltree.q(keys)
# progress_cache: Dict[int, Tuple[int, int]] = {}
# result = self.goaltree.q(keys)
# queue: List[int] = list(result.keys())
# while queue:
# goal_id = queue.pop(0)
# children = [
# x[0] for x in result[goal_id]["edge"] if x[1] == EdgeType.PARENT
# ]
# open_count = 0 if result[goal_id]["open"] else 1
# if not children:
# progress_cache[goal_id] = (open_count, 1)
# elif all(g in progress_cache for g in children):
# progress_cache[goal_id] = (
# sum(progress_cache[x][0] for x in children) + open_count,
# sum(progress_cache[x][1] for x in children) + 1,
# )
# else:
# queue.append(goal_id)
#
# for goal_id, attr in result.items():
# progress = progress_cache[goal_id]
# old_name = attr["name"]
# attr["name"] = f"[{progress[0]}/{progress[1]}] {old_name}"
#
# return result
#
# class ToggleProgress(Command):
# pass
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
. Output only the next line. | 4: {"name": "[0/1] Top goal"}, |
Here is a snippet: <|code_start|> 1: {"name": "[0/4] Root"},
2: {"name": "[0/1] With blocker"},
3: {"name": "[0/2] With subgoal"},
4: {"name": "[0/1] Top goal"},
}
def test_toggle_hide_progress(goaltree):
goaltree.accept_all(ToggleProgress(), ToggleProgress())
assert goaltree.q("name") == {
1: {"name": "Root"},
2: {"name": "With blocker"},
3: {"name": "With subgoal"},
4: {"name": "Top goal"},
}
def test_change_progress_on_close(goaltree):
goaltree.accept_all(ToggleProgress(), Select(4), ToggleClose())
assert goaltree.q("name") == {
1: {"name": "[1/4] Root"},
2: {"name": "[0/1] With blocker"},
3: {"name": "[1/2] With subgoal"},
4: {"name": "[1/1] Top goal"},
}
goaltree.accept_all(Select(2), ToggleClose())
assert goaltree.q("name") == {
1: {"name": "[2/4] Root"},
2: {"name": "[1/1] With blocker"},
3: {"name": "[1/2] With subgoal"},
<|code_end|>
. Write the next line using the current file imports:
from _pytest.fixtures import fixture
from siebenapp.domain import Select, ToggleClose
from siebenapp.progress_view import ProgressView, ToggleProgress
from siebenapp.tests.dsl import build_goaltree, selected, open_
and context from other files:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# Path: siebenapp/progress_view.py
# class ProgressView(Graph):
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self.show_progress = False
#
# def accept_ToggleProgress(self, command: ToggleProgress) -> None:
# self.show_progress = not self.show_progress
#
# def settings(self, key: str) -> Any:
# if key == "filter_progress":
# return self.show_progress
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# self.show_progress = origin.settings("filter_progress")
#
# @with_key("name")
# @with_key("open")
# @with_key("edge")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# if not self.show_progress:
# return self.goaltree.q(keys)
# progress_cache: Dict[int, Tuple[int, int]] = {}
# result = self.goaltree.q(keys)
# queue: List[int] = list(result.keys())
# while queue:
# goal_id = queue.pop(0)
# children = [
# x[0] for x in result[goal_id]["edge"] if x[1] == EdgeType.PARENT
# ]
# open_count = 0 if result[goal_id]["open"] else 1
# if not children:
# progress_cache[goal_id] = (open_count, 1)
# elif all(g in progress_cache for g in children):
# progress_cache[goal_id] = (
# sum(progress_cache[x][0] for x in children) + open_count,
# sum(progress_cache[x][1] for x in children) + 1,
# )
# else:
# queue.append(goal_id)
#
# for goal_id, attr in result.items():
# progress = progress_cache[goal_id]
# old_name = attr["name"]
# attr["name"] = f"[{progress[0]}/{progress[1]}] {old_name}"
#
# return result
#
# class ToggleProgress(Command):
# pass
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
, which may include functions, classes, or code. Output only the next line. | 4: {"name": "[1/1] Top goal"}, |
Using the snippet: <|code_start|>
@fixture
def goaltree():
return ProgressView(
build_goaltree(
open_(1, "Root", [2, 3], select=selected),
open_(2, "With blocker", [], [4]),
open_(3, "With subgoal", [4]),
open_(4, "Top goal"),
)
)
def test_no_progress_by_default(goaltree):
assert goaltree.q("name") == {
1: {"name": "Root"},
<|code_end|>
, determine the next line of code. You have imports:
from _pytest.fixtures import fixture
from siebenapp.domain import Select, ToggleClose
from siebenapp.progress_view import ProgressView, ToggleProgress
from siebenapp.tests.dsl import build_goaltree, selected, open_
and context (class names, function names, or code) available:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# Path: siebenapp/progress_view.py
# class ProgressView(Graph):
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self.show_progress = False
#
# def accept_ToggleProgress(self, command: ToggleProgress) -> None:
# self.show_progress = not self.show_progress
#
# def settings(self, key: str) -> Any:
# if key == "filter_progress":
# return self.show_progress
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# self.show_progress = origin.settings("filter_progress")
#
# @with_key("name")
# @with_key("open")
# @with_key("edge")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# if not self.show_progress:
# return self.goaltree.q(keys)
# progress_cache: Dict[int, Tuple[int, int]] = {}
# result = self.goaltree.q(keys)
# queue: List[int] = list(result.keys())
# while queue:
# goal_id = queue.pop(0)
# children = [
# x[0] for x in result[goal_id]["edge"] if x[1] == EdgeType.PARENT
# ]
# open_count = 0 if result[goal_id]["open"] else 1
# if not children:
# progress_cache[goal_id] = (open_count, 1)
# elif all(g in progress_cache for g in children):
# progress_cache[goal_id] = (
# sum(progress_cache[x][0] for x in children) + open_count,
# sum(progress_cache[x][1] for x in children) + 1,
# )
# else:
# queue.append(goal_id)
#
# for goal_id, attr in result.items():
# progress = progress_cache[goal_id]
# old_name = attr["name"]
# attr["name"] = f"[{progress[0]}/{progress[1]}] {old_name}"
#
# return result
#
# class ToggleProgress(Command):
# pass
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
. Output only the next line. | 2: {"name": "With blocker"}, |
Given snippet: <|code_start|>
@fixture
def goaltree():
return ProgressView(
build_goaltree(
open_(1, "Root", [2, 3], select=selected),
open_(2, "With blocker", [], [4]),
open_(3, "With subgoal", [4]),
open_(4, "Top goal"),
)
)
def test_no_progress_by_default(goaltree):
assert goaltree.q("name") == {
1: {"name": "Root"},
2: {"name": "With blocker"},
3: {"name": "With subgoal"},
4: {"name": "Top goal"},
}
def test_show_progress(goaltree):
goaltree.accept(ToggleProgress())
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from _pytest.fixtures import fixture
from siebenapp.domain import Select, ToggleClose
from siebenapp.progress_view import ProgressView, ToggleProgress
from siebenapp.tests.dsl import build_goaltree, selected, open_
and context:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# Path: siebenapp/progress_view.py
# class ProgressView(Graph):
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self.show_progress = False
#
# def accept_ToggleProgress(self, command: ToggleProgress) -> None:
# self.show_progress = not self.show_progress
#
# def settings(self, key: str) -> Any:
# if key == "filter_progress":
# return self.show_progress
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# self.show_progress = origin.settings("filter_progress")
#
# @with_key("name")
# @with_key("open")
# @with_key("edge")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# if not self.show_progress:
# return self.goaltree.q(keys)
# progress_cache: Dict[int, Tuple[int, int]] = {}
# result = self.goaltree.q(keys)
# queue: List[int] = list(result.keys())
# while queue:
# goal_id = queue.pop(0)
# children = [
# x[0] for x in result[goal_id]["edge"] if x[1] == EdgeType.PARENT
# ]
# open_count = 0 if result[goal_id]["open"] else 1
# if not children:
# progress_cache[goal_id] = (open_count, 1)
# elif all(g in progress_cache for g in children):
# progress_cache[goal_id] = (
# sum(progress_cache[x][0] for x in children) + open_count,
# sum(progress_cache[x][1] for x in children) + 1,
# )
# else:
# queue.append(goal_id)
#
# for goal_id, attr in result.items():
# progress = progress_cache[goal_id]
# old_name = attr["name"]
# attr["name"] = f"[{progress[0]}/{progress[1]}] {old_name}"
#
# return result
#
# class ToggleProgress(Command):
# pass
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
which might include code, classes, or functions. Output only the next line. | assert goaltree.q("name") == { |
Next line prediction: <|code_start|>
@fixture
def goaltree():
return ProgressView(
build_goaltree(
open_(1, "Root", [2, 3], select=selected),
open_(2, "With blocker", [], [4]),
open_(3, "With subgoal", [4]),
open_(4, "Top goal"),
)
)
def test_no_progress_by_default(goaltree):
assert goaltree.q("name") == {
1: {"name": "Root"},
2: {"name": "With blocker"},
3: {"name": "With subgoal"},
4: {"name": "Top goal"},
}
def test_show_progress(goaltree):
goaltree.accept(ToggleProgress())
assert goaltree.q("name") == {
1: {"name": "[0/4] Root"},
2: {"name": "[0/1] With blocker"},
3: {"name": "[0/2] With subgoal"},
<|code_end|>
. Use current file imports:
(from _pytest.fixtures import fixture
from siebenapp.domain import Select, ToggleClose
from siebenapp.progress_view import ProgressView, ToggleProgress
from siebenapp.tests.dsl import build_goaltree, selected, open_)
and context including class names, function names, or small code snippets from other files:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# Path: siebenapp/progress_view.py
# class ProgressView(Graph):
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self.show_progress = False
#
# def accept_ToggleProgress(self, command: ToggleProgress) -> None:
# self.show_progress = not self.show_progress
#
# def settings(self, key: str) -> Any:
# if key == "filter_progress":
# return self.show_progress
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# self.show_progress = origin.settings("filter_progress")
#
# @with_key("name")
# @with_key("open")
# @with_key("edge")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# if not self.show_progress:
# return self.goaltree.q(keys)
# progress_cache: Dict[int, Tuple[int, int]] = {}
# result = self.goaltree.q(keys)
# queue: List[int] = list(result.keys())
# while queue:
# goal_id = queue.pop(0)
# children = [
# x[0] for x in result[goal_id]["edge"] if x[1] == EdgeType.PARENT
# ]
# open_count = 0 if result[goal_id]["open"] else 1
# if not children:
# progress_cache[goal_id] = (open_count, 1)
# elif all(g in progress_cache for g in children):
# progress_cache[goal_id] = (
# sum(progress_cache[x][0] for x in children) + open_count,
# sum(progress_cache[x][1] for x in children) + 1,
# )
# else:
# queue.append(goal_id)
#
# for goal_id, attr in result.items():
# progress = progress_cache[goal_id]
# old_name = attr["name"]
# attr["name"] = f"[{progress[0]}/{progress[1]}] {old_name}"
#
# return result
#
# class ToggleProgress(Command):
# pass
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
. Output only the next line. | 4: {"name": "[0/1] Top goal"}, |
Predict the next line for this snippet: <|code_start|>
@fixture
def goaltree():
return ProgressView(
build_goaltree(
open_(1, "Root", [2, 3], select=selected),
open_(2, "With blocker", [], [4]),
open_(3, "With subgoal", [4]),
open_(4, "Top goal"),
<|code_end|>
with the help of current file imports:
from _pytest.fixtures import fixture
from siebenapp.domain import Select, ToggleClose
from siebenapp.progress_view import ProgressView, ToggleProgress
from siebenapp.tests.dsl import build_goaltree, selected, open_
and context from other files:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# Path: siebenapp/progress_view.py
# class ProgressView(Graph):
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self.show_progress = False
#
# def accept_ToggleProgress(self, command: ToggleProgress) -> None:
# self.show_progress = not self.show_progress
#
# def settings(self, key: str) -> Any:
# if key == "filter_progress":
# return self.show_progress
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# self.show_progress = origin.settings("filter_progress")
#
# @with_key("name")
# @with_key("open")
# @with_key("edge")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# if not self.show_progress:
# return self.goaltree.q(keys)
# progress_cache: Dict[int, Tuple[int, int]] = {}
# result = self.goaltree.q(keys)
# queue: List[int] = list(result.keys())
# while queue:
# goal_id = queue.pop(0)
# children = [
# x[0] for x in result[goal_id]["edge"] if x[1] == EdgeType.PARENT
# ]
# open_count = 0 if result[goal_id]["open"] else 1
# if not children:
# progress_cache[goal_id] = (open_count, 1)
# elif all(g in progress_cache for g in children):
# progress_cache[goal_id] = (
# sum(progress_cache[x][0] for x in children) + open_count,
# sum(progress_cache[x][1] for x in children) + 1,
# )
# else:
# queue.append(goal_id)
#
# for goal_id, attr in result.items():
# progress = progress_cache[goal_id]
# old_name = attr["name"]
# attr["name"] = f"[{progress[0]}/{progress[1]}] {old_name}"
#
# return result
#
# class ToggleProgress(Command):
# pass
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
, which may contain function names, class names, or code. Output only the next line. | ) |
Continue the code snippet: <|code_start|>
@fixture
def goaltree():
return ProgressView(
build_goaltree(
open_(1, "Root", [2, 3], select=selected),
open_(2, "With blocker", [], [4]),
open_(3, "With subgoal", [4]),
open_(4, "Top goal"),
)
)
def test_no_progress_by_default(goaltree):
assert goaltree.q("name") == {
<|code_end|>
. Use current file imports:
from _pytest.fixtures import fixture
from siebenapp.domain import Select, ToggleClose
from siebenapp.progress_view import ProgressView, ToggleProgress
from siebenapp.tests.dsl import build_goaltree, selected, open_
and context (classes, functions, or code) from other files:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# Path: siebenapp/progress_view.py
# class ProgressView(Graph):
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self.show_progress = False
#
# def accept_ToggleProgress(self, command: ToggleProgress) -> None:
# self.show_progress = not self.show_progress
#
# def settings(self, key: str) -> Any:
# if key == "filter_progress":
# return self.show_progress
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# self.show_progress = origin.settings("filter_progress")
#
# @with_key("name")
# @with_key("open")
# @with_key("edge")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# if not self.show_progress:
# return self.goaltree.q(keys)
# progress_cache: Dict[int, Tuple[int, int]] = {}
# result = self.goaltree.q(keys)
# queue: List[int] = list(result.keys())
# while queue:
# goal_id = queue.pop(0)
# children = [
# x[0] for x in result[goal_id]["edge"] if x[1] == EdgeType.PARENT
# ]
# open_count = 0 if result[goal_id]["open"] else 1
# if not children:
# progress_cache[goal_id] = (open_count, 1)
# elif all(g in progress_cache for g in children):
# progress_cache[goal_id] = (
# sum(progress_cache[x][0] for x in children) + open_count,
# sum(progress_cache[x][1] for x in children) + 1,
# )
# else:
# queue.append(goal_id)
#
# for goal_id, attr in result.items():
# progress = progress_cache[goal_id]
# old_name = attr["name"]
# attr["name"] = f"[{progress[0]}/{progress[1]}] {old_name}"
#
# return result
#
# class ToggleProgress(Command):
# pass
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
. Output only the next line. | 1: {"name": "Root"}, |
Predict the next line for this snippet: <|code_start|>
@dataclass(frozen=True)
class ToggleProgress(Command):
pass
class ProgressView(Graph):
def __init__(self, goaltree: Graph):
super().__init__(goaltree)
self.show_progress = False
def accept_ToggleProgress(self, command: ToggleProgress) -> None:
self.show_progress = not self.show_progress
def settings(self, key: str) -> Any:
if key == "filter_progress":
return self.show_progress
return self.goaltree.settings(key)
def reconfigure_from(self, origin: "Graph") -> None:
super().reconfigure_from(origin)
self.show_progress = origin.settings("filter_progress")
@with_key("name")
@with_key("open")
@with_key("edge")
def q(self, keys: str = "name") -> Dict[int, Any]:
<|code_end|>
with the help of current file imports:
from dataclasses import dataclass
from typing import Dict, Any, Tuple, List
from siebenapp.domain import Graph, Command, with_key, EdgeType
and context from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class Command:
# pass
#
# def with_key(key):
# """Wraps around Graph.q, adding given key to the request"""
#
# def inner(q):
# @wraps(q)
# def wrapper(self, keys="name"):
# if no_key := key not in keys:
# keys = ",".join([keys, key])
# result = q(self, keys)
# if no_key:
# for v in result.values():
# v.pop(key, None)
# return result
#
# return wrapper
#
# return inner
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
, which may contain function names, class names, or code. Output only the next line. | if not self.show_progress: |
Given snippet: <|code_start|>
@dataclass(frozen=True)
class ToggleProgress(Command):
pass
class ProgressView(Graph):
def __init__(self, goaltree: Graph):
super().__init__(goaltree)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from dataclasses import dataclass
from typing import Dict, Any, Tuple, List
from siebenapp.domain import Graph, Command, with_key, EdgeType
and context:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class Command:
# pass
#
# def with_key(key):
# """Wraps around Graph.q, adding given key to the request"""
#
# def inner(q):
# @wraps(q)
# def wrapper(self, keys="name"):
# if no_key := key not in keys:
# keys = ",".join([keys, key])
# result = q(self, keys)
# if no_key:
# for v in result.values():
# v.pop(key, None)
# return result
#
# return wrapper
#
# return inner
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
which might include code, classes, or functions. Output only the next line. | self.show_progress = False |
Next line prediction: <|code_start|>
@dataclass(frozen=True)
class ToggleProgress(Command):
pass
class ProgressView(Graph):
def __init__(self, goaltree: Graph):
super().__init__(goaltree)
self.show_progress = False
def accept_ToggleProgress(self, command: ToggleProgress) -> None:
self.show_progress = not self.show_progress
def settings(self, key: str) -> Any:
if key == "filter_progress":
return self.show_progress
return self.goaltree.settings(key)
def reconfigure_from(self, origin: "Graph") -> None:
<|code_end|>
. Use current file imports:
(from dataclasses import dataclass
from typing import Dict, Any, Tuple, List
from siebenapp.domain import Graph, Command, with_key, EdgeType)
and context including class names, function names, or small code snippets from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class Command:
# pass
#
# def with_key(key):
# """Wraps around Graph.q, adding given key to the request"""
#
# def inner(q):
# @wraps(q)
# def wrapper(self, keys="name"):
# if no_key := key not in keys:
# keys = ",".join([keys, key])
# result = q(self, keys)
# if no_key:
# for v in result.values():
# v.pop(key, None)
# return result
#
# return wrapper
#
# return inner
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
. Output only the next line. | super().reconfigure_from(origin) |
Given the following code snippet before the placeholder: <|code_start|>
@dataclass(frozen=True)
class ToggleSwitchableView(Command):
"""Switch between "only switchable goals" and "all goals" views"""
class SwitchableView(Graph):
"""Non-persistent layer that allows to
show only switchable and/or selected goals"""
def __init__(self, goaltree: Graph):
<|code_end|>
, predict the next line using imports from the current file:
from dataclasses import dataclass
from typing import Dict, Any
from siebenapp.domain import Command, Graph, with_key
and context including class names, function names, and sometimes code from other files:
# Path: siebenapp/domain.py
# class Command:
# pass
#
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# def with_key(key):
# """Wraps around Graph.q, adding given key to the request"""
#
# def inner(q):
# @wraps(q)
# def wrapper(self, keys="name"):
# if no_key := key not in keys:
# keys = ",".join([keys, key])
# result = q(self, keys)
# if no_key:
# for v in result.values():
# v.pop(key, None)
# return result
#
# return wrapper
#
# return inner
. Output only the next line. | super().__init__(goaltree) |
Given snippet: <|code_start|>
@dataclass(frozen=True)
class ToggleSwitchableView(Command):
"""Switch between "only switchable goals" and "all goals" views"""
class SwitchableView(Graph):
"""Non-persistent layer that allows to
show only switchable and/or selected goals"""
def __init__(self, goaltree: Graph):
super().__init__(goaltree)
self._only_switchable: bool = False
def accept_ToggleSwitchableView(self, command: ToggleSwitchableView):
self._only_switchable = not self._only_switchable
def settings(self, key: str) -> Any:
if key == "filter_switchable":
return self._only_switchable
return self.goaltree.settings(key)
def reconfigure_from(self, origin: "Graph") -> None:
super().reconfigure_from(origin)
if origin.settings("filter_switchable"):
self.accept(ToggleSwitchableView())
@with_key("switchable")
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from dataclasses import dataclass
from typing import Dict, Any
from siebenapp.domain import Command, Graph, with_key
and context:
# Path: siebenapp/domain.py
# class Command:
# pass
#
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# def with_key(key):
# """Wraps around Graph.q, adding given key to the request"""
#
# def inner(q):
# @wraps(q)
# def wrapper(self, keys="name"):
# if no_key := key not in keys:
# keys = ",".join([keys, key])
# result = q(self, keys)
# if no_key:
# for v in result.values():
# v.pop(key, None)
# return result
#
# return wrapper
#
# return inner
which might include code, classes, or functions. Output only the next line. | def q(self, keys: str = "name") -> Dict[int, Any]: |
Next line prediction: <|code_start|>
@dataclass(frozen=True)
class ToggleSwitchableView(Command):
"""Switch between "only switchable goals" and "all goals" views"""
class SwitchableView(Graph):
"""Non-persistent layer that allows to
show only switchable and/or selected goals"""
def __init__(self, goaltree: Graph):
super().__init__(goaltree)
self._only_switchable: bool = False
def accept_ToggleSwitchableView(self, command: ToggleSwitchableView):
self._only_switchable = not self._only_switchable
def settings(self, key: str) -> Any:
if key == "filter_switchable":
<|code_end|>
. Use current file imports:
(from dataclasses import dataclass
from typing import Dict, Any
from siebenapp.domain import Command, Graph, with_key)
and context including class names, function names, or small code snippets from other files:
# Path: siebenapp/domain.py
# class Command:
# pass
#
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# def with_key(key):
# """Wraps around Graph.q, adding given key to the request"""
#
# def inner(q):
# @wraps(q)
# def wrapper(self, keys="name"):
# if no_key := key not in keys:
# keys = ",".join([keys, key])
# result = q(self, keys)
# if no_key:
# for v in result.values():
# v.pop(key, None)
# return result
#
# return wrapper
#
# return inner
. Output only the next line. | return self._only_switchable |
Continue the code snippet: <|code_start|> for row_vals in result_index.values():
left: int = 0
edges: List[str] = []
phase: str = "goals"
for _, new_goal_id in sorted(row_vals.items(), key=lambda x: x[0]):
if isinstance(new_goal_id, int):
if phase == "edges":
self._write_edges(edges, left)
edges = []
phase = "goals"
left = new_goal_id
else:
phase = "edges"
edges.append(new_goal_id)
self._write_edges(edges, left)
def _write_edges(self, edges: List[str], left: int) -> None:
self.result_edge_options.update(
{e: (left, i + 1, len(edges) + 1) for i, e in enumerate(edges)}
)
def place(self, source: Dict[GoalId, int]) -> Layer:
result: Layer = []
unplaced: List[Tuple[GoalId, int]] = sorted(list(source.items()), key=goal_key)
while unplaced:
value, index = unplaced.pop(0)
if len(result) < index + 1:
result.extend([None] * (index + 1 - len(result)))
if result[index] is None:
<|code_end|>
. Use current file imports:
from collections import defaultdict
from dataclasses import dataclass
from typing import Dict, List, Tuple, Union, Any, Set, Optional, Protocol
from siebenapp.domain import Graph, EdgeType
and context (classes, functions, or code) from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
. Output only the next line. | result[index] = value |
Continue the code snippet: <|code_start|> new_layer.append(new_goal_name)
sorted_goals.add(new_goal_name)
self.layers[current_layer] = new_layer
current_layer += 1
incoming_edges.update(outgoing_edges)
outgoing_edges.clear()
self.positions = {
g: idx
for layer in self.layers.values()
for idx, g in enumerate(layer)
if g is not None
}
@staticmethod
def candidates_for_new_layer(
sorted_goals: Set[GoalId], unsorted_goals: Dict[GoalId, List[GoalId]]
) -> List[Tuple[GoalId, int]]:
candidates: List[Tuple[GoalId, int]] = [
(goal, len(edges))
for goal, edges in unsorted_goals.items()
if all(v in sorted_goals for v in edges)
]
candidates.sort(key=lambda x: x[1], reverse=True)
return candidates
def reorder(self) -> None:
for curr_layer in sorted(self.layers.keys(), reverse=True)[:-1]:
fixed_line: Layer = self.layers[curr_layer]
random_line: Layer = self.layers[curr_layer - 1]
deltas: Dict[GoalId, int] = self.count_deltas(fixed_line)
<|code_end|>
. Use current file imports:
from collections import defaultdict
from dataclasses import dataclass
from typing import Dict, List, Tuple, Union, Any, Set, Optional, Protocol
from siebenapp.domain import Graph, EdgeType
and context (classes, functions, or code) from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
. Output only the next line. | new_positions: Dict[GoalId, int] = { |
Next line prediction: <|code_start|> "2",
"a Build simple test",
"3",
"c",
]
io = DummyIO(commands, log)
db_name = ":memory:"
goals = load(db_name, update_message)
loop(io, goals, db_name)
verify("\n".join(log), reporter=GenericDiffReporterFactory().get_first_working())
def test_complex_scenario():
log = []
commands = [
"r Cover all current features",
"a Filter view",
"a Toggle show open/closed goals",
"a Toggle show goal progress",
"a Toggle show switchable goals",
"a Toggle zoom and unzoom",
"2",
"h",
"6",
"l",
"2",
"z",
"2",
"c",
"z",
<|code_end|>
. Use current file imports:
(from typing import List
from approvaltests import verify, Options # type: ignore
from approvaltests.reporters import GenericDiffReporterFactory # type: ignore
from approvaltests.reporters.generic_diff_reporter import GenericDiffReporter # type: ignore
from siebenapp.cli import IO, update_message, loop
from siebenapp.system import load)
and context including class names, function names, or small code snippets from other files:
# Path: siebenapp/cli.py
# class IO:
# """Simple wrapper for all input/output interactions"""
#
# def write(self, text: str, *args) -> None:
# raise NotImplementedError
#
# def read(self) -> str:
# raise NotImplementedError
#
# def update_message(message=""):
# global USER_MESSAGE
# USER_MESSAGE = message
#
# def loop(io: IO, goals: Graph, db_name: str):
# cmd = ""
# while cmd != "q":
# render_result = Renderer(goals, 100).build()
# rows = render_result.graph
# index = sorted(
# [
# (goal_id, goal_vars["row"], goal_vars["col"])
# for goal_id, goal_vars in rows.items()
# if isinstance(goal_id, int)
# ],
# key=itemgetter(1, 2),
# reverse=True,
# )
# id_width = len(str(max(g for g in rows.keys() if isinstance(g, int))))
# for item in index:
# goal_id = item[0]
# goal_vars = rows[goal_id]
# io.write(fmt(goal_id, goal_vars, id_width))
# if USER_MESSAGE:
# io.write(USER_MESSAGE)
# update_message()
# try:
# cmd = io.read().strip()
# except EOFError:
# break
# actions = build_actions(cmd)
# if actions:
# goals.accept_all(*actions)
# save(goals, db_name)
#
# Path: siebenapp/system.py
# def load(filename: str, message_fn: Callable[[str], None] = None) -> Enumeration:
# zoom_data: ZoomData = []
# autolink_data: AutoLinkData = []
# if path.isfile(filename):
# connection = sqlite3.connect(filename)
# run_migrations(connection)
# cur = connection.cursor()
# names = list(cur.execute("select * from goals"))
# edges = list(cur.execute("select parent, child, reltype from edges"))
# settings = list(cur.execute("select * from settings"))
# zoom_data = list(cur.execute("select * from zoom"))
# autolink_data = list(cur.execute("select * from autolink"))
# cur.close()
# goals = Goals.build(names, edges, settings, message_fn)
# else:
# goals = Goals("Rename me", message_fn)
# result = Enumeration(all_layers(goals, zoom_data, autolink_data))
# result.verify()
# return result
. Output only the next line. | "f Toggle", |
Predict the next line after this snippet: <|code_start|> verify("\n".join(log), reporter=GenericDiffReporterFactory().get_first_working())
def test_complex_scenario():
log = []
commands = [
"r Cover all current features",
"a Filter view",
"a Toggle show open/closed goals",
"a Toggle show goal progress",
"a Toggle show switchable goals",
"a Toggle zoom and unzoom",
"2",
"h",
"6",
"l",
"2",
"z",
"2",
"c",
"z",
"f Toggle",
"n",
"2",
"c",
"f",
"p",
"t",
"n",
"t",
<|code_end|>
using the current file's imports:
from typing import List
from approvaltests import verify, Options # type: ignore
from approvaltests.reporters import GenericDiffReporterFactory # type: ignore
from approvaltests.reporters.generic_diff_reporter import GenericDiffReporter # type: ignore
from siebenapp.cli import IO, update_message, loop
from siebenapp.system import load
and any relevant context from other files:
# Path: siebenapp/cli.py
# class IO:
# """Simple wrapper for all input/output interactions"""
#
# def write(self, text: str, *args) -> None:
# raise NotImplementedError
#
# def read(self) -> str:
# raise NotImplementedError
#
# def update_message(message=""):
# global USER_MESSAGE
# USER_MESSAGE = message
#
# def loop(io: IO, goals: Graph, db_name: str):
# cmd = ""
# while cmd != "q":
# render_result = Renderer(goals, 100).build()
# rows = render_result.graph
# index = sorted(
# [
# (goal_id, goal_vars["row"], goal_vars["col"])
# for goal_id, goal_vars in rows.items()
# if isinstance(goal_id, int)
# ],
# key=itemgetter(1, 2),
# reverse=True,
# )
# id_width = len(str(max(g for g in rows.keys() if isinstance(g, int))))
# for item in index:
# goal_id = item[0]
# goal_vars = rows[goal_id]
# io.write(fmt(goal_id, goal_vars, id_width))
# if USER_MESSAGE:
# io.write(USER_MESSAGE)
# update_message()
# try:
# cmd = io.read().strip()
# except EOFError:
# break
# actions = build_actions(cmd)
# if actions:
# goals.accept_all(*actions)
# save(goals, db_name)
#
# Path: siebenapp/system.py
# def load(filename: str, message_fn: Callable[[str], None] = None) -> Enumeration:
# zoom_data: ZoomData = []
# autolink_data: AutoLinkData = []
# if path.isfile(filename):
# connection = sqlite3.connect(filename)
# run_migrations(connection)
# cur = connection.cursor()
# names = list(cur.execute("select * from goals"))
# edges = list(cur.execute("select parent, child, reltype from edges"))
# settings = list(cur.execute("select * from settings"))
# zoom_data = list(cur.execute("select * from zoom"))
# autolink_data = list(cur.execute("select * from autolink"))
# cur.close()
# goals = Goals.build(names, edges, settings, message_fn)
# else:
# goals = Goals("Rename me", message_fn)
# result = Enumeration(all_layers(goals, zoom_data, autolink_data))
# result.verify()
# return result
. Output only the next line. | "4", |
Given the code snippet: <|code_start|> return command
self.log.append("*USER BREAK*")
raise EOFError("Commands list is empty")
def test_simple_scenario():
log = []
commands = [
"r Approval testing",
"a Measure coverage",
"2",
"a Build simple test",
"3",
"c",
]
io = DummyIO(commands, log)
db_name = ":memory:"
goals = load(db_name, update_message)
loop(io, goals, db_name)
verify("\n".join(log), reporter=GenericDiffReporterFactory().get_first_working())
def test_complex_scenario():
log = []
commands = [
"r Cover all current features",
"a Filter view",
"a Toggle show open/closed goals",
"a Toggle show goal progress",
"a Toggle show switchable goals",
<|code_end|>
, generate the next line using the imports in this file:
from typing import List
from approvaltests import verify, Options # type: ignore
from approvaltests.reporters import GenericDiffReporterFactory # type: ignore
from approvaltests.reporters.generic_diff_reporter import GenericDiffReporter # type: ignore
from siebenapp.cli import IO, update_message, loop
from siebenapp.system import load
and context (functions, classes, or occasionally code) from other files:
# Path: siebenapp/cli.py
# class IO:
# """Simple wrapper for all input/output interactions"""
#
# def write(self, text: str, *args) -> None:
# raise NotImplementedError
#
# def read(self) -> str:
# raise NotImplementedError
#
# def update_message(message=""):
# global USER_MESSAGE
# USER_MESSAGE = message
#
# def loop(io: IO, goals: Graph, db_name: str):
# cmd = ""
# while cmd != "q":
# render_result = Renderer(goals, 100).build()
# rows = render_result.graph
# index = sorted(
# [
# (goal_id, goal_vars["row"], goal_vars["col"])
# for goal_id, goal_vars in rows.items()
# if isinstance(goal_id, int)
# ],
# key=itemgetter(1, 2),
# reverse=True,
# )
# id_width = len(str(max(g for g in rows.keys() if isinstance(g, int))))
# for item in index:
# goal_id = item[0]
# goal_vars = rows[goal_id]
# io.write(fmt(goal_id, goal_vars, id_width))
# if USER_MESSAGE:
# io.write(USER_MESSAGE)
# update_message()
# try:
# cmd = io.read().strip()
# except EOFError:
# break
# actions = build_actions(cmd)
# if actions:
# goals.accept_all(*actions)
# save(goals, db_name)
#
# Path: siebenapp/system.py
# def load(filename: str, message_fn: Callable[[str], None] = None) -> Enumeration:
# zoom_data: ZoomData = []
# autolink_data: AutoLinkData = []
# if path.isfile(filename):
# connection = sqlite3.connect(filename)
# run_migrations(connection)
# cur = connection.cursor()
# names = list(cur.execute("select * from goals"))
# edges = list(cur.execute("select parent, child, reltype from edges"))
# settings = list(cur.execute("select * from settings"))
# zoom_data = list(cur.execute("select * from zoom"))
# autolink_data = list(cur.execute("select * from autolink"))
# cur.close()
# goals = Goals.build(names, edges, settings, message_fn)
# else:
# goals = Goals("Rename me", message_fn)
# result = Enumeration(all_layers(goals, zoom_data, autolink_data))
# result.verify()
# return result
. Output only the next line. | "a Toggle zoom and unzoom", |
Given the code snippet: <|code_start|> log = []
commands = [
"r Approval testing",
"a Measure coverage",
"2",
"a Build simple test",
"3",
"c",
]
io = DummyIO(commands, log)
db_name = ":memory:"
goals = load(db_name, update_message)
loop(io, goals, db_name)
verify("\n".join(log), reporter=GenericDiffReporterFactory().get_first_working())
def test_complex_scenario():
log = []
commands = [
"r Cover all current features",
"a Filter view",
"a Toggle show open/closed goals",
"a Toggle show goal progress",
"a Toggle show switchable goals",
"a Toggle zoom and unzoom",
"2",
"h",
"6",
"l",
"2",
<|code_end|>
, generate the next line using the imports in this file:
from typing import List
from approvaltests import verify, Options # type: ignore
from approvaltests.reporters import GenericDiffReporterFactory # type: ignore
from approvaltests.reporters.generic_diff_reporter import GenericDiffReporter # type: ignore
from siebenapp.cli import IO, update_message, loop
from siebenapp.system import load
and context (functions, classes, or occasionally code) from other files:
# Path: siebenapp/cli.py
# class IO:
# """Simple wrapper for all input/output interactions"""
#
# def write(self, text: str, *args) -> None:
# raise NotImplementedError
#
# def read(self) -> str:
# raise NotImplementedError
#
# def update_message(message=""):
# global USER_MESSAGE
# USER_MESSAGE = message
#
# def loop(io: IO, goals: Graph, db_name: str):
# cmd = ""
# while cmd != "q":
# render_result = Renderer(goals, 100).build()
# rows = render_result.graph
# index = sorted(
# [
# (goal_id, goal_vars["row"], goal_vars["col"])
# for goal_id, goal_vars in rows.items()
# if isinstance(goal_id, int)
# ],
# key=itemgetter(1, 2),
# reverse=True,
# )
# id_width = len(str(max(g for g in rows.keys() if isinstance(g, int))))
# for item in index:
# goal_id = item[0]
# goal_vars = rows[goal_id]
# io.write(fmt(goal_id, goal_vars, id_width))
# if USER_MESSAGE:
# io.write(USER_MESSAGE)
# update_message()
# try:
# cmd = io.read().strip()
# except EOFError:
# break
# actions = build_actions(cmd)
# if actions:
# goals.accept_all(*actions)
# save(goals, db_name)
#
# Path: siebenapp/system.py
# def load(filename: str, message_fn: Callable[[str], None] = None) -> Enumeration:
# zoom_data: ZoomData = []
# autolink_data: AutoLinkData = []
# if path.isfile(filename):
# connection = sqlite3.connect(filename)
# run_migrations(connection)
# cur = connection.cursor()
# names = list(cur.execute("select * from goals"))
# edges = list(cur.execute("select parent, child, reltype from edges"))
# settings = list(cur.execute("select * from settings"))
# zoom_data = list(cur.execute("select * from zoom"))
# autolink_data = list(cur.execute("select * from autolink"))
# cur.close()
# goals = Goals.build(names, edges, settings, message_fn)
# else:
# goals = Goals("Rename me", message_fn)
# result = Enumeration(all_layers(goals, zoom_data, autolink_data))
# result.verify()
# return result
. Output only the next line. | "z", |
Given snippet: <|code_start|> # type: (GoalsData, EdgesData, OptionsData, Callable[[str], None]) -> Goals
result = Goals("", message_fn)
result._events.clear()
goals_dict = {g[0]: g[1] for g in goals}
result.goals = {
i: goals_dict.get(i) for i in range(1, max(goals_dict.keys()) + 1)
}
result.closed = {g[0] for g in goals if not g[2]}.union(
{k for k, v in result.goals.items() if v is None}
)
for parent, child, link_type in edges:
result.edges[parent, child] = EdgeType(link_type)
result.edges_forward[parent][child] = EdgeType(link_type)
result.edges_backward[child][parent] = EdgeType(link_type)
selection_dict = dict(settings)
result.selection = selection_dict.get("selection", result.selection)
result.previous_selection = selection_dict.get(
"previous_selection", result.previous_selection
)
result.verify()
return result
@staticmethod
def export(goals):
# type: (Goals) -> Tuple[GoalsData, EdgesData, OptionsData]
nodes = [
(g_id, g_name, g_id not in goals.closed)
for g_id, g_name in goals.goals.items()
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from typing import Callable, Dict, Optional, List, Set, Any, Tuple
from collections import deque, defaultdict
from siebenapp.domain import (
Graph,
EdgeType,
Edge,
HoldSelect,
ToggleClose,
Delete,
ToggleLink,
Add,
Select,
Insert,
Rename,
)
and context:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class Edge:
# source: int
# target: int
# type: EdgeType
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class Delete(Command):
# """Remove given or selected goal whether it exists. Do nothing in other case"""
#
# goal_id: int = 0
#
# class ToggleLink(Command):
# """Create or remove a link between two given goals, if possible"""
#
# lower: int = 0
# upper: int = 0
# edge_type: EdgeType = EdgeType.BLOCKER
#
# class Add(Command):
# """Add a new goal to the existing tree"""
#
# name: str
# add_to: int = 0
# edge_type: EdgeType = EdgeType.PARENT
#
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class Insert(Command):
# """Add an intermediate goal between two selected goals"""
#
# name: str
#
# class Rename(Command):
# """Change a name of the given goal"""
#
# new_name: str
# goal_id: int = 0
which might include code, classes, or functions. Output only the next line. | ] |
Given the following code snippet before the placeholder: <|code_start|> Select(self._first_open_and_switchable(command.root))
)
self.accept(HoldSelect())
else:
self.error("This goal can't be closed because it have open subgoals")
def _may_be_closed(self) -> bool:
return all(g.target in self.closed for g in self._forward_edges(self.selection))
def _may_be_reopened(self) -> bool:
blocked_by_selected = [e.source for e in self._back_edges(self.selection)]
return all(g not in self.closed for g in blocked_by_selected)
def _first_open_and_switchable(self, root: int) -> int:
root = max(root, Goals.ROOT_ID)
front = [root]
candidates: List[int] = []
while front:
next_goal = front.pop()
subgoals = [
e.target
for e in self._forward_edges(next_goal)
if e.target not in self.closed and e.type == EdgeType.PARENT
]
front.extend(subgoals)
candidates.extend(g for g in subgoals if self._switchable(g))
return min(candidates) if candidates else root
def accept_Delete(self, command: Delete) -> None:
if (goal_id := command.goal_id or self.selection) == Goals.ROOT_ID:
<|code_end|>
, predict the next line using imports from the current file:
from typing import Callable, Dict, Optional, List, Set, Any, Tuple
from collections import deque, defaultdict
from siebenapp.domain import (
Graph,
EdgeType,
Edge,
HoldSelect,
ToggleClose,
Delete,
ToggleLink,
Add,
Select,
Insert,
Rename,
)
and context including class names, function names, and sometimes code from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class Edge:
# source: int
# target: int
# type: EdgeType
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class Delete(Command):
# """Remove given or selected goal whether it exists. Do nothing in other case"""
#
# goal_id: int = 0
#
# class ToggleLink(Command):
# """Create or remove a link between two given goals, if possible"""
#
# lower: int = 0
# upper: int = 0
# edge_type: EdgeType = EdgeType.BLOCKER
#
# class Add(Command):
# """Add a new goal to the existing tree"""
#
# name: str
# add_to: int = 0
# edge_type: EdgeType = EdgeType.PARENT
#
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class Insert(Command):
# """Add an intermediate goal between two selected goals"""
#
# name: str
#
# class Rename(Command):
# """Change a name of the given goal"""
#
# new_name: str
# goal_id: int = 0
. Output only the next line. | self.error("Root goal can't be deleted") |
Predict the next line after this snippet: <|code_start|># coding: utf-8
GoalsData = List[Tuple[int, Optional[str], bool]]
EdgesData = List[Tuple[int, int, EdgeType]]
OptionsData = List[Tuple[str, int]]
class Goals(Graph):
ROOT_ID = 1
def __init__(self, name: str, message_fn: Callable[[str], None] = None) -> None:
super().__init__()
self.goals: Dict[int, Optional[str]] = {}
self.edges: Dict[Tuple[int, int], EdgeType] = {}
self.edges_forward: Dict[int, Dict[int, EdgeType]] = defaultdict(
lambda: defaultdict(lambda: EdgeType.BLOCKER)
)
self.edges_backward: Dict[int, Dict[int, EdgeType]] = defaultdict(
lambda: defaultdict(lambda: EdgeType.BLOCKER)
)
self.closed: Set[int] = set()
self.selection = Goals.ROOT_ID
self.previous_selection = Goals.ROOT_ID
self._events: deque = deque()
self.message_fn = message_fn
self._add_no_link(name)
def error(self, message: str) -> None:
<|code_end|>
using the current file's imports:
from typing import Callable, Dict, Optional, List, Set, Any, Tuple
from collections import deque, defaultdict
from siebenapp.domain import (
Graph,
EdgeType,
Edge,
HoldSelect,
ToggleClose,
Delete,
ToggleLink,
Add,
Select,
Insert,
Rename,
)
and any relevant context from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class Edge:
# source: int
# target: int
# type: EdgeType
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class Delete(Command):
# """Remove given or selected goal whether it exists. Do nothing in other case"""
#
# goal_id: int = 0
#
# class ToggleLink(Command):
# """Create or remove a link between two given goals, if possible"""
#
# lower: int = 0
# upper: int = 0
# edge_type: EdgeType = EdgeType.BLOCKER
#
# class Add(Command):
# """Add a new goal to the existing tree"""
#
# name: str
# add_to: int = 0
# edge_type: EdgeType = EdgeType.PARENT
#
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class Insert(Command):
# """Add an intermediate goal between two selected goals"""
#
# name: str
#
# class Rename(Command):
# """Change a name of the given goal"""
#
# new_name: str
# goal_id: int = 0
. Output only the next line. | if self.message_fn: |
Continue the code snippet: <|code_start|> return all(g.target in self.closed for g in self._forward_edges(self.selection))
def _may_be_reopened(self) -> bool:
blocked_by_selected = [e.source for e in self._back_edges(self.selection)]
return all(g not in self.closed for g in blocked_by_selected)
def _first_open_and_switchable(self, root: int) -> int:
root = max(root, Goals.ROOT_ID)
front = [root]
candidates: List[int] = []
while front:
next_goal = front.pop()
subgoals = [
e.target
for e in self._forward_edges(next_goal)
if e.target not in self.closed and e.type == EdgeType.PARENT
]
front.extend(subgoals)
candidates.extend(g for g in subgoals if self._switchable(g))
return min(candidates) if candidates else root
def accept_Delete(self, command: Delete) -> None:
if (goal_id := command.goal_id or self.selection) == Goals.ROOT_ID:
self.error("Root goal can't be deleted")
return
parent = self._parent(goal_id)
self._delete_subtree(goal_id)
self.accept_Select(Select(parent))
self.accept(HoldSelect())
<|code_end|>
. Use current file imports:
from typing import Callable, Dict, Optional, List, Set, Any, Tuple
from collections import deque, defaultdict
from siebenapp.domain import (
Graph,
EdgeType,
Edge,
HoldSelect,
ToggleClose,
Delete,
ToggleLink,
Add,
Select,
Insert,
Rename,
)
and context (classes, functions, or code) from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class Edge:
# source: int
# target: int
# type: EdgeType
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class Delete(Command):
# """Remove given or selected goal whether it exists. Do nothing in other case"""
#
# goal_id: int = 0
#
# class ToggleLink(Command):
# """Create or remove a link between two given goals, if possible"""
#
# lower: int = 0
# upper: int = 0
# edge_type: EdgeType = EdgeType.BLOCKER
#
# class Add(Command):
# """Add a new goal to the existing tree"""
#
# name: str
# add_to: int = 0
# edge_type: EdgeType = EdgeType.PARENT
#
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class Insert(Command):
# """Add an intermediate goal between two selected goals"""
#
# name: str
#
# class Rename(Command):
# """Change a name of the given goal"""
#
# new_name: str
# goal_id: int = 0
. Output only the next line. | def _delete_subtree(self, goal_id: int) -> None: |
Here is a snippet: <|code_start|> e.target
for e in self._forward_edges(next_goal)
if e.target not in self.closed and e.type == EdgeType.PARENT
]
front.extend(subgoals)
candidates.extend(g for g in subgoals if self._switchable(g))
return min(candidates) if candidates else root
def accept_Delete(self, command: Delete) -> None:
if (goal_id := command.goal_id or self.selection) == Goals.ROOT_ID:
self.error("Root goal can't be deleted")
return
parent = self._parent(goal_id)
self._delete_subtree(goal_id)
self.accept_Select(Select(parent))
self.accept(HoldSelect())
def _delete_subtree(self, goal_id: int) -> None:
parent = self._parent(goal_id)
self.goals[goal_id] = None
self.closed.add(goal_id)
forward_edges = self._forward_edges(goal_id)
next_to_remove = {e for e in forward_edges if e.type == EdgeType.PARENT}
blockers = {e for e in forward_edges if e.type == EdgeType.BLOCKER}
for back_edge in self._back_edges(goal_id):
self.edges_forward[back_edge.source].pop(goal_id)
self.edges_forward[goal_id].clear()
for forward_edge in forward_edges:
self.edges_backward[forward_edge.target].pop(goal_id)
self.edges_backward[goal_id].clear()
<|code_end|>
. Write the next line using the current file imports:
from typing import Callable, Dict, Optional, List, Set, Any, Tuple
from collections import deque, defaultdict
from siebenapp.domain import (
Graph,
EdgeType,
Edge,
HoldSelect,
ToggleClose,
Delete,
ToggleLink,
Add,
Select,
Insert,
Rename,
)
and context from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class Edge:
# source: int
# target: int
# type: EdgeType
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class Delete(Command):
# """Remove given or selected goal whether it exists. Do nothing in other case"""
#
# goal_id: int = 0
#
# class ToggleLink(Command):
# """Create or remove a link between two given goals, if possible"""
#
# lower: int = 0
# upper: int = 0
# edge_type: EdgeType = EdgeType.BLOCKER
#
# class Add(Command):
# """Add a new goal to the existing tree"""
#
# name: str
# add_to: int = 0
# edge_type: EdgeType = EdgeType.PARENT
#
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class Insert(Command):
# """Add an intermediate goal between two selected goals"""
#
# name: str
#
# class Rename(Command):
# """Change a name of the given goal"""
#
# new_name: str
# goal_id: int = 0
, which may include functions, classes, or code. Output only the next line. | self.edges = {k: v for k, v in self.edges.items() if goal_id not in k} |
Based on the snippet: <|code_start|> def _forward_edges(self, goal: int) -> List[Edge]:
return [Edge(goal, k, v) for k, v in self.edges_forward[goal].items()]
def _back_edges(self, goal: int) -> List[Edge]:
return [Edge(k, goal, v) for k, v in self.edges_backward[goal].items()]
def _parent(self, goal: int) -> int:
parents = {e for e in self._back_edges(goal) if e.type == EdgeType.PARENT}
return parents.pop().source if parents else Goals.ROOT_ID
def settings(self, key: str) -> Any:
return {
"selection": self.selection,
"previous_selection": self.previous_selection,
}.get(key, 0)
def selections(self) -> Set[int]:
return set(
k
for k in [
self.settings("selection"),
self.settings("previous_selection"),
]
if k is not None
)
def events(self) -> deque:
return self._events
def accept_Add(self, command: Add) -> bool:
<|code_end|>
, predict the immediate next line with the help of imports:
from typing import Callable, Dict, Optional, List, Set, Any, Tuple
from collections import deque, defaultdict
from siebenapp.domain import (
Graph,
EdgeType,
Edge,
HoldSelect,
ToggleClose,
Delete,
ToggleLink,
Add,
Select,
Insert,
Rename,
)
and context (classes, functions, sometimes code) from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class Edge:
# source: int
# target: int
# type: EdgeType
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class Delete(Command):
# """Remove given or selected goal whether it exists. Do nothing in other case"""
#
# goal_id: int = 0
#
# class ToggleLink(Command):
# """Create or remove a link between two given goals, if possible"""
#
# lower: int = 0
# upper: int = 0
# edge_type: EdgeType = EdgeType.BLOCKER
#
# class Add(Command):
# """Add a new goal to the existing tree"""
#
# name: str
# add_to: int = 0
# edge_type: EdgeType = EdgeType.PARENT
#
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class Insert(Command):
# """Add an intermediate goal between two selected goals"""
#
# name: str
#
# class Rename(Command):
# """Change a name of the given goal"""
#
# new_name: str
# goal_id: int = 0
. Output only the next line. | add_to = command.add_to or self.selection |
Given the code snippet: <|code_start|> if e not in visited:
front.add(e.target)
return lower in total
def verify(self) -> bool:
assert all(
g.target in self.closed for p in self.closed for g in self._forward_edges(p)
), "Open goals could not be blocked by closed ones"
queue: List[int] = [Goals.ROOT_ID]
visited: Set[int] = set()
while queue:
goal = queue.pop()
queue.extend(
g.target
for g in self._forward_edges(goal)
if g.target not in visited and self.goals[g.target] is not None
)
visited.add(goal)
assert visited == {
x for x in self.goals if self.goals[x] is not None
}, "All subgoals must be accessible from the root goal"
deleted_nodes = [g for g, v in self.goals.items() if v is None]
assert all(
not self._forward_edges(n) for n in deleted_nodes
), "Deleted goals must have no dependencies"
fwd_edges = set(
(g1, g2, et) for g1, e in self.edges_forward.items() for g2, et in e.items()
<|code_end|>
, generate the next line using the imports in this file:
from typing import Callable, Dict, Optional, List, Set, Any, Tuple
from collections import deque, defaultdict
from siebenapp.domain import (
Graph,
EdgeType,
Edge,
HoldSelect,
ToggleClose,
Delete,
ToggleLink,
Add,
Select,
Insert,
Rename,
)
and context (functions, classes, or occasionally code) from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class Edge:
# source: int
# target: int
# type: EdgeType
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class Delete(Command):
# """Remove given or selected goal whether it exists. Do nothing in other case"""
#
# goal_id: int = 0
#
# class ToggleLink(Command):
# """Create or remove a link between two given goals, if possible"""
#
# lower: int = 0
# upper: int = 0
# edge_type: EdgeType = EdgeType.BLOCKER
#
# class Add(Command):
# """Add a new goal to the existing tree"""
#
# name: str
# add_to: int = 0
# edge_type: EdgeType = EdgeType.PARENT
#
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class Insert(Command):
# """Add an intermediate goal between two selected goals"""
#
# name: str
#
# class Rename(Command):
# """Change a name of the given goal"""
#
# new_name: str
# goal_id: int = 0
. Output only the next line. | ) |
Based on the snippet: <|code_start|> self._events.append(("select", goal_id))
def accept_HoldSelect(self, command: HoldSelect):
self.previous_selection = self.selection
self._events.append(("hold_select", self.selection))
def q(self, keys: str = "name") -> Dict[int, Any]:
def sel(x: int) -> Optional[str]:
if x == self.selection:
return "select"
if x == self.previous_selection:
return "prev"
return None
keys_list = keys.split(",")
result: Dict[int, Any] = dict()
for key, name in ((k, n) for k, n in self.goals.items() if n is not None):
value = {
"edge": sorted([(e.target, e.type) for e in self._forward_edges(key)]),
"name": name,
"open": key not in self.closed,
"select": sel(key),
"switchable": self._switchable(key),
}
result[key] = {k: v for k, v in value.items() if k in keys_list}
return result
def _switchable(self, key: int) -> bool:
if key in self.closed:
if back_edges := self._back_edges(key):
<|code_end|>
, predict the immediate next line with the help of imports:
from typing import Callable, Dict, Optional, List, Set, Any, Tuple
from collections import deque, defaultdict
from siebenapp.domain import (
Graph,
EdgeType,
Edge,
HoldSelect,
ToggleClose,
Delete,
ToggleLink,
Add,
Select,
Insert,
Rename,
)
and context (classes, functions, sometimes code) from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class Edge:
# source: int
# target: int
# type: EdgeType
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class Delete(Command):
# """Remove given or selected goal whether it exists. Do nothing in other case"""
#
# goal_id: int = 0
#
# class ToggleLink(Command):
# """Create or remove a link between two given goals, if possible"""
#
# lower: int = 0
# upper: int = 0
# edge_type: EdgeType = EdgeType.BLOCKER
#
# class Add(Command):
# """Add a new goal to the existing tree"""
#
# name: str
# add_to: int = 0
# edge_type: EdgeType = EdgeType.PARENT
#
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class Insert(Command):
# """Add an intermediate goal between two selected goals"""
#
# name: str
#
# class Rename(Command):
# """Change a name of the given goal"""
#
# new_name: str
# goal_id: int = 0
. Output only the next line. | return any(e.source not in self.closed for e in back_edges) |
Given the following code snippet before the placeholder: <|code_start|> g.target
for g in self._forward_edges(goal)
if g.target not in visited and self.goals[g.target] is not None
)
visited.add(goal)
assert visited == {
x for x in self.goals if self.goals[x] is not None
}, "All subgoals must be accessible from the root goal"
deleted_nodes = [g for g, v in self.goals.items() if v is None]
assert all(
not self._forward_edges(n) for n in deleted_nodes
), "Deleted goals must have no dependencies"
fwd_edges = set(
(g1, g2, et) for g1, e in self.edges_forward.items() for g2, et in e.items()
)
bwd_edges = set(
(g1, g2, et)
for g2, e in self.edges_backward.items()
for g1, et in e.items()
)
assert (
fwd_edges == bwd_edges
), "Forward and backward edges must always match each other"
parent_edges = [k for k, v in self.edges.items() if v == EdgeType.PARENT]
edges_with_parent = {child for parent, child in parent_edges}
assert len(parent_edges) == len(
edges_with_parent
<|code_end|>
, predict the next line using imports from the current file:
from typing import Callable, Dict, Optional, List, Set, Any, Tuple
from collections import deque, defaultdict
from siebenapp.domain import (
Graph,
EdgeType,
Edge,
HoldSelect,
ToggleClose,
Delete,
ToggleLink,
Add,
Select,
Insert,
Rename,
)
and context including class names, function names, and sometimes code from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class Edge:
# source: int
# target: int
# type: EdgeType
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class Delete(Command):
# """Remove given or selected goal whether it exists. Do nothing in other case"""
#
# goal_id: int = 0
#
# class ToggleLink(Command):
# """Create or remove a link between two given goals, if possible"""
#
# lower: int = 0
# upper: int = 0
# edge_type: EdgeType = EdgeType.BLOCKER
#
# class Add(Command):
# """Add a new goal to the existing tree"""
#
# name: str
# add_to: int = 0
# edge_type: EdgeType = EdgeType.PARENT
#
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class Insert(Command):
# """Add an intermediate goal between two selected goals"""
#
# name: str
#
# class Rename(Command):
# """Change a name of the given goal"""
#
# new_name: str
# goal_id: int = 0
. Output only the next line. | ), "Each goal must have at most 1 parent" |
Given the following code snippet before the placeholder: <|code_start|> }, "All subgoals must be accessible from the root goal"
deleted_nodes = [g for g, v in self.goals.items() if v is None]
assert all(
not self._forward_edges(n) for n in deleted_nodes
), "Deleted goals must have no dependencies"
fwd_edges = set(
(g1, g2, et) for g1, e in self.edges_forward.items() for g2, et in e.items()
)
bwd_edges = set(
(g1, g2, et)
for g2, e in self.edges_backward.items()
for g1, et in e.items()
)
assert (
fwd_edges == bwd_edges
), "Forward and backward edges must always match each other"
parent_edges = [k for k, v in self.edges.items() if v == EdgeType.PARENT]
edges_with_parent = {child for parent, child in parent_edges}
assert len(parent_edges) == len(
edges_with_parent
), "Each goal must have at most 1 parent"
return True
@staticmethod
def build(goals, edges, settings, message_fn=None):
# type: (GoalsData, EdgesData, OptionsData, Callable[[str], None]) -> Goals
<|code_end|>
, predict the next line using imports from the current file:
from typing import Callable, Dict, Optional, List, Set, Any, Tuple
from collections import deque, defaultdict
from siebenapp.domain import (
Graph,
EdgeType,
Edge,
HoldSelect,
ToggleClose,
Delete,
ToggleLink,
Add,
Select,
Insert,
Rename,
)
and context including class names, function names, and sometimes code from other files:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class Edge:
# source: int
# target: int
# type: EdgeType
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class Delete(Command):
# """Remove given or selected goal whether it exists. Do nothing in other case"""
#
# goal_id: int = 0
#
# class ToggleLink(Command):
# """Create or remove a link between two given goals, if possible"""
#
# lower: int = 0
# upper: int = 0
# edge_type: EdgeType = EdgeType.BLOCKER
#
# class Add(Command):
# """Add a new goal to the existing tree"""
#
# name: str
# add_to: int = 0
# edge_type: EdgeType = EdgeType.PARENT
#
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class Insert(Command):
# """Add an intermediate goal between two selected goals"""
#
# name: str
#
# class Rename(Command):
# """Change a name of the given goal"""
#
# new_name: str
# goal_id: int = 0
. Output only the next line. | result = Goals("", message_fn) |
Using the snippet: <|code_start|> def accept_ToggleClose(self, command: ToggleClose) -> None:
if self.selection in self.closed:
if self._may_be_reopened():
self.closed.remove(self.selection)
self._events.append(("toggle_close", True, self.selection))
else:
self.error(
"This goal can't be reopened because other subgoals block it"
)
else:
if self._may_be_closed():
self.closed.add(self.selection)
self._events.append(("toggle_close", False, self.selection))
self.accept_Select(
Select(self._first_open_and_switchable(command.root))
)
self.accept(HoldSelect())
else:
self.error("This goal can't be closed because it have open subgoals")
def _may_be_closed(self) -> bool:
return all(g.target in self.closed for g in self._forward_edges(self.selection))
def _may_be_reopened(self) -> bool:
blocked_by_selected = [e.source for e in self._back_edges(self.selection)]
return all(g not in self.closed for g in blocked_by_selected)
def _first_open_and_switchable(self, root: int) -> int:
root = max(root, Goals.ROOT_ID)
front = [root]
<|code_end|>
, determine the next line of code. You have imports:
from typing import Callable, Dict, Optional, List, Set, Any, Tuple
from collections import deque, defaultdict
from siebenapp.domain import (
Graph,
EdgeType,
Edge,
HoldSelect,
ToggleClose,
Delete,
ToggleLink,
Add,
Select,
Insert,
Rename,
)
and context (class names, function names, or code) available:
# Path: siebenapp/domain.py
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class Edge:
# source: int
# target: int
# type: EdgeType
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class Delete(Command):
# """Remove given or selected goal whether it exists. Do nothing in other case"""
#
# goal_id: int = 0
#
# class ToggleLink(Command):
# """Create or remove a link between two given goals, if possible"""
#
# lower: int = 0
# upper: int = 0
# edge_type: EdgeType = EdgeType.BLOCKER
#
# class Add(Command):
# """Add a new goal to the existing tree"""
#
# name: str
# add_to: int = 0
# edge_type: EdgeType = EdgeType.PARENT
#
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class Insert(Command):
# """Add an intermediate goal between two selected goals"""
#
# name: str
#
# class Rename(Command):
# """Change a name of the given goal"""
#
# new_name: str
# goal_id: int = 0
. Output only the next line. | candidates: List[int] = [] |
Based on the snippet: <|code_start|>
@dataclass(frozen=True)
class ToggleOpenView(Command):
"""Switch between "only open goals" and "all goals" views"""
class OpenView(Graph):
"""Non-persistent view layer that allows to switch
between only-open (plus selected) and all goals"""
def __init__(self, goaltree: Graph):
super().__init__(goaltree)
self._open: bool = True
def accept_ToggleOpenView(self, command: ToggleOpenView):
self._open = not self._open
def settings(self, key: str) -> Any:
if key == "filter_open":
return self._open
return self.goaltree.settings(key)
def reconfigure_from(self, origin: "Graph") -> None:
<|code_end|>
, predict the immediate next line with the help of imports:
from dataclasses import dataclass
from typing import Dict, Any, Set, List, Tuple
from siebenapp.domain import Command, Graph, with_key, EdgeType
and context (classes, functions, sometimes code) from other files:
# Path: siebenapp/domain.py
# class Command:
# pass
#
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# def with_key(key):
# """Wraps around Graph.q, adding given key to the request"""
#
# def inner(q):
# @wraps(q)
# def wrapper(self, keys="name"):
# if no_key := key not in keys:
# keys = ",".join([keys, key])
# result = q(self, keys)
# if no_key:
# for v in result.values():
# v.pop(key, None)
# return result
#
# return wrapper
#
# return inner
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
. Output only the next line. | super().reconfigure_from(origin) |
Here is a snippet: <|code_start|> self._open = not self._open
def settings(self, key: str) -> Any:
if key == "filter_open":
return self._open
return self.goaltree.settings(key)
def reconfigure_from(self, origin: "Graph") -> None:
super().reconfigure_from(origin)
if not origin.settings("filter_open"):
self.accept(ToggleOpenView())
@with_key("open")
def q(self, keys: str = "name") -> Dict[int, Any]:
goals = self.goaltree.q(keys)
result: Dict[int, Any] = {
k: {}
for k, v in goals.items()
if not self._open or v["open"] or k in self.selections()
}
# goals without parents
not_linked: Set[int] = set(g for g in result.keys() if g > 1)
for goal_id in result:
val = goals[goal_id]
result[goal_id] = {k: v for k, v in val.items() if k != "edge"}
if "edge" in keys:
filtered_edges: List[Tuple[int, EdgeType]] = []
for edge in val["edge"]:
if edge[0] in result:
filtered_edges.append(edge)
<|code_end|>
. Write the next line using the current file imports:
from dataclasses import dataclass
from typing import Dict, Any, Set, List, Tuple
from siebenapp.domain import Command, Graph, with_key, EdgeType
and context from other files:
# Path: siebenapp/domain.py
# class Command:
# pass
#
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# def with_key(key):
# """Wraps around Graph.q, adding given key to the request"""
#
# def inner(q):
# @wraps(q)
# def wrapper(self, keys="name"):
# if no_key := key not in keys:
# keys = ",".join([keys, key])
# result = q(self, keys)
# if no_key:
# for v in result.values():
# v.pop(key, None)
# return result
#
# return wrapper
#
# return inner
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
, which may include functions, classes, or code. Output only the next line. | if edge[0] > 1: |
Given the following code snippet before the placeholder: <|code_start|>
@dataclass(frozen=True)
class ToggleOpenView(Command):
"""Switch between "only open goals" and "all goals" views"""
class OpenView(Graph):
"""Non-persistent view layer that allows to switch
between only-open (plus selected) and all goals"""
def __init__(self, goaltree: Graph):
super().__init__(goaltree)
<|code_end|>
, predict the next line using imports from the current file:
from dataclasses import dataclass
from typing import Dict, Any, Set, List, Tuple
from siebenapp.domain import Command, Graph, with_key, EdgeType
and context including class names, function names, and sometimes code from other files:
# Path: siebenapp/domain.py
# class Command:
# pass
#
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# def with_key(key):
# """Wraps around Graph.q, adding given key to the request"""
#
# def inner(q):
# @wraps(q)
# def wrapper(self, keys="name"):
# if no_key := key not in keys:
# keys = ",".join([keys, key])
# result = q(self, keys)
# if no_key:
# for v in result.values():
# v.pop(key, None)
# return result
#
# return wrapper
#
# return inner
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
. Output only the next line. | self._open: bool = True |
Given snippet: <|code_start|>@dataclass(frozen=True)
class ToggleOpenView(Command):
"""Switch between "only open goals" and "all goals" views"""
class OpenView(Graph):
"""Non-persistent view layer that allows to switch
between only-open (plus selected) and all goals"""
def __init__(self, goaltree: Graph):
super().__init__(goaltree)
self._open: bool = True
def accept_ToggleOpenView(self, command: ToggleOpenView):
self._open = not self._open
def settings(self, key: str) -> Any:
if key == "filter_open":
return self._open
return self.goaltree.settings(key)
def reconfigure_from(self, origin: "Graph") -> None:
super().reconfigure_from(origin)
if not origin.settings("filter_open"):
self.accept(ToggleOpenView())
@with_key("open")
def q(self, keys: str = "name") -> Dict[int, Any]:
goals = self.goaltree.q(keys)
result: Dict[int, Any] = {
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from dataclasses import dataclass
from typing import Dict, Any, Set, List, Tuple
from siebenapp.domain import Command, Graph, with_key, EdgeType
and context:
# Path: siebenapp/domain.py
# class Command:
# pass
#
# class Graph:
# """Base interface definition"""
#
# NO_VALUE = "no value"
#
# def __init__(self, goaltree=None):
# self.goaltree: Graph = goaltree
#
# def __getattr__(self, item):
# """When method is not found, ask nested goaltree for it"""
# if self.goaltree != self:
# return getattr(self.goaltree, item)
# return None
#
# def accept(self, command: Command) -> None:
# """React on the given command"""
# method_name = "accept_" + command.__class__.__name__
# if method := getattr(self, method_name):
# method(command)
# elif parent := self.goaltree:
# parent.accept(command)
# else:
# raise NotImplementedError(f"Cannot find method {method_name}")
#
# def accept_all(self, *commands: Command) -> None:
# """React on the command chain"""
# for command in commands:
# self.accept(command)
#
# def settings(self, key: str) -> Any:
# """Returns given inner value by the key"""
# if self.goaltree is not None:
# return self.goaltree.settings(key)
# return Graph.NO_VALUE
#
# def reconfigure_from(self, origin: "Graph") -> None:
# """Synchronize *non-persistent* settings from the given origin"""
# if self.goaltree:
# self.goaltree.reconfigure_from(origin)
#
# def selections(self) -> Set[int]:
# """Return ids of special 'selection' goals"""
# if self.goaltree:
# return self.goaltree.selections()
# raise NotImplementedError
#
# def events(self) -> deque:
# """Returns queue of applied actions.
# Note: this queue is modifiable -- you may push new events into it. But this
# behavior may be changed in future."""
# if self.goaltree is not None:
# return self.goaltree.events()
# raise NotImplementedError
#
# def q(self, keys: str = "name") -> Dict[int, Any]:
# """Run search query against content"""
# raise NotImplementedError
#
# def error(self, message: str) -> None:
# """Show error message"""
# if self.goaltree is not None:
# self.goaltree.error(message)
#
# def verify(self) -> bool:
# """Check all inner data for correctness"""
# if self.goaltree is not None:
# return self.goaltree.verify()
# return False
#
# def with_key(key):
# """Wraps around Graph.q, adding given key to the request"""
#
# def inner(q):
# @wraps(q)
# def wrapper(self, keys="name"):
# if no_key := key not in keys:
# keys = ",".join([keys, key])
# result = q(self, keys)
# if no_key:
# for v in result.values():
# v.pop(key, None)
# return result
#
# return wrapper
#
# return inner
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
which might include code, classes, or functions. Output only the next line. | k: {} |
Continue the code snippet: <|code_start|>
@pytest.fixture
def trivial():
g = build_goaltree(open_(1, "Start", [], [], select=selected))
return OpenView(g)
@pytest.fixture
def two_goals():
g = build_goaltree(open_(1, "Open", [2], [], select=selected), clos_(2, "Closed"))
return OpenView(g)
def test_open_goal_is_shown_by_default(trivial):
<|code_end|>
. Use current file imports:
import pytest
from siebenapp.domain import Select, ToggleClose, EdgeType, HoldSelect
from siebenapp.open_view import ToggleOpenView, OpenView
from siebenapp.tests.dsl import build_goaltree, open_, selected, clos_, previous
and context (classes, functions, or code) from other files:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# Path: siebenapp/open_view.py
# class ToggleOpenView(Command):
# """Switch between "only open goals" and "all goals" views"""
#
# class OpenView(Graph):
# """Non-persistent view layer that allows to switch
# between only-open (plus selected) and all goals"""
#
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self._open: bool = True
#
# def accept_ToggleOpenView(self, command: ToggleOpenView):
# self._open = not self._open
#
# def settings(self, key: str) -> Any:
# if key == "filter_open":
# return self._open
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# if not origin.settings("filter_open"):
# self.accept(ToggleOpenView())
#
# @with_key("open")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# goals = self.goaltree.q(keys)
# result: Dict[int, Any] = {
# k: {}
# for k, v in goals.items()
# if not self._open or v["open"] or k in self.selections()
# }
# # goals without parents
# not_linked: Set[int] = set(g for g in result.keys() if g > 1)
# for goal_id in result:
# val = goals[goal_id]
# result[goal_id] = {k: v for k, v in val.items() if k != "edge"}
# if "edge" in keys:
# filtered_edges: List[Tuple[int, EdgeType]] = []
# for edge in val["edge"]:
# if edge[0] in result:
# filtered_edges.append(edge)
# if edge[0] > 1:
# not_linked.discard(edge[0])
# result[goal_id]["edge"] = filtered_edges
# if "edge" in keys:
# # here we know something about other layers (Zoom). I do not like it
# root_goals: Set[int] = set(result.keys()).intersection({1, -1})
# if root_goals:
# root_goal: int = root_goals.pop()
# for missing_goal in not_linked:
# result[root_goal]["edge"].append((missing_goal, EdgeType.BLOCKER))
# return result
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
. Output only the next line. | assert trivial.q("name") == {1: {"name": "Start"}} |
Given the following code snippet before the placeholder: <|code_start|> "select": "prev",
"open": True,
"edge": [(2, EdgeType.PARENT), (3, EdgeType.PARENT)],
},
2: {"name": "1", "select": "select", "open": True, "edge": []},
3: {"name": "2", "select": None, "open": True, "edge": []},
}
e.accept(ToggleClose())
assert e.q(keys="name,select,open,edge") == {
1: {
"name": "Root",
"select": None,
"open": True,
"edge": [(3, EdgeType.PARENT)],
},
3: {"name": "2", "select": "select", "open": True, "edge": []},
}
def test_closed_goals_are_shown_when_selected():
v = OpenView(
build_goaltree(
open_(1, "Root", [2, 3], select=selected),
clos_(2, "closed"),
clos_(3, "closed too", [4]),
clos_(4, "closed and not selected"),
)
)
v.accept_all(ToggleOpenView(), Select(2), HoldSelect(), Select(3))
assert v.q("name,select,open") == {
<|code_end|>
, predict the next line using imports from the current file:
import pytest
from siebenapp.domain import Select, ToggleClose, EdgeType, HoldSelect
from siebenapp.open_view import ToggleOpenView, OpenView
from siebenapp.tests.dsl import build_goaltree, open_, selected, clos_, previous
and context including class names, function names, and sometimes code from other files:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# Path: siebenapp/open_view.py
# class ToggleOpenView(Command):
# """Switch between "only open goals" and "all goals" views"""
#
# class OpenView(Graph):
# """Non-persistent view layer that allows to switch
# between only-open (plus selected) and all goals"""
#
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self._open: bool = True
#
# def accept_ToggleOpenView(self, command: ToggleOpenView):
# self._open = not self._open
#
# def settings(self, key: str) -> Any:
# if key == "filter_open":
# return self._open
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# if not origin.settings("filter_open"):
# self.accept(ToggleOpenView())
#
# @with_key("open")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# goals = self.goaltree.q(keys)
# result: Dict[int, Any] = {
# k: {}
# for k, v in goals.items()
# if not self._open or v["open"] or k in self.selections()
# }
# # goals without parents
# not_linked: Set[int] = set(g for g in result.keys() if g > 1)
# for goal_id in result:
# val = goals[goal_id]
# result[goal_id] = {k: v for k, v in val.items() if k != "edge"}
# if "edge" in keys:
# filtered_edges: List[Tuple[int, EdgeType]] = []
# for edge in val["edge"]:
# if edge[0] in result:
# filtered_edges.append(edge)
# if edge[0] > 1:
# not_linked.discard(edge[0])
# result[goal_id]["edge"] = filtered_edges
# if "edge" in keys:
# # here we know something about other layers (Zoom). I do not like it
# root_goals: Set[int] = set(result.keys()).intersection({1, -1})
# if root_goals:
# root_goal: int = root_goals.pop()
# for missing_goal in not_linked:
# result[root_goal]["edge"].append((missing_goal, EdgeType.BLOCKER))
# return result
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
. Output only the next line. | 1: {"name": "Root", "open": True, "select": None}, |
Using the snippet: <|code_start|>
@pytest.fixture
def trivial():
g = build_goaltree(open_(1, "Start", [], [], select=selected))
return OpenView(g)
@pytest.fixture
def two_goals():
g = build_goaltree(open_(1, "Open", [2], [], select=selected), clos_(2, "Closed"))
return OpenView(g)
<|code_end|>
, determine the next line of code. You have imports:
import pytest
from siebenapp.domain import Select, ToggleClose, EdgeType, HoldSelect
from siebenapp.open_view import ToggleOpenView, OpenView
from siebenapp.tests.dsl import build_goaltree, open_, selected, clos_, previous
and context (class names, function names, or code) available:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# Path: siebenapp/open_view.py
# class ToggleOpenView(Command):
# """Switch between "only open goals" and "all goals" views"""
#
# class OpenView(Graph):
# """Non-persistent view layer that allows to switch
# between only-open (plus selected) and all goals"""
#
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self._open: bool = True
#
# def accept_ToggleOpenView(self, command: ToggleOpenView):
# self._open = not self._open
#
# def settings(self, key: str) -> Any:
# if key == "filter_open":
# return self._open
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# if not origin.settings("filter_open"):
# self.accept(ToggleOpenView())
#
# @with_key("open")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# goals = self.goaltree.q(keys)
# result: Dict[int, Any] = {
# k: {}
# for k, v in goals.items()
# if not self._open or v["open"] or k in self.selections()
# }
# # goals without parents
# not_linked: Set[int] = set(g for g in result.keys() if g > 1)
# for goal_id in result:
# val = goals[goal_id]
# result[goal_id] = {k: v for k, v in val.items() if k != "edge"}
# if "edge" in keys:
# filtered_edges: List[Tuple[int, EdgeType]] = []
# for edge in val["edge"]:
# if edge[0] in result:
# filtered_edges.append(edge)
# if edge[0] > 1:
# not_linked.discard(edge[0])
# result[goal_id]["edge"] = filtered_edges
# if "edge" in keys:
# # here we know something about other layers (Zoom). I do not like it
# root_goals: Set[int] = set(result.keys()).intersection({1, -1})
# if root_goals:
# root_goal: int = root_goals.pop()
# for missing_goal in not_linked:
# result[root_goal]["edge"].append((missing_goal, EdgeType.BLOCKER))
# return result
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
. Output only the next line. | def test_open_goal_is_shown_by_default(trivial): |
Given snippet: <|code_start|>@pytest.fixture
def trivial():
g = build_goaltree(open_(1, "Start", [], [], select=selected))
return OpenView(g)
@pytest.fixture
def two_goals():
g = build_goaltree(open_(1, "Open", [2], [], select=selected), clos_(2, "Closed"))
return OpenView(g)
def test_open_goal_is_shown_by_default(trivial):
assert trivial.q("name") == {1: {"name": "Start"}}
def test_open_goal_is_shown_after_switch(trivial):
trivial.accept(ToggleOpenView())
assert trivial.q("name") == {1: {"name": "Start"}}
def test_filter_open_setting_is_set_by_default(trivial):
assert trivial.settings("filter_open") == 1
def test_filter_open_setting_is_changed_after_switch(trivial):
trivial.accept(ToggleOpenView())
assert trivial.settings("filter_open") == 0
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pytest
from siebenapp.domain import Select, ToggleClose, EdgeType, HoldSelect
from siebenapp.open_view import ToggleOpenView, OpenView
from siebenapp.tests.dsl import build_goaltree, open_, selected, clos_, previous
and context:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# Path: siebenapp/open_view.py
# class ToggleOpenView(Command):
# """Switch between "only open goals" and "all goals" views"""
#
# class OpenView(Graph):
# """Non-persistent view layer that allows to switch
# between only-open (plus selected) and all goals"""
#
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self._open: bool = True
#
# def accept_ToggleOpenView(self, command: ToggleOpenView):
# self._open = not self._open
#
# def settings(self, key: str) -> Any:
# if key == "filter_open":
# return self._open
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# if not origin.settings("filter_open"):
# self.accept(ToggleOpenView())
#
# @with_key("open")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# goals = self.goaltree.q(keys)
# result: Dict[int, Any] = {
# k: {}
# for k, v in goals.items()
# if not self._open or v["open"] or k in self.selections()
# }
# # goals without parents
# not_linked: Set[int] = set(g for g in result.keys() if g > 1)
# for goal_id in result:
# val = goals[goal_id]
# result[goal_id] = {k: v for k, v in val.items() if k != "edge"}
# if "edge" in keys:
# filtered_edges: List[Tuple[int, EdgeType]] = []
# for edge in val["edge"]:
# if edge[0] in result:
# filtered_edges.append(edge)
# if edge[0] > 1:
# not_linked.discard(edge[0])
# result[goal_id]["edge"] = filtered_edges
# if "edge" in keys:
# # here we know something about other layers (Zoom). I do not like it
# root_goals: Set[int] = set(result.keys()).intersection({1, -1})
# if root_goals:
# root_goal: int = root_goals.pop()
# for missing_goal in not_linked:
# result[root_goal]["edge"].append((missing_goal, EdgeType.BLOCKER))
# return result
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
which might include code, classes, or functions. Output only the next line. | def test_closed_goal_is_not_shown_by_default(two_goals): |
Given snippet: <|code_start|>@pytest.fixture
def trivial():
g = build_goaltree(open_(1, "Start", [], [], select=selected))
return OpenView(g)
@pytest.fixture
def two_goals():
g = build_goaltree(open_(1, "Open", [2], [], select=selected), clos_(2, "Closed"))
return OpenView(g)
def test_open_goal_is_shown_by_default(trivial):
assert trivial.q("name") == {1: {"name": "Start"}}
def test_open_goal_is_shown_after_switch(trivial):
trivial.accept(ToggleOpenView())
assert trivial.q("name") == {1: {"name": "Start"}}
def test_filter_open_setting_is_set_by_default(trivial):
assert trivial.settings("filter_open") == 1
def test_filter_open_setting_is_changed_after_switch(trivial):
trivial.accept(ToggleOpenView())
assert trivial.settings("filter_open") == 0
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pytest
from siebenapp.domain import Select, ToggleClose, EdgeType, HoldSelect
from siebenapp.open_view import ToggleOpenView, OpenView
from siebenapp.tests.dsl import build_goaltree, open_, selected, clos_, previous
and context:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# Path: siebenapp/open_view.py
# class ToggleOpenView(Command):
# """Switch between "only open goals" and "all goals" views"""
#
# class OpenView(Graph):
# """Non-persistent view layer that allows to switch
# between only-open (plus selected) and all goals"""
#
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self._open: bool = True
#
# def accept_ToggleOpenView(self, command: ToggleOpenView):
# self._open = not self._open
#
# def settings(self, key: str) -> Any:
# if key == "filter_open":
# return self._open
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# if not origin.settings("filter_open"):
# self.accept(ToggleOpenView())
#
# @with_key("open")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# goals = self.goaltree.q(keys)
# result: Dict[int, Any] = {
# k: {}
# for k, v in goals.items()
# if not self._open or v["open"] or k in self.selections()
# }
# # goals without parents
# not_linked: Set[int] = set(g for g in result.keys() if g > 1)
# for goal_id in result:
# val = goals[goal_id]
# result[goal_id] = {k: v for k, v in val.items() if k != "edge"}
# if "edge" in keys:
# filtered_edges: List[Tuple[int, EdgeType]] = []
# for edge in val["edge"]:
# if edge[0] in result:
# filtered_edges.append(edge)
# if edge[0] > 1:
# not_linked.discard(edge[0])
# result[goal_id]["edge"] = filtered_edges
# if "edge" in keys:
# # here we know something about other layers (Zoom). I do not like it
# root_goals: Set[int] = set(result.keys()).intersection({1, -1})
# if root_goals:
# root_goal: int = root_goals.pop()
# for missing_goal in not_linked:
# result[root_goal]["edge"].append((missing_goal, EdgeType.BLOCKER))
# return result
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
which might include code, classes, or functions. Output only the next line. | def test_closed_goal_is_not_shown_by_default(two_goals): |
Given snippet: <|code_start|> }
two_goals.accept(ToggleOpenView())
assert two_goals.q("name,open,edge") == {
1: {"name": "Open", "open": True, "edge": []}
}
def test_simple_open_enumeration_workflow():
e = OpenView(
build_goaltree(
open_(1, "Root", [2, 3], select=previous),
open_(2, "1", select=selected),
open_(3, "2"),
)
)
assert e.q(keys="name,select,open,edge") == {
1: {
"name": "Root",
"select": "prev",
"open": True,
"edge": [(2, EdgeType.PARENT), (3, EdgeType.PARENT)],
},
2: {"name": "1", "select": "select", "open": True, "edge": []},
3: {"name": "2", "select": None, "open": True, "edge": []},
}
e.accept(ToggleClose())
assert e.q(keys="name,select,open,edge") == {
1: {
"name": "Root",
"select": None,
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pytest
from siebenapp.domain import Select, ToggleClose, EdgeType, HoldSelect
from siebenapp.open_view import ToggleOpenView, OpenView
from siebenapp.tests.dsl import build_goaltree, open_, selected, clos_, previous
and context:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# Path: siebenapp/open_view.py
# class ToggleOpenView(Command):
# """Switch between "only open goals" and "all goals" views"""
#
# class OpenView(Graph):
# """Non-persistent view layer that allows to switch
# between only-open (plus selected) and all goals"""
#
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self._open: bool = True
#
# def accept_ToggleOpenView(self, command: ToggleOpenView):
# self._open = not self._open
#
# def settings(self, key: str) -> Any:
# if key == "filter_open":
# return self._open
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# if not origin.settings("filter_open"):
# self.accept(ToggleOpenView())
#
# @with_key("open")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# goals = self.goaltree.q(keys)
# result: Dict[int, Any] = {
# k: {}
# for k, v in goals.items()
# if not self._open or v["open"] or k in self.selections()
# }
# # goals without parents
# not_linked: Set[int] = set(g for g in result.keys() if g > 1)
# for goal_id in result:
# val = goals[goal_id]
# result[goal_id] = {k: v for k, v in val.items() if k != "edge"}
# if "edge" in keys:
# filtered_edges: List[Tuple[int, EdgeType]] = []
# for edge in val["edge"]:
# if edge[0] in result:
# filtered_edges.append(edge)
# if edge[0] > 1:
# not_linked.discard(edge[0])
# result[goal_id]["edge"] = filtered_edges
# if "edge" in keys:
# # here we know something about other layers (Zoom). I do not like it
# root_goals: Set[int] = set(result.keys()).intersection({1, -1})
# if root_goals:
# root_goal: int = root_goals.pop()
# for missing_goal in not_linked:
# result[root_goal]["edge"].append((missing_goal, EdgeType.BLOCKER))
# return result
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
which might include code, classes, or functions. Output only the next line. | "open": True, |
Based on the snippet: <|code_start|> 1: {"name": "Open", "open": True, "edge": [(2, EdgeType.PARENT)]},
2: {"name": "Closed", "open": False, "edge": []},
}
two_goals.accept(ToggleOpenView())
assert two_goals.q("name,open,edge") == {
1: {"name": "Open", "open": True, "edge": []}
}
def test_simple_open_enumeration_workflow():
e = OpenView(
build_goaltree(
open_(1, "Root", [2, 3], select=previous),
open_(2, "1", select=selected),
open_(3, "2"),
)
)
assert e.q(keys="name,select,open,edge") == {
1: {
"name": "Root",
"select": "prev",
"open": True,
"edge": [(2, EdgeType.PARENT), (3, EdgeType.PARENT)],
},
2: {"name": "1", "select": "select", "open": True, "edge": []},
3: {"name": "2", "select": None, "open": True, "edge": []},
}
e.accept(ToggleClose())
assert e.q(keys="name,select,open,edge") == {
1: {
<|code_end|>
, predict the immediate next line with the help of imports:
import pytest
from siebenapp.domain import Select, ToggleClose, EdgeType, HoldSelect
from siebenapp.open_view import ToggleOpenView, OpenView
from siebenapp.tests.dsl import build_goaltree, open_, selected, clos_, previous
and context (classes, functions, sometimes code) from other files:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# Path: siebenapp/open_view.py
# class ToggleOpenView(Command):
# """Switch between "only open goals" and "all goals" views"""
#
# class OpenView(Graph):
# """Non-persistent view layer that allows to switch
# between only-open (plus selected) and all goals"""
#
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self._open: bool = True
#
# def accept_ToggleOpenView(self, command: ToggleOpenView):
# self._open = not self._open
#
# def settings(self, key: str) -> Any:
# if key == "filter_open":
# return self._open
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# if not origin.settings("filter_open"):
# self.accept(ToggleOpenView())
#
# @with_key("open")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# goals = self.goaltree.q(keys)
# result: Dict[int, Any] = {
# k: {}
# for k, v in goals.items()
# if not self._open or v["open"] or k in self.selections()
# }
# # goals without parents
# not_linked: Set[int] = set(g for g in result.keys() if g > 1)
# for goal_id in result:
# val = goals[goal_id]
# result[goal_id] = {k: v for k, v in val.items() if k != "edge"}
# if "edge" in keys:
# filtered_edges: List[Tuple[int, EdgeType]] = []
# for edge in val["edge"]:
# if edge[0] in result:
# filtered_edges.append(edge)
# if edge[0] > 1:
# not_linked.discard(edge[0])
# result[goal_id]["edge"] = filtered_edges
# if "edge" in keys:
# # here we know something about other layers (Zoom). I do not like it
# root_goals: Set[int] = set(result.keys()).intersection({1, -1})
# if root_goals:
# root_goal: int = root_goals.pop()
# for missing_goal in not_linked:
# result[root_goal]["edge"].append((missing_goal, EdgeType.BLOCKER))
# return result
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
. Output only the next line. | "name": "Root", |
Given the following code snippet before the placeholder: <|code_start|>
def test_closed_goal_is_shown_after_switch(two_goals):
two_goals.accept(ToggleOpenView())
assert two_goals.q("name,open,edge") == {
1: {"name": "Open", "open": True, "edge": [(2, EdgeType.PARENT)]},
2: {"name": "Closed", "open": False, "edge": []},
}
two_goals.accept(ToggleOpenView())
assert two_goals.q("name,open,edge") == {
1: {"name": "Open", "open": True, "edge": []}
}
def test_simple_open_enumeration_workflow():
e = OpenView(
build_goaltree(
open_(1, "Root", [2, 3], select=previous),
open_(2, "1", select=selected),
open_(3, "2"),
)
)
assert e.q(keys="name,select,open,edge") == {
1: {
"name": "Root",
"select": "prev",
"open": True,
"edge": [(2, EdgeType.PARENT), (3, EdgeType.PARENT)],
},
2: {"name": "1", "select": "select", "open": True, "edge": []},
<|code_end|>
, predict the next line using imports from the current file:
import pytest
from siebenapp.domain import Select, ToggleClose, EdgeType, HoldSelect
from siebenapp.open_view import ToggleOpenView, OpenView
from siebenapp.tests.dsl import build_goaltree, open_, selected, clos_, previous
and context including class names, function names, and sometimes code from other files:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# Path: siebenapp/open_view.py
# class ToggleOpenView(Command):
# """Switch between "only open goals" and "all goals" views"""
#
# class OpenView(Graph):
# """Non-persistent view layer that allows to switch
# between only-open (plus selected) and all goals"""
#
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self._open: bool = True
#
# def accept_ToggleOpenView(self, command: ToggleOpenView):
# self._open = not self._open
#
# def settings(self, key: str) -> Any:
# if key == "filter_open":
# return self._open
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# if not origin.settings("filter_open"):
# self.accept(ToggleOpenView())
#
# @with_key("open")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# goals = self.goaltree.q(keys)
# result: Dict[int, Any] = {
# k: {}
# for k, v in goals.items()
# if not self._open or v["open"] or k in self.selections()
# }
# # goals without parents
# not_linked: Set[int] = set(g for g in result.keys() if g > 1)
# for goal_id in result:
# val = goals[goal_id]
# result[goal_id] = {k: v for k, v in val.items() if k != "edge"}
# if "edge" in keys:
# filtered_edges: List[Tuple[int, EdgeType]] = []
# for edge in val["edge"]:
# if edge[0] in result:
# filtered_edges.append(edge)
# if edge[0] > 1:
# not_linked.discard(edge[0])
# result[goal_id]["edge"] = filtered_edges
# if "edge" in keys:
# # here we know something about other layers (Zoom). I do not like it
# root_goals: Set[int] = set(result.keys()).intersection({1, -1})
# if root_goals:
# root_goal: int = root_goals.pop()
# for missing_goal in not_linked:
# result[root_goal]["edge"].append((missing_goal, EdgeType.BLOCKER))
# return result
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
. Output only the next line. | 3: {"name": "2", "select": None, "open": True, "edge": []}, |
Given the code snippet: <|code_start|> g = build_goaltree(open_(1, "Start", [], [], select=selected))
return OpenView(g)
@pytest.fixture
def two_goals():
g = build_goaltree(open_(1, "Open", [2], [], select=selected), clos_(2, "Closed"))
return OpenView(g)
def test_open_goal_is_shown_by_default(trivial):
assert trivial.q("name") == {1: {"name": "Start"}}
def test_open_goal_is_shown_after_switch(trivial):
trivial.accept(ToggleOpenView())
assert trivial.q("name") == {1: {"name": "Start"}}
def test_filter_open_setting_is_set_by_default(trivial):
assert trivial.settings("filter_open") == 1
def test_filter_open_setting_is_changed_after_switch(trivial):
trivial.accept(ToggleOpenView())
assert trivial.settings("filter_open") == 0
def test_closed_goal_is_not_shown_by_default(two_goals):
assert two_goals.q("name,open,edge") == {
<|code_end|>
, generate the next line using the imports in this file:
import pytest
from siebenapp.domain import Select, ToggleClose, EdgeType, HoldSelect
from siebenapp.open_view import ToggleOpenView, OpenView
from siebenapp.tests.dsl import build_goaltree, open_, selected, clos_, previous
and context (functions, classes, or occasionally code) from other files:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# Path: siebenapp/open_view.py
# class ToggleOpenView(Command):
# """Switch between "only open goals" and "all goals" views"""
#
# class OpenView(Graph):
# """Non-persistent view layer that allows to switch
# between only-open (plus selected) and all goals"""
#
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self._open: bool = True
#
# def accept_ToggleOpenView(self, command: ToggleOpenView):
# self._open = not self._open
#
# def settings(self, key: str) -> Any:
# if key == "filter_open":
# return self._open
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# if not origin.settings("filter_open"):
# self.accept(ToggleOpenView())
#
# @with_key("open")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# goals = self.goaltree.q(keys)
# result: Dict[int, Any] = {
# k: {}
# for k, v in goals.items()
# if not self._open or v["open"] or k in self.selections()
# }
# # goals without parents
# not_linked: Set[int] = set(g for g in result.keys() if g > 1)
# for goal_id in result:
# val = goals[goal_id]
# result[goal_id] = {k: v for k, v in val.items() if k != "edge"}
# if "edge" in keys:
# filtered_edges: List[Tuple[int, EdgeType]] = []
# for edge in val["edge"]:
# if edge[0] in result:
# filtered_edges.append(edge)
# if edge[0] > 1:
# not_linked.discard(edge[0])
# result[goal_id]["edge"] = filtered_edges
# if "edge" in keys:
# # here we know something about other layers (Zoom). I do not like it
# root_goals: Set[int] = set(result.keys()).intersection({1, -1})
# if root_goals:
# root_goal: int = root_goals.pop()
# for missing_goal in not_linked:
# result[root_goal]["edge"].append((missing_goal, EdgeType.BLOCKER))
# return result
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
. Output only the next line. | 1: {"name": "Open", "open": True, "edge": []} |
Based on the snippet: <|code_start|>
@pytest.fixture
def trivial():
g = build_goaltree(open_(1, "Start", [], [], select=selected))
return OpenView(g)
@pytest.fixture
def two_goals():
g = build_goaltree(open_(1, "Open", [2], [], select=selected), clos_(2, "Closed"))
return OpenView(g)
<|code_end|>
, predict the immediate next line with the help of imports:
import pytest
from siebenapp.domain import Select, ToggleClose, EdgeType, HoldSelect
from siebenapp.open_view import ToggleOpenView, OpenView
from siebenapp.tests.dsl import build_goaltree, open_, selected, clos_, previous
and context (classes, functions, sometimes code) from other files:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# Path: siebenapp/open_view.py
# class ToggleOpenView(Command):
# """Switch between "only open goals" and "all goals" views"""
#
# class OpenView(Graph):
# """Non-persistent view layer that allows to switch
# between only-open (plus selected) and all goals"""
#
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self._open: bool = True
#
# def accept_ToggleOpenView(self, command: ToggleOpenView):
# self._open = not self._open
#
# def settings(self, key: str) -> Any:
# if key == "filter_open":
# return self._open
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# if not origin.settings("filter_open"):
# self.accept(ToggleOpenView())
#
# @with_key("open")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# goals = self.goaltree.q(keys)
# result: Dict[int, Any] = {
# k: {}
# for k, v in goals.items()
# if not self._open or v["open"] or k in self.selections()
# }
# # goals without parents
# not_linked: Set[int] = set(g for g in result.keys() if g > 1)
# for goal_id in result:
# val = goals[goal_id]
# result[goal_id] = {k: v for k, v in val.items() if k != "edge"}
# if "edge" in keys:
# filtered_edges: List[Tuple[int, EdgeType]] = []
# for edge in val["edge"]:
# if edge[0] in result:
# filtered_edges.append(edge)
# if edge[0] > 1:
# not_linked.discard(edge[0])
# result[goal_id]["edge"] = filtered_edges
# if "edge" in keys:
# # here we know something about other layers (Zoom). I do not like it
# root_goals: Set[int] = set(result.keys()).intersection({1, -1})
# if root_goals:
# root_goal: int = root_goals.pop()
# for missing_goal in not_linked:
# result[root_goal]["edge"].append((missing_goal, EdgeType.BLOCKER))
# return result
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
. Output only the next line. | def test_open_goal_is_shown_by_default(trivial): |
Predict the next line after this snippet: <|code_start|> }
v.accept(ToggleOpenView())
# Still show: open goals, selected goals
assert v.q("name,select,open") == {
1: {"name": "Root", "open": True, "select": None},
2: {"name": "closed", "open": False, "select": "prev"},
3: {"name": "closed too", "open": False, "select": "select"},
}
def test_build_fake_links_to_far_closed_goals():
v = OpenView(
build_goaltree(
open_(1, "Root", blockers=[2], select=previous),
clos_(2, "Middle", blockers=[3]),
clos_(3, "Top", select=selected),
)
)
assert v.q("select,edge") == {
1: {"select": "prev", "edge": [(3, EdgeType.BLOCKER)]},
3: {"select": "select", "edge": []},
}
def test_show_single_goal_when_root_is_closed_and_unselected():
v = OpenView(
build_goaltree(
clos_(1, "Hidden root", [2]),
clos_(2, "Visible", select=selected),
)
<|code_end|>
using the current file's imports:
import pytest
from siebenapp.domain import Select, ToggleClose, EdgeType, HoldSelect
from siebenapp.open_view import ToggleOpenView, OpenView
from siebenapp.tests.dsl import build_goaltree, open_, selected, clos_, previous
and any relevant context from other files:
# Path: siebenapp/domain.py
# class Select(Command):
# """Select a goal by its id whether it exist. Do nothing in other case"""
#
# goal_id: int
#
# class ToggleClose(Command):
# """Close an open selected goal. Re-open a closed selected goal"""
#
# root: int = 0
#
# class EdgeType(IntEnum):
# BLOCKER = 1
# PARENT = 2
#
# class HoldSelect(Command):
# """Saves current selection into the "previous selection" state"""
#
# Path: siebenapp/open_view.py
# class ToggleOpenView(Command):
# """Switch between "only open goals" and "all goals" views"""
#
# class OpenView(Graph):
# """Non-persistent view layer that allows to switch
# between only-open (plus selected) and all goals"""
#
# def __init__(self, goaltree: Graph):
# super().__init__(goaltree)
# self._open: bool = True
#
# def accept_ToggleOpenView(self, command: ToggleOpenView):
# self._open = not self._open
#
# def settings(self, key: str) -> Any:
# if key == "filter_open":
# return self._open
# return self.goaltree.settings(key)
#
# def reconfigure_from(self, origin: "Graph") -> None:
# super().reconfigure_from(origin)
# if not origin.settings("filter_open"):
# self.accept(ToggleOpenView())
#
# @with_key("open")
# def q(self, keys: str = "name") -> Dict[int, Any]:
# goals = self.goaltree.q(keys)
# result: Dict[int, Any] = {
# k: {}
# for k, v in goals.items()
# if not self._open or v["open"] or k in self.selections()
# }
# # goals without parents
# not_linked: Set[int] = set(g for g in result.keys() if g > 1)
# for goal_id in result:
# val = goals[goal_id]
# result[goal_id] = {k: v for k, v in val.items() if k != "edge"}
# if "edge" in keys:
# filtered_edges: List[Tuple[int, EdgeType]] = []
# for edge in val["edge"]:
# if edge[0] in result:
# filtered_edges.append(edge)
# if edge[0] > 1:
# not_linked.discard(edge[0])
# result[goal_id]["edge"] = filtered_edges
# if "edge" in keys:
# # here we know something about other layers (Zoom). I do not like it
# root_goals: Set[int] = set(result.keys()).intersection({1, -1})
# if root_goals:
# root_goal: int = root_goals.pop()
# for missing_goal in not_linked:
# result[root_goal]["edge"].append((missing_goal, EdgeType.BLOCKER))
# return result
#
# Path: siebenapp/tests/dsl.py
# class GoalPrototype:
# def _build_goal_prototype(goal_id, name, is_open, children, blockers, select):
# def open_(goal_id, name, children=None, blockers=None, select=None):
# def clos_(goal_id, name, children=None, blockers=None, select=None):
# def build_goaltree(*goal_prototypes, message_fn=None):
. Output only the next line. | ) |
Using the snippet: <|code_start|>
class WebSearchManager (object):
def __init__(self, typeIconPath):
self.docsetFolder = 'Docsets/WebSearch'
self.docsetIndexFileName = os.path.join(self.docsetFolder, 'WebSearch.db')
self.typeManager = TypeManager.TypeManager(typeIconPath)
self.connection = None
self.__createDocsetFolder()
self.__createInitialIndex()
def __createDocsetFolder(self):
if not os.path.exists(self.docsetFolder):
<|code_end|>
, determine the next line of code. You have imports:
import os
import sqlite3
import urllib
import requests
import ui
from PIL import Image
from Managers import TypeManager
and context (class names, function names, or code) available:
# Path: Managers/TypeManager.py
# class TypeManager (object):
# def __init__(self, typeIconPath):
# self.typeIconPath = typeIconPath
# self.types = self.__setup()
#
# def __setup(self):
# with open('types.json') as json_data:
# data = json.load(json_data)
# types = []
# for ty in data:
# t = Type()
# t.name = ty['name']
# t.plural = ty['plural']
# if 'aliases' in ty:
# t.aliases = ty['aliases']
# t.icon = self.__getTypeIconWithName(ty['name'])
# types.append(t)
# return types
#
# def __getTypeIconWithName(self, name):
# imgPath = os.path.join(os.path.abspath('.'), self.typeIconPath, name+'.png')
# if not os.path.exists(imgPath):
# imgPath = os.path.join(os.path.abspath('.'), self.typeIconPath, 'Unknown.png')
# return ui.Image.named(imgPath)
#
# def getTypeForName(self, name):
# for type in self.types:
# if type.name == name:
# return type
# for type in self.types:
# if name in type.aliases:
# return type
. Output only the next line. | os.mkdir(self.docsetFolder) |
Predict the next line for this snippet: <|code_start|>
@pytest.mark.parametrize("input, keys, output", [
(1, ["foo"], 1),
({"foo": 1}, ["foo"], 1)
])
<|code_end|>
with the help of current file imports:
import pytest
import re
from aioconsul.util import extract_attr, extract_pattern
and context from other files:
# Path: aioconsul/util.py
# def extract_attr(obj, *, keys):
# if isinstance(obj, Mapping):
# for key in keys:
# if key in obj:
# return obj[key]
# raise TypeError("%s not found in obj %s" % (keys, obj))
# return obj
#
# def extract_pattern(obj):
# """Extract pattern from str or re.compile object
#
# Returns:
# str: Extracted pattern
# """
# if obj is not None:
# return getattr(obj, 'pattern', obj)
# return obj
, which may contain function names, class names, or code. Output only the next line. | def test_extract(input, keys, output): |
Given the code snippet: <|code_start|>
@pytest.mark.parametrize("input, keys, output", [
(1, ["foo"], 1),
({"foo": 1}, ["foo"], 1)
])
def test_extract(input, keys, output):
assert extract_attr(input, keys=keys) == output
@pytest.mark.parametrize("input, keys", [
({"foo": 1}, ["bar"]),
])
def test_extract_error(input, keys):
<|code_end|>
, generate the next line using the imports in this file:
import pytest
import re
from aioconsul.util import extract_attr, extract_pattern
and context (functions, classes, or occasionally code) from other files:
# Path: aioconsul/util.py
# def extract_attr(obj, *, keys):
# if isinstance(obj, Mapping):
# for key in keys:
# if key in obj:
# return obj[key]
# raise TypeError("%s not found in obj %s" % (keys, obj))
# return obj
#
# def extract_pattern(obj):
# """Extract pattern from str or re.compile object
#
# Returns:
# str: Extracted pattern
# """
# if obj is not None:
# return getattr(obj, 'pattern', obj)
# return obj
. Output only the next line. | with pytest.raises(TypeError): |
Using the snippet: <|code_start|>
class RequestHandler:
def __init__(self, address, *, loop=None):
self.address = parse_addr(address, proto="http", host="localhost")
self.loop = loop or asyncio.get_event_loop()
self.session = aiohttp.ClientSession(loop=self.loop)
self.json_loader = json.loads
async def request(self, method, path, **kwargs):
url = "%s/%s" % (self.address.__str__(), path.lstrip("/"))
<|code_end|>
, determine the next line of code. You have imports:
import aiohttp
import asyncio
import json
from .addr import parse_addr
from .objs import Response
and context (class names, function names, or code) available:
# Path: aioconsul/common/addr.py
# def parse_addr(addr, *, proto=None, host=None):
# """Parses an address
#
# Returns:
# Address: the parsed address
# """
# port = None
#
# if isinstance(addr, Address):
# return addr
# elif isinstance(addr, str):
# if addr.startswith('http://'):
# proto, addr = 'http', addr[7:]
# if addr.startswith('udp://'):
# proto, addr = 'udp', addr[6:]
# elif addr.startswith('tcp://'):
# proto, addr = 'tcp', addr[6:]
# elif addr.startswith('unix://'):
# proto, addr = 'unix', addr[7:]
# a, _, b = addr.partition(':')
# host = a or host
# port = b or port
# elif isinstance(addr, (tuple, list)):
# # list is not good
# a, b = addr
# host = a or host
# port = b or port
# elif isinstance(addr, int):
# port = addr
# else:
# raise ValueError('bad value')
#
# if port is not None:
# port = int(port)
# return Address(proto, host, port)
#
# Path: aioconsul/common/objs.py
# class Response:
#
# def __init__(self, path, status, body, headers, method):
# self.path = path
# self.status = status
# self.body = body
# self.headers = headers
# self.method = method
#
# def __repr__(self):
# return "<%s(method=%r, path=%r, status=%r, body=%r, headers=%r)>" % (
# self.__class__.__name__,
# self.method,
# self.path,
# self.status,
# self.body,
# self.headers
# )
. Output only the next line. | async with self.session.request(method, url, **kwargs) as response: |
Using the snippet: <|code_start|>
class RequestHandler:
def __init__(self, address, *, loop=None):
self.address = parse_addr(address, proto="http", host="localhost")
self.loop = loop or asyncio.get_event_loop()
self.session = aiohttp.ClientSession(loop=self.loop)
self.json_loader = json.loads
async def request(self, method, path, **kwargs):
url = "%s/%s" % (self.address.__str__(), path.lstrip("/"))
async with self.session.request(method, url, **kwargs) as response:
if response.headers.get("Content-Type") == "application/json":
body = await response.json(encoding="utf-8",
loads=self.json_loader)
else:
body = await response.read()
return Response(path=path,
<|code_end|>
, determine the next line of code. You have imports:
import aiohttp
import asyncio
import json
from .addr import parse_addr
from .objs import Response
and context (class names, function names, or code) available:
# Path: aioconsul/common/addr.py
# def parse_addr(addr, *, proto=None, host=None):
# """Parses an address
#
# Returns:
# Address: the parsed address
# """
# port = None
#
# if isinstance(addr, Address):
# return addr
# elif isinstance(addr, str):
# if addr.startswith('http://'):
# proto, addr = 'http', addr[7:]
# if addr.startswith('udp://'):
# proto, addr = 'udp', addr[6:]
# elif addr.startswith('tcp://'):
# proto, addr = 'tcp', addr[6:]
# elif addr.startswith('unix://'):
# proto, addr = 'unix', addr[7:]
# a, _, b = addr.partition(':')
# host = a or host
# port = b or port
# elif isinstance(addr, (tuple, list)):
# # list is not good
# a, b = addr
# host = a or host
# port = b or port
# elif isinstance(addr, int):
# port = addr
# else:
# raise ValueError('bad value')
#
# if port is not None:
# port = int(port)
# return Address(proto, host, port)
#
# Path: aioconsul/common/objs.py
# class Response:
#
# def __init__(self, path, status, body, headers, method):
# self.path = path
# self.status = status
# self.body = body
# self.headers = headers
# self.method = method
#
# def __repr__(self):
# return "<%s(method=%r, path=%r, status=%r, body=%r, headers=%r)>" % (
# self.__class__.__name__,
# self.method,
# self.path,
# self.status,
# self.body,
# self.headers
# )
. Output only the next line. | status=response.status, |
Next line prediction: <|code_start|>
@pytest.mark.parametrize("input, expected", [
(None, (None, {})),
("foo", ("foo", {})),
({"ID": "foo"}, ("foo", {})),
({"Node": "foo"}, ("foo", {})),
({
"Node": {
"Node": "foobar",
"Address": "10.1.10.12",
"TaggedAddresses": {
"lan": "10.1.10.12",
"wan": "10.1.10.12"
}
},
"Service": {},
"Checks": []
}, ("foobar", {
"Node": "foobar",
"Address": "10.1.10.12",
<|code_end|>
. Use current file imports:
(import pytest
from aioconsul.client import util)
and context including class names, function names, or small code snippets from other files:
# Path: aioconsul/client/util.py
# def prepare_node(data):
# def prepare_service(data):
# def prepare_check(data):
. Output only the next line. | "TaggedAddresses": { |
Continue the code snippet: <|code_start|>
def bootstrap_devenv():
try:
os.makedirs(".devenv")
except OSError:
pass
if not os.path.exists(".devenv/buildrecipes-common"):
subprocess.check_call([
"git", "clone",
"http://github.com/simphony/buildrecipes-common.git",
".devenv/buildrecipes-common"
])
sys.path.insert(0, ".devenv/buildrecipes-common")
<|code_end|>
. Use current file imports:
import sys
import click
import os
import subprocess
import buildcommons as common # noqa
from packageinfo import BUILD, VERSION, NAME
and context (classes, functions, or code) from other files:
# Path: packageinfo.py
# BUILD = "1"
#
# VERSION = "0.8.0.dev0"
#
# NAME = "simphony"
. Output only the next line. | bootstrap_devenv() |
Given the code snippet: <|code_start|>
def bootstrap_devenv():
try:
os.makedirs(".devenv")
except OSError:
pass
if not os.path.exists(".devenv/buildrecipes-common"):
subprocess.check_call([
"git", "clone",
"http://github.com/simphony/buildrecipes-common.git",
<|code_end|>
, generate the next line using the imports in this file:
import sys
import click
import os
import subprocess
import buildcommons as common # noqa
from packageinfo import BUILD, VERSION, NAME
and context (functions, classes, or occasionally code) from other files:
# Path: packageinfo.py
# BUILD = "1"
#
# VERSION = "0.8.0.dev0"
#
# NAME = "simphony"
. Output only the next line. | ".devenv/buildrecipes-common" |
Using the snippet: <|code_start|>
def bootstrap_devenv():
try:
os.makedirs(".devenv")
except OSError:
pass
if not os.path.exists(".devenv/buildrecipes-common"):
subprocess.check_call([
"git", "clone",
"http://github.com/simphony/buildrecipes-common.git",
".devenv/buildrecipes-common"
])
sys.path.insert(0, ".devenv/buildrecipes-common")
bootstrap_devenv()
workspace = common.workspace()
common.edmenv_setup()
<|code_end|>
, determine the next line of code. You have imports:
import sys
import click
import os
import subprocess
import buildcommons as common # noqa
from packageinfo import BUILD, VERSION, NAME
and context (class names, function names, or code) available:
# Path: packageinfo.py
# BUILD = "1"
#
# VERSION = "0.8.0.dev0"
#
# NAME = "simphony"
. Output only the next line. | @click.group() |
Predict the next line after this snippet: <|code_start|> self.assertIsInstance(key, CUBA)
def test_initialization_with_keywords(self):
data = {key: index + 3 for index, key in enumerate(CUBA.__members__)}
container = DataContainer(**data)
self.assertEqual(
container, {key: index + 3 for index, key in enumerate(CUBA)})
for key in container:
self.assertIsInstance(key, CUBA)
def test_initialization_with_keywords_and_iterable(self):
data = {
key: 3 for index, key in enumerate(CUBA.__members__)
if key != str(CUBA("POTENTIAL_ENERGY"))[5:]}
container = DataContainer([(CUBA("POTENTIAL_ENERGY"), 23)], **data)
expected = {key: 3 for index, key in enumerate(CUBA)}
expected[CUBA("POTENTIAL_ENERGY")] = 23
self.assertDictEqual(container, expected)
for key in container:
self.assertIsInstance(key, CUBA)
def test_initialization_with_non_cuba_kwards(self):
with self.assertRaises(ValueError):
DataContainer(bar=5)
def test_initialization_with_non_cuba_dict(self):
with self.assertRaises(ValueError):
DataContainer({'foo': 5})
def test_initialization_with_non_cuba_iterable(self):
<|code_end|>
using the current file's imports:
import unittest
from simphony.core.cuba import CUBA
from simphony.core.data_container import DataContainer
and any relevant context from other files:
# Path: simphony/core/data_container.py
# class DataContainer(dict):
# """ A DataContainer instance
#
# The DataContainer object is implemented as a python dictionary whose keys
# are restricted to the instance's `restricted_keys`, default to the CUBA
# enum members.
#
# The data container can be initialized like a typical python dict
# using the mapping and iterables where the keys are CUBA enum members.
#
# For convenience keywords can be passed as capitalized CUBA enum members::
#
# >>> DataContainer(ACCELERATION=234) # CUBA.ACCELERATION is 22
# {<CUBA.ACCELERATION: 22>: 234}
#
# """
#
# def __init__(self, *args, **kwargs):
# """ Constructor.
# Initialization follows the behaviour of the python dict class.
# """
# super(DataContainer, self).__init__()
#
# # These are the allowed CUBA keys (faster to convert to set for lookup)
# self.restricted_keys = frozenset(CUBA)
#
# # Map CUBA enum name to CUBA enum
# # Used by assigning key using keyword name
# self._restricted_mapping = CUBA.__members__
#
# self.update(*args, **kwargs)
#
# def __setitem__(self, key, value):
# """ Set/Update the key value only when the key is a CUBA key.
#
# """
# if isinstance(key, CUBA) and key in self.restricted_keys:
# super(DataContainer, self).__setitem__(key, value)
# else:
# message = "Key {!r} is not in the supported CUBA keywords"
# raise ValueError(message.format(key))
#
# def update(self, *args, **kwargs):
# self._check_arguments(args, kwargs)
#
# if args and not hasattr(args[0], 'keys'):
# # args is an iterator
# for key, value in args[0]:
# self[key] = value
# elif args:
# mapping = args[0]
# if (isinstance(mapping, DataContainer) and
# mapping.restricted_keys == self.restricted_keys):
# super(DataContainer, self).update(mapping)
# else:
# self._check_mapping(mapping)
# super(DataContainer, self).update(mapping)
#
# super(DataContainer, self).update(
# {self._restricted_mapping[kwarg]: value
# for kwarg, value in kwargs.viewitems()})
#
# def _check_arguments(self, args, kwargs):
# """ Check for the right arguments.
#
# """
# # See if there are any non CUBA keys in the keyword arguments
# invalid_keys = [key for key in kwargs
# if key not in self._restricted_mapping]
# if invalid_keys:
# message = "Key(s) {!r} are not in the supported CUBA keywords"
# raise ValueError(message.format(invalid_keys))
# # Only one positional argument is allowed.
# if len(args) > 1:
# message = 'DataContainer expected at most 1 arguments, got {}'
# raise TypeError(message.format(len(args)))
#
# def _check_mapping(self, mapping):
# ''' Check if the keys in the mappings are all supported CUBA keys
#
# Parameters
# ----------
# mapping : Mapping
#
# Raises
# ------
# ValueError
# if any of the keys in the mappings is not supported
# '''
# invalid_keys = [key for key in mapping
# if (not isinstance(key, CUBA) or
# key not in self.restricted_keys)]
# if invalid_keys:
# message = 'Key(s) {!r} are not in the supported CUBA keywords'
# raise ValueError(message.format(invalid_keys))
. Output only the next line. | with self.assertRaises(ValueError): |
Based on the snippet: <|code_start|>from __future__ import print_function
dict_data = {key: 3 for key in CUBA}
data_container = DataContainer(dict_data)
indices = [key for key in CUBA]
random.shuffle(indices)
def data_container_setup():
return DataContainer(dict_data)
def iteration(container):
for i in container:
pass
<|code_end|>
, predict the immediate next line with the help of imports:
import random
from .util import bench
from simphony.core.data_container import DataContainer
from simphony.core.cuba import CUBA
and context (classes, functions, sometimes code) from other files:
# Path: bench/util.py
# def bench(stmt='pass', setup='pass', repeat=5, adjust_runs=True):
# """ BenchMark the function.
#
# """
# timer = Timer(stmt, setup)
# if adjust_runs:
# for i in range(100):
# number = 10**i
# time = timer.timeit(number)
# if time > 0.2:
# break
# else:
# number = 1
# times = [timer.timeit(number) for i in range(repeat)]
# message = '{} calls, best of {} repeats: {:f} sec per call'
# return message.format(number, repeat, min(times)/number)
#
# Path: simphony/core/data_container.py
# class DataContainer(dict):
# """ A DataContainer instance
#
# The DataContainer object is implemented as a python dictionary whose keys
# are restricted to the instance's `restricted_keys`, default to the CUBA
# enum members.
#
# The data container can be initialized like a typical python dict
# using the mapping and iterables where the keys are CUBA enum members.
#
# For convenience keywords can be passed as capitalized CUBA enum members::
#
# >>> DataContainer(ACCELERATION=234) # CUBA.ACCELERATION is 22
# {<CUBA.ACCELERATION: 22>: 234}
#
# """
#
# def __init__(self, *args, **kwargs):
# """ Constructor.
# Initialization follows the behaviour of the python dict class.
# """
# super(DataContainer, self).__init__()
#
# # These are the allowed CUBA keys (faster to convert to set for lookup)
# self.restricted_keys = frozenset(CUBA)
#
# # Map CUBA enum name to CUBA enum
# # Used by assigning key using keyword name
# self._restricted_mapping = CUBA.__members__
#
# self.update(*args, **kwargs)
#
# def __setitem__(self, key, value):
# """ Set/Update the key value only when the key is a CUBA key.
#
# """
# if isinstance(key, CUBA) and key in self.restricted_keys:
# super(DataContainer, self).__setitem__(key, value)
# else:
# message = "Key {!r} is not in the supported CUBA keywords"
# raise ValueError(message.format(key))
#
# def update(self, *args, **kwargs):
# self._check_arguments(args, kwargs)
#
# if args and not hasattr(args[0], 'keys'):
# # args is an iterator
# for key, value in args[0]:
# self[key] = value
# elif args:
# mapping = args[0]
# if (isinstance(mapping, DataContainer) and
# mapping.restricted_keys == self.restricted_keys):
# super(DataContainer, self).update(mapping)
# else:
# self._check_mapping(mapping)
# super(DataContainer, self).update(mapping)
#
# super(DataContainer, self).update(
# {self._restricted_mapping[kwarg]: value
# for kwarg, value in kwargs.viewitems()})
#
# def _check_arguments(self, args, kwargs):
# """ Check for the right arguments.
#
# """
# # See if there are any non CUBA keys in the keyword arguments
# invalid_keys = [key for key in kwargs
# if key not in self._restricted_mapping]
# if invalid_keys:
# message = "Key(s) {!r} are not in the supported CUBA keywords"
# raise ValueError(message.format(invalid_keys))
# # Only one positional argument is allowed.
# if len(args) > 1:
# message = 'DataContainer expected at most 1 arguments, got {}'
# raise TypeError(message.format(len(args)))
#
# def _check_mapping(self, mapping):
# ''' Check if the keys in the mappings are all supported CUBA keys
#
# Parameters
# ----------
# mapping : Mapping
#
# Raises
# ------
# ValueError
# if any of the keys in the mappings is not supported
# '''
# invalid_keys = [key for key in mapping
# if (not isinstance(key, CUBA) or
# key not in self.restricted_keys)]
# if invalid_keys:
# message = 'Key(s) {!r} are not in the supported CUBA keywords'
# raise ValueError(message.format(invalid_keys))
. Output only the next line. | def getitem_access(data, indices): |
Here is a snippet: <|code_start|>indices = [key for key in CUBA]
random.shuffle(indices)
def data_container_setup():
return DataContainer(dict_data)
def iteration(container):
for i in container:
pass
def getitem_access(data, indices):
return [data[index] for index in indices]
def setitem_with_CUBA_keys(data):
for item in CUBA:
data[item] = str(item)
return data
def main():
print("""
Benchmarking various operations between different data containers
.. note:
Only the relative time taken for each type of container within a
<|code_end|>
. Write the next line using the current file imports:
import random
from .util import bench
from simphony.core.data_container import DataContainer
from simphony.core.cuba import CUBA
and context from other files:
# Path: bench/util.py
# def bench(stmt='pass', setup='pass', repeat=5, adjust_runs=True):
# """ BenchMark the function.
#
# """
# timer = Timer(stmt, setup)
# if adjust_runs:
# for i in range(100):
# number = 10**i
# time = timer.timeit(number)
# if time > 0.2:
# break
# else:
# number = 1
# times = [timer.timeit(number) for i in range(repeat)]
# message = '{} calls, best of {} repeats: {:f} sec per call'
# return message.format(number, repeat, min(times)/number)
#
# Path: simphony/core/data_container.py
# class DataContainer(dict):
# """ A DataContainer instance
#
# The DataContainer object is implemented as a python dictionary whose keys
# are restricted to the instance's `restricted_keys`, default to the CUBA
# enum members.
#
# The data container can be initialized like a typical python dict
# using the mapping and iterables where the keys are CUBA enum members.
#
# For convenience keywords can be passed as capitalized CUBA enum members::
#
# >>> DataContainer(ACCELERATION=234) # CUBA.ACCELERATION is 22
# {<CUBA.ACCELERATION: 22>: 234}
#
# """
#
# def __init__(self, *args, **kwargs):
# """ Constructor.
# Initialization follows the behaviour of the python dict class.
# """
# super(DataContainer, self).__init__()
#
# # These are the allowed CUBA keys (faster to convert to set for lookup)
# self.restricted_keys = frozenset(CUBA)
#
# # Map CUBA enum name to CUBA enum
# # Used by assigning key using keyword name
# self._restricted_mapping = CUBA.__members__
#
# self.update(*args, **kwargs)
#
# def __setitem__(self, key, value):
# """ Set/Update the key value only when the key is a CUBA key.
#
# """
# if isinstance(key, CUBA) and key in self.restricted_keys:
# super(DataContainer, self).__setitem__(key, value)
# else:
# message = "Key {!r} is not in the supported CUBA keywords"
# raise ValueError(message.format(key))
#
# def update(self, *args, **kwargs):
# self._check_arguments(args, kwargs)
#
# if args and not hasattr(args[0], 'keys'):
# # args is an iterator
# for key, value in args[0]:
# self[key] = value
# elif args:
# mapping = args[0]
# if (isinstance(mapping, DataContainer) and
# mapping.restricted_keys == self.restricted_keys):
# super(DataContainer, self).update(mapping)
# else:
# self._check_mapping(mapping)
# super(DataContainer, self).update(mapping)
#
# super(DataContainer, self).update(
# {self._restricted_mapping[kwarg]: value
# for kwarg, value in kwargs.viewitems()})
#
# def _check_arguments(self, args, kwargs):
# """ Check for the right arguments.
#
# """
# # See if there are any non CUBA keys in the keyword arguments
# invalid_keys = [key for key in kwargs
# if key not in self._restricted_mapping]
# if invalid_keys:
# message = "Key(s) {!r} are not in the supported CUBA keywords"
# raise ValueError(message.format(invalid_keys))
# # Only one positional argument is allowed.
# if len(args) > 1:
# message = 'DataContainer expected at most 1 arguments, got {}'
# raise TypeError(message.format(len(args)))
#
# def _check_mapping(self, mapping):
# ''' Check if the keys in the mappings are all supported CUBA keys
#
# Parameters
# ----------
# mapping : Mapping
#
# Raises
# ------
# ValueError
# if any of the keys in the mappings is not supported
# '''
# invalid_keys = [key for key in mapping
# if (not isinstance(key, CUBA) or
# key not in self.restricted_keys)]
# if invalid_keys:
# message = 'Key(s) {!r} are not in the supported CUBA keywords'
# raise ValueError(message.format(invalid_keys))
, which may include functions, classes, or code. Output only the next line. | section is comparable. |
Continue the code snippet: <|code_start|>
# Read description
with open('README.rst', 'r') as readme:
README_TEXT = readme.read()
# Install the compiler
subprocess.check_call(["pip", "install", "-r", "build_requirements.txt"])
def create_ontology_classes():
ontology_dir = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"ontology")
if not os.path.exists(ontology_dir):
print("Cannot find ontology dir files in {}".format(ontology_dir))
raise RuntimeError("Unrecoverable error.")
print("Building classes from ontology")
cmd_args = ["simphony-meta-generate",
ontology_dir,
"simphony",
"--overwrite"]
<|code_end|>
. Use current file imports:
import os
import subprocess
from subprocess import check_call
from setuptools import setup
from setuptools.command.build_py import build_py
from setuptools.command.develop import develop
from packageinfo import VERSION, NAME
and context (classes, functions, or code) from other files:
# Path: packageinfo.py
# VERSION = "0.8.0.dev0"
#
# NAME = "simphony"
. Output only the next line. | check_call(cmd_args) |
Given snippet: <|code_start|>
# Read description
with open('README.rst', 'r') as readme:
README_TEXT = readme.read()
# Install the compiler
subprocess.check_call(["pip", "install", "-r", "build_requirements.txt"])
def create_ontology_classes():
ontology_dir = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"ontology")
if not os.path.exists(ontology_dir):
print("Cannot find ontology dir files in {}".format(ontology_dir))
raise RuntimeError("Unrecoverable error.")
print("Building classes from ontology")
cmd_args = ["simphony-meta-generate",
ontology_dir,
"simphony",
"--overwrite"]
check_call(cmd_args)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import subprocess
from subprocess import check_call
from setuptools import setup
from setuptools.command.build_py import build_py
from setuptools.command.develop import develop
from packageinfo import VERSION, NAME
and context:
# Path: packageinfo.py
# VERSION = "0.8.0.dev0"
#
# NAME = "simphony"
which might include code, classes, or functions. Output only the next line. | class Build(build_py): |
Given snippet: <|code_start|>try:
PYOMO3 = False
except ImportError:
PYOMO3 = True
base_directory = os.path.join('data', 'moosh')
building_shapefile = os.path.join(base_directory, 'building')
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pyomo.environ
import coopr.environ
import matplotlib.pyplot as plt
import os
import pandas as pd
from pyomo.opt.base import SolverFactory
from coopr.opt.base import SolverFactory
from operator import itemgetter
from rivus.utils import pandashp as pdshp
from rivus.main import rivus
and context:
# Path: rivus/utils/pandashp.py
# def read_shp(filename):
# def write_shp(filename, dataframe, write_index=True):
# def match_vertices_and_edges(vertices, edges, vertex_cols=('Vertex1', 'Vertex2')):
# def find_closest_edge(polygons, edges, to_attr='index', column='nearest'):
# def bounds(df):
# def total_bounds(df):
#
# Path: rivus/main/rivus.py
# COLORS = { # (R,G,B) tuples with range (0-255)
# # defaults
# 'base': (192, 192, 192),
# 'building': (192, 192, 192),
# 'decoration': (128, 128, 128),
# # commodities
# 'Heat': (230, 112, 36),
# 'Cool': (0, 0, 255),
# 'Elec': (255, 170, 0),
# 'Demand': (0, 255, 0),
# 'Gas': (128, 64, 0),
# # buildings
# 'industrial': (240, 198, 116),
# 'residential': (181, 189, 104),
# 'commercial': (129, 162, 190),
# 'basin': (110, 75, 56),
# 'chapel': (177, 121, 91),
# 'church': (177, 121, 91),
# 'farm': (202, 178, 214),
# 'farm_auxiliary': (106, 61, 154),
# 'garage': (253, 191, 111),
# 'greenhouse': (255, 127, 0),
# 'hospital': (129, 221, 190),
# 'hotel': (227, 26, 28),
# 'house': (181, 189, 104),
# 'office': (129, 162, 190),
# 'public': (129, 162, 190),
# 'restaurant': (227, 26, 28),
# 'retail': (129, 162, 190),
# 'school': (29, 103, 214),
# 'warehouse': (98, 134, 6),
# }
# def read_excel(filepath):
# def create_model(data, vertex, edge, peak_multiplier=None,
# hub_only_in_edge=True):
# def multiply_by_area_demand(series, column):
# def peak_satisfaction_rule(m, i, j, co, t):
# def edge_equation_rule(m, i, j, co, t):
# def arc_flow_by_capacity_rule(m, i, j, co, t):
# def arc_flow_unidirectionality_rule(m, i, j, co, t):
# def arc_unidirectionality_rule(m, i, j, co, t):
# def edge_capacity_rule(m, i, j, co):
# def hub_supply_rule(m, i, j, co, t):
# def hub_output_by_capacity_rule(m, i, j, h, t):
# def hub_capacity_rule(m, i, j, h):
# def vertex_equation_rule(m, v, co, t):
# def source_vertices_rule(m, v, co, t):
# def commodity_maximum_rule(m, co):
# def process_throughput_by_capacity_rule(m, v, p, t):
# def process_capacity_min_rule(m, v, p):
# def process_capacity_max_rule(m, v, p):
# def process_input_rule(m, v, p, co, t):
# def process_output_rule(m, v, p, co, t):
# def def_costs_rule(m, cost_type):
# def obj_rule(m):
# def hub_balance(m, i, j, co, t):
# def flow_balance(m, v, co, t):
# def process_balance(m, v, co, t):
# def find_matching_edge(m, i, j):
# def line_length(line):
# def pairs(lst):
# def get_entity(instance, name):
# def get_entities(instance, names):
# def list_entities(instance, entity_type):
# def filter_by_type(entity, entity_type):
# def get_onset_names(entity):
# def get_constants(prob):
# def get_timeseries(prob):
# def plot(prob, commodity, plot_demand=False, mapscale=False, tick_labels=True,
# annotations=True, buildings=None, shapefiles=None, decoration=True,
# boundary=False):
# def _calc_xytext_offset(line):
# def result_figures(prob, file_basename, buildings=None, shapefiles=None):
# def report(prob, filename):
# def save_log(result, filename):
# def save(prob, filepath):
# def load(filepath):
which might include code, classes, or functions. Output only the next line. | edge_shapefile = os.path.join(base_directory, 'edge') |
Here is a snippet: <|code_start|>
# Consts
inp_dir = os.path.normpath(r"C:\Users\Kristof\GIT\Masterarbeit\rivus\data\haag15")
out_dir = os.path.normpath(r"C:\Users\Kristof\GIT\Masterarbeit\rivus\data\haag15")
EPSG_XY = 32632
# IN
<|code_end|>
. Write the next line using the current file imports:
import geopandas
import pandas as pd
import shutil
import os
from ..utils import pandashp as pdshp
and context from other files:
# Path: rivus/utils/pandashp.py
# def read_shp(filename):
# def write_shp(filename, dataframe, write_index=True):
# def match_vertices_and_edges(vertices, edges, vertex_cols=('Vertex1', 'Vertex2')):
# def find_closest_edge(polygons, edges, to_attr='index', column='nearest'):
# def bounds(df):
# def total_bounds(df):
, which may include functions, classes, or code. Output only the next line. | buildings_apath = os.path.join(inp_dir, 'building.shp') |
Here is a snippet: <|code_start|> FutureWarning, stacklevel=2)
COLORS = { # (R,G,B) tuples with range (0-255)
# defaults
'base': (192, 192, 192),
'building': (192, 192, 192),
'decoration': (128, 128, 128),
# commodities
'Heat': (230, 112, 36),
'Cool': (0, 0, 255),
'Elec': (255, 170, 0),
'Demand': (0, 255, 0),
'Gas': (128, 64, 0),
# buildings
'industrial': (240, 198, 116),
'residential': (181, 189, 104),
'commercial': (129, 162, 190),
'basin': (110, 75, 56),
'chapel': (177, 121, 91),
'church': (177, 121, 91),
'farm': (202, 178, 214),
'farm_auxiliary': (106, 61, 154),
'garage': (253, 191, 111),
'greenhouse': (255, 127, 0),
'hospital': (129, 221, 190),
'hotel': (227, 26, 28),
'house': (181, 189, 104),
'office': (129, 162, 190),
'public': (129, 162, 190),
<|code_end|>
. Write the next line using the current file imports:
import warnings
import pyomo.core as pyomo
import coopr.pyomo as pyomo
import math
import matplotlib.pyplot as plt
import matplotlib.patheffects as pe
import numpy as np
import os
import pandas as pd
import warnings
import gzip
import cPickle as pickle
import pickle
import gzip
import cPickle as pickle
import pickle
from ..utils import pandashp as pdshp
from geopy.distance import distance
from mpl_toolkits.basemap import Basemap
from collections import defaultdict
from matplotlib.patches import Polygon
from matplotlib.collections import PatchCollection
and context from other files:
# Path: rivus/utils/pandashp.py
# def read_shp(filename):
# def write_shp(filename, dataframe, write_index=True):
# def match_vertices_and_edges(vertices, edges, vertex_cols=('Vertex1', 'Vertex2')):
# def find_closest_edge(polygons, edges, to_attr='index', column='nearest'):
# def bounds(df):
# def total_bounds(df):
, which may include functions, classes, or code. Output only the next line. | 'restaurant': (227, 26, 28), |
Predict the next line for this snippet: <|code_start|>try:
PYOMO3 = False
except ImportError:
PYOMO3 = True
base_directory = os.path.join('data', 'haag')
building_shapefile = os.path.join(base_directory, 'building')
edge_shapefile = os.path.join(base_directory, 'edge')
<|code_end|>
with the help of current file imports:
import matplotlib.pyplot as plt
import os
import pandas as pd
import pyomo.environ
import coopr.environ
from rivus.utils import pandashp as pdshp
from rivus.main import rivus
from pyomo.opt.base import SolverFactory
from coopr.opt.base import SolverFactory
and context from other files:
# Path: rivus/utils/pandashp.py
# def read_shp(filename):
# def write_shp(filename, dataframe, write_index=True):
# def match_vertices_and_edges(vertices, edges, vertex_cols=('Vertex1', 'Vertex2')):
# def find_closest_edge(polygons, edges, to_attr='index', column='nearest'):
# def bounds(df):
# def total_bounds(df):
#
# Path: rivus/main/rivus.py
# COLORS = { # (R,G,B) tuples with range (0-255)
# # defaults
# 'base': (192, 192, 192),
# 'building': (192, 192, 192),
# 'decoration': (128, 128, 128),
# # commodities
# 'Heat': (230, 112, 36),
# 'Cool': (0, 0, 255),
# 'Elec': (255, 170, 0),
# 'Demand': (0, 255, 0),
# 'Gas': (128, 64, 0),
# # buildings
# 'industrial': (240, 198, 116),
# 'residential': (181, 189, 104),
# 'commercial': (129, 162, 190),
# 'basin': (110, 75, 56),
# 'chapel': (177, 121, 91),
# 'church': (177, 121, 91),
# 'farm': (202, 178, 214),
# 'farm_auxiliary': (106, 61, 154),
# 'garage': (253, 191, 111),
# 'greenhouse': (255, 127, 0),
# 'hospital': (129, 221, 190),
# 'hotel': (227, 26, 28),
# 'house': (181, 189, 104),
# 'office': (129, 162, 190),
# 'public': (129, 162, 190),
# 'restaurant': (227, 26, 28),
# 'retail': (129, 162, 190),
# 'school': (29, 103, 214),
# 'warehouse': (98, 134, 6),
# }
# def read_excel(filepath):
# def create_model(data, vertex, edge, peak_multiplier=None,
# hub_only_in_edge=True):
# def multiply_by_area_demand(series, column):
# def peak_satisfaction_rule(m, i, j, co, t):
# def edge_equation_rule(m, i, j, co, t):
# def arc_flow_by_capacity_rule(m, i, j, co, t):
# def arc_flow_unidirectionality_rule(m, i, j, co, t):
# def arc_unidirectionality_rule(m, i, j, co, t):
# def edge_capacity_rule(m, i, j, co):
# def hub_supply_rule(m, i, j, co, t):
# def hub_output_by_capacity_rule(m, i, j, h, t):
# def hub_capacity_rule(m, i, j, h):
# def vertex_equation_rule(m, v, co, t):
# def source_vertices_rule(m, v, co, t):
# def commodity_maximum_rule(m, co):
# def process_throughput_by_capacity_rule(m, v, p, t):
# def process_capacity_min_rule(m, v, p):
# def process_capacity_max_rule(m, v, p):
# def process_input_rule(m, v, p, co, t):
# def process_output_rule(m, v, p, co, t):
# def def_costs_rule(m, cost_type):
# def obj_rule(m):
# def hub_balance(m, i, j, co, t):
# def flow_balance(m, v, co, t):
# def process_balance(m, v, co, t):
# def find_matching_edge(m, i, j):
# def line_length(line):
# def pairs(lst):
# def get_entity(instance, name):
# def get_entities(instance, names):
# def list_entities(instance, entity_type):
# def filter_by_type(entity, entity_type):
# def get_onset_names(entity):
# def get_constants(prob):
# def get_timeseries(prob):
# def plot(prob, commodity, plot_demand=False, mapscale=False, tick_labels=True,
# annotations=True, buildings=None, shapefiles=None, decoration=True,
# boundary=False):
# def _calc_xytext_offset(line):
# def result_figures(prob, file_basename, buildings=None, shapefiles=None):
# def report(prob, filename):
# def save_log(result, filename):
# def save(prob, filepath):
# def load(filepath):
, which may contain function names, class names, or code. Output only the next line. | vertex_shapefile = os.path.join(base_directory, 'vertex') |
Based on the snippet: <|code_start|>try:
PYOMO3 = False
except ImportError:
PYOMO3 = True
base_directory = os.path.join('data', 'haag')
building_shapefile = os.path.join(base_directory, 'building')
edge_shapefile = os.path.join(base_directory, 'edge')
vertex_shapefile = os.path.join(base_directory, 'vertex')
data_spreadsheet = os.path.join(base_directory, 'data.xlsx')
# scenarios
<|code_end|>
, predict the immediate next line with the help of imports:
import matplotlib.pyplot as plt
import os
import pandas as pd
import pyomo.environ
import coopr.environ
from rivus.utils import pandashp as pdshp
from rivus.main import rivus
from pyomo.opt.base import SolverFactory
from coopr.opt.base import SolverFactory
and context (classes, functions, sometimes code) from other files:
# Path: rivus/utils/pandashp.py
# def read_shp(filename):
# def write_shp(filename, dataframe, write_index=True):
# def match_vertices_and_edges(vertices, edges, vertex_cols=('Vertex1', 'Vertex2')):
# def find_closest_edge(polygons, edges, to_attr='index', column='nearest'):
# def bounds(df):
# def total_bounds(df):
#
# Path: rivus/main/rivus.py
# COLORS = { # (R,G,B) tuples with range (0-255)
# # defaults
# 'base': (192, 192, 192),
# 'building': (192, 192, 192),
# 'decoration': (128, 128, 128),
# # commodities
# 'Heat': (230, 112, 36),
# 'Cool': (0, 0, 255),
# 'Elec': (255, 170, 0),
# 'Demand': (0, 255, 0),
# 'Gas': (128, 64, 0),
# # buildings
# 'industrial': (240, 198, 116),
# 'residential': (181, 189, 104),
# 'commercial': (129, 162, 190),
# 'basin': (110, 75, 56),
# 'chapel': (177, 121, 91),
# 'church': (177, 121, 91),
# 'farm': (202, 178, 214),
# 'farm_auxiliary': (106, 61, 154),
# 'garage': (253, 191, 111),
# 'greenhouse': (255, 127, 0),
# 'hospital': (129, 221, 190),
# 'hotel': (227, 26, 28),
# 'house': (181, 189, 104),
# 'office': (129, 162, 190),
# 'public': (129, 162, 190),
# 'restaurant': (227, 26, 28),
# 'retail': (129, 162, 190),
# 'school': (29, 103, 214),
# 'warehouse': (98, 134, 6),
# }
# def read_excel(filepath):
# def create_model(data, vertex, edge, peak_multiplier=None,
# hub_only_in_edge=True):
# def multiply_by_area_demand(series, column):
# def peak_satisfaction_rule(m, i, j, co, t):
# def edge_equation_rule(m, i, j, co, t):
# def arc_flow_by_capacity_rule(m, i, j, co, t):
# def arc_flow_unidirectionality_rule(m, i, j, co, t):
# def arc_unidirectionality_rule(m, i, j, co, t):
# def edge_capacity_rule(m, i, j, co):
# def hub_supply_rule(m, i, j, co, t):
# def hub_output_by_capacity_rule(m, i, j, h, t):
# def hub_capacity_rule(m, i, j, h):
# def vertex_equation_rule(m, v, co, t):
# def source_vertices_rule(m, v, co, t):
# def commodity_maximum_rule(m, co):
# def process_throughput_by_capacity_rule(m, v, p, t):
# def process_capacity_min_rule(m, v, p):
# def process_capacity_max_rule(m, v, p):
# def process_input_rule(m, v, p, co, t):
# def process_output_rule(m, v, p, co, t):
# def def_costs_rule(m, cost_type):
# def obj_rule(m):
# def hub_balance(m, i, j, co, t):
# def flow_balance(m, v, co, t):
# def process_balance(m, v, co, t):
# def find_matching_edge(m, i, j):
# def line_length(line):
# def pairs(lst):
# def get_entity(instance, name):
# def get_entities(instance, names):
# def list_entities(instance, entity_type):
# def filter_by_type(entity, entity_type):
# def get_onset_names(entity):
# def get_constants(prob):
# def get_timeseries(prob):
# def plot(prob, commodity, plot_demand=False, mapscale=False, tick_labels=True,
# annotations=True, buildings=None, shapefiles=None, decoration=True,
# boundary=False):
# def _calc_xytext_offset(line):
# def result_figures(prob, file_basename, buildings=None, shapefiles=None):
# def report(prob, filename):
# def save_log(result, filename):
# def save(prob, filepath):
# def load(filepath):
. Output only the next line. | def scenario_base(data, vertex, edge): |
Predict the next line for this snippet: <|code_start|>try:
PYOMO3 = False
except ImportError:
PYOMO3 = True
base_directory = os.path.join('data', 'haag15')
building_shapefile = os.path.join(base_directory, 'building')
edge_shapefile = os.path.join(base_directory, 'edge')
to_edge_shapefile = os.path.join(base_directory, 'to_edge')
vertex_shapefile = os.path.join(base_directory, 'vertex')
data_spreadsheet = os.path.join(base_directory, 'data.xlsx')
peak_demand_prefactor = rivus.load('urbs-peak-demand-reduction.pgz')
<|code_end|>
with the help of current file imports:
import pyomo.environ
import coopr.environ
import geopandas
import os
import pandas as pd
from pyomo.opt.base import SolverFactory
from coopr.opt.base import SolverFactory
from datetime import datetime
from rivus.utils import pandashp as pdshp
from rivus.main import rivus
and context from other files:
# Path: rivus/utils/pandashp.py
# def read_shp(filename):
# def write_shp(filename, dataframe, write_index=True):
# def match_vertices_and_edges(vertices, edges, vertex_cols=('Vertex1', 'Vertex2')):
# def find_closest_edge(polygons, edges, to_attr='index', column='nearest'):
# def bounds(df):
# def total_bounds(df):
#
# Path: rivus/main/rivus.py
# COLORS = { # (R,G,B) tuples with range (0-255)
# # defaults
# 'base': (192, 192, 192),
# 'building': (192, 192, 192),
# 'decoration': (128, 128, 128),
# # commodities
# 'Heat': (230, 112, 36),
# 'Cool': (0, 0, 255),
# 'Elec': (255, 170, 0),
# 'Demand': (0, 255, 0),
# 'Gas': (128, 64, 0),
# # buildings
# 'industrial': (240, 198, 116),
# 'residential': (181, 189, 104),
# 'commercial': (129, 162, 190),
# 'basin': (110, 75, 56),
# 'chapel': (177, 121, 91),
# 'church': (177, 121, 91),
# 'farm': (202, 178, 214),
# 'farm_auxiliary': (106, 61, 154),
# 'garage': (253, 191, 111),
# 'greenhouse': (255, 127, 0),
# 'hospital': (129, 221, 190),
# 'hotel': (227, 26, 28),
# 'house': (181, 189, 104),
# 'office': (129, 162, 190),
# 'public': (129, 162, 190),
# 'restaurant': (227, 26, 28),
# 'retail': (129, 162, 190),
# 'school': (29, 103, 214),
# 'warehouse': (98, 134, 6),
# }
# def read_excel(filepath):
# def create_model(data, vertex, edge, peak_multiplier=None,
# hub_only_in_edge=True):
# def multiply_by_area_demand(series, column):
# def peak_satisfaction_rule(m, i, j, co, t):
# def edge_equation_rule(m, i, j, co, t):
# def arc_flow_by_capacity_rule(m, i, j, co, t):
# def arc_flow_unidirectionality_rule(m, i, j, co, t):
# def arc_unidirectionality_rule(m, i, j, co, t):
# def edge_capacity_rule(m, i, j, co):
# def hub_supply_rule(m, i, j, co, t):
# def hub_output_by_capacity_rule(m, i, j, h, t):
# def hub_capacity_rule(m, i, j, h):
# def vertex_equation_rule(m, v, co, t):
# def source_vertices_rule(m, v, co, t):
# def commodity_maximum_rule(m, co):
# def process_throughput_by_capacity_rule(m, v, p, t):
# def process_capacity_min_rule(m, v, p):
# def process_capacity_max_rule(m, v, p):
# def process_input_rule(m, v, p, co, t):
# def process_output_rule(m, v, p, co, t):
# def def_costs_rule(m, cost_type):
# def obj_rule(m):
# def hub_balance(m, i, j, co, t):
# def flow_balance(m, v, co, t):
# def process_balance(m, v, co, t):
# def find_matching_edge(m, i, j):
# def line_length(line):
# def pairs(lst):
# def get_entity(instance, name):
# def get_entities(instance, names):
# def list_entities(instance, entity_type):
# def filter_by_type(entity, entity_type):
# def get_onset_names(entity):
# def get_constants(prob):
# def get_timeseries(prob):
# def plot(prob, commodity, plot_demand=False, mapscale=False, tick_labels=True,
# annotations=True, buildings=None, shapefiles=None, decoration=True,
# boundary=False):
# def _calc_xytext_offset(line):
# def result_figures(prob, file_basename, buildings=None, shapefiles=None):
# def report(prob, filename):
# def save_log(result, filename):
# def save(prob, filepath):
# def load(filepath):
, which may contain function names, class names, or code. Output only the next line. | def scale_peak_demand(model, multiplier): |
Predict the next line after this snippet: <|code_start|>
# Consts
work_dir = os.path.normpath(r"C:\Users\Kristof\GIT\Masterarbeit\rivus\data\haag15")
EPSG_XY = 32632
# IN
streets_filename = 'streets.shp'
streets_filename_abs = os.path.join(work_dir, 'streets.shp')
# OUT
<|code_end|>
using the current file's imports:
import os
import geopandas
from ..utils import pandashp
from ..utils import shapelytools
from ..utils import skeletrontools
and any relevant context from other files:
# Path: rivus/utils/pandashp.py
# def read_shp(filename):
# def write_shp(filename, dataframe, write_index=True):
# def match_vertices_and_edges(vertices, edges, vertex_cols=('Vertex1', 'Vertex2')):
# def find_closest_edge(polygons, edges, to_attr='index', column='nearest'):
# def bounds(df):
# def total_bounds(df):
#
# Path: rivus/utils/shapelytools.py
# def endpoints_from_lines(lines):
# def vertices_from_lines(lines):
# def snapping_vertexis_from_lines(lines, closeness_limit):
# def prune_short_lines(lines, min_length):
# def neighbors(lines, of):
# def bend_towards(line, where, to):
# def snappy_endings(lines, max_distance):
# def nearest_neighbor_within(others, point, max_distance):
# def find_isolated_endpoints(lines):
# def closest_object(geometries, point):
# def project_point_to_line(point, line_start, line_end):
# def pairs(lst):
# def project_point_to_object(point, geometry):
# def one_linestring_per_intersection(lines):
# def linemerge(linestrings_or_multilinestrings):
#
# Path: rivus/utils/skeletrontools.py
# def select_biggest_polygon_from_multipolygon(multi_polygon):
# def extract_lines_from_graph(graphs):
# def skeletonize(roads, buffer_length=60,
# dissolve_length=30,
# simplify_length=30,
# buffer_resolution=2,
# psg_length=150):
. Output only the next line. | edge_apath = os.path.join(work_dir, 'edgeout.shp') |
Given snippet: <|code_start|>streets_filename_abs = os.path.join(work_dir, 'streets.shp')
# OUT
edge_apath = os.path.join(work_dir, 'edgeout.shp')
vertex_apath = os.path.join(work_dir, 'vertexout.shp')
streets = geopandas.read_file(streets_filename)
streets = streets.to_crs(epsg=EPSG_XY) # EPSG:32632 == UTM Zone 32N (Germany!)
# filter away roads by type
road_types = ['motorway', 'motorway_link', 'primary', 'primary_link',
'secondary', 'secondary_link', 'tertiary', 'tertiary_link',
'residential', 'living_street', 'service', 'unclassified']
streets = streets[streets['type'].isin(road_types)]
skeleton = skeletrontools.skeletonize(streets,
buffer_length=30,
dissolve_length=15,
simplify_length=30)
skeleton = shapelytools.one_linestring_per_intersection(skeleton)
skeleton = shapelytools.snappy_endings(skeleton, max_distance=100)
skeleton = shapelytools.one_linestring_per_intersection(skeleton)
skeleton = shapelytools.prune_short_lines(skeleton, min_length=55)
# convert back to GeoPandas
edge = geopandas.GeoDataFrame(geometry=skeleton, crs=streets.crs)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import geopandas
from ..utils import pandashp
from ..utils import shapelytools
from ..utils import skeletrontools
and context:
# Path: rivus/utils/pandashp.py
# def read_shp(filename):
# def write_shp(filename, dataframe, write_index=True):
# def match_vertices_and_edges(vertices, edges, vertex_cols=('Vertex1', 'Vertex2')):
# def find_closest_edge(polygons, edges, to_attr='index', column='nearest'):
# def bounds(df):
# def total_bounds(df):
#
# Path: rivus/utils/shapelytools.py
# def endpoints_from_lines(lines):
# def vertices_from_lines(lines):
# def snapping_vertexis_from_lines(lines, closeness_limit):
# def prune_short_lines(lines, min_length):
# def neighbors(lines, of):
# def bend_towards(line, where, to):
# def snappy_endings(lines, max_distance):
# def nearest_neighbor_within(others, point, max_distance):
# def find_isolated_endpoints(lines):
# def closest_object(geometries, point):
# def project_point_to_line(point, line_start, line_end):
# def pairs(lst):
# def project_point_to_object(point, geometry):
# def one_linestring_per_intersection(lines):
# def linemerge(linestrings_or_multilinestrings):
#
# Path: rivus/utils/skeletrontools.py
# def select_biggest_polygon_from_multipolygon(multi_polygon):
# def extract_lines_from_graph(graphs):
# def skeletonize(roads, buffer_length=60,
# dissolve_length=30,
# simplify_length=30,
# buffer_resolution=2,
# psg_length=150):
which might include code, classes, or functions. Output only the next line. | edge = edge.to_crs(epsg=4326) # World Geodetic System (WGS84) |
Given snippet: <|code_start|>
# Consts
work_dir = os.path.normpath(r"C:\Users\Kristof\GIT\Masterarbeit\rivus\data\haag15")
EPSG_XY = 32632
# IN
streets_filename = 'streets.shp'
streets_filename_abs = os.path.join(work_dir, 'streets.shp')
# OUT
edge_apath = os.path.join(work_dir, 'edgeout.shp')
vertex_apath = os.path.join(work_dir, 'vertexout.shp')
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import geopandas
from ..utils import pandashp
from ..utils import shapelytools
from ..utils import skeletrontools
and context:
# Path: rivus/utils/pandashp.py
# def read_shp(filename):
# def write_shp(filename, dataframe, write_index=True):
# def match_vertices_and_edges(vertices, edges, vertex_cols=('Vertex1', 'Vertex2')):
# def find_closest_edge(polygons, edges, to_attr='index', column='nearest'):
# def bounds(df):
# def total_bounds(df):
#
# Path: rivus/utils/shapelytools.py
# def endpoints_from_lines(lines):
# def vertices_from_lines(lines):
# def snapping_vertexis_from_lines(lines, closeness_limit):
# def prune_short_lines(lines, min_length):
# def neighbors(lines, of):
# def bend_towards(line, where, to):
# def snappy_endings(lines, max_distance):
# def nearest_neighbor_within(others, point, max_distance):
# def find_isolated_endpoints(lines):
# def closest_object(geometries, point):
# def project_point_to_line(point, line_start, line_end):
# def pairs(lst):
# def project_point_to_object(point, geometry):
# def one_linestring_per_intersection(lines):
# def linemerge(linestrings_or_multilinestrings):
#
# Path: rivus/utils/skeletrontools.py
# def select_biggest_polygon_from_multipolygon(multi_polygon):
# def extract_lines_from_graph(graphs):
# def skeletonize(roads, buffer_length=60,
# dissolve_length=30,
# simplify_length=30,
# buffer_resolution=2,
# psg_length=150):
which might include code, classes, or functions. Output only the next line. | streets = geopandas.read_file(streets_filename) |
Given the following code snippet before the placeholder: <|code_start|>try:
PYOMO3 = False
except ImportError:
PYOMO3 = True
base_directory = os.path.join('data', 'mnl')
building_shapefile = os.path.join(base_directory, 'building')
edge_shapefile = os.path.join(base_directory, 'edge')
vertex_shapefile = os.path.join(base_directory, 'vertex')
<|code_end|>
, predict the next line using imports from the current file:
import pyomo.environ
import coopr.environ
import matplotlib.pyplot as plt
import os
import pandas as pd
from pyomo.opt.base import SolverFactory
from coopr.opt.base import SolverFactory
from rivus.utils import pandashp as pdshp
from rivus.main import rivus
and context including class names, function names, and sometimes code from other files:
# Path: rivus/utils/pandashp.py
# def read_shp(filename):
# def write_shp(filename, dataframe, write_index=True):
# def match_vertices_and_edges(vertices, edges, vertex_cols=('Vertex1', 'Vertex2')):
# def find_closest_edge(polygons, edges, to_attr='index', column='nearest'):
# def bounds(df):
# def total_bounds(df):
#
# Path: rivus/main/rivus.py
# COLORS = { # (R,G,B) tuples with range (0-255)
# # defaults
# 'base': (192, 192, 192),
# 'building': (192, 192, 192),
# 'decoration': (128, 128, 128),
# # commodities
# 'Heat': (230, 112, 36),
# 'Cool': (0, 0, 255),
# 'Elec': (255, 170, 0),
# 'Demand': (0, 255, 0),
# 'Gas': (128, 64, 0),
# # buildings
# 'industrial': (240, 198, 116),
# 'residential': (181, 189, 104),
# 'commercial': (129, 162, 190),
# 'basin': (110, 75, 56),
# 'chapel': (177, 121, 91),
# 'church': (177, 121, 91),
# 'farm': (202, 178, 214),
# 'farm_auxiliary': (106, 61, 154),
# 'garage': (253, 191, 111),
# 'greenhouse': (255, 127, 0),
# 'hospital': (129, 221, 190),
# 'hotel': (227, 26, 28),
# 'house': (181, 189, 104),
# 'office': (129, 162, 190),
# 'public': (129, 162, 190),
# 'restaurant': (227, 26, 28),
# 'retail': (129, 162, 190),
# 'school': (29, 103, 214),
# 'warehouse': (98, 134, 6),
# }
# def read_excel(filepath):
# def create_model(data, vertex, edge, peak_multiplier=None,
# hub_only_in_edge=True):
# def multiply_by_area_demand(series, column):
# def peak_satisfaction_rule(m, i, j, co, t):
# def edge_equation_rule(m, i, j, co, t):
# def arc_flow_by_capacity_rule(m, i, j, co, t):
# def arc_flow_unidirectionality_rule(m, i, j, co, t):
# def arc_unidirectionality_rule(m, i, j, co, t):
# def edge_capacity_rule(m, i, j, co):
# def hub_supply_rule(m, i, j, co, t):
# def hub_output_by_capacity_rule(m, i, j, h, t):
# def hub_capacity_rule(m, i, j, h):
# def vertex_equation_rule(m, v, co, t):
# def source_vertices_rule(m, v, co, t):
# def commodity_maximum_rule(m, co):
# def process_throughput_by_capacity_rule(m, v, p, t):
# def process_capacity_min_rule(m, v, p):
# def process_capacity_max_rule(m, v, p):
# def process_input_rule(m, v, p, co, t):
# def process_output_rule(m, v, p, co, t):
# def def_costs_rule(m, cost_type):
# def obj_rule(m):
# def hub_balance(m, i, j, co, t):
# def flow_balance(m, v, co, t):
# def process_balance(m, v, co, t):
# def find_matching_edge(m, i, j):
# def line_length(line):
# def pairs(lst):
# def get_entity(instance, name):
# def get_entities(instance, names):
# def list_entities(instance, entity_type):
# def filter_by_type(entity, entity_type):
# def get_onset_names(entity):
# def get_constants(prob):
# def get_timeseries(prob):
# def plot(prob, commodity, plot_demand=False, mapscale=False, tick_labels=True,
# annotations=True, buildings=None, shapefiles=None, decoration=True,
# boundary=False):
# def _calc_xytext_offset(line):
# def result_figures(prob, file_basename, buildings=None, shapefiles=None):
# def report(prob, filename):
# def save_log(result, filename):
# def save(prob, filepath):
# def load(filepath):
. Output only the next line. | data_spreadsheet = os.path.join(base_directory, 'data.xlsx') |
Given snippet: <|code_start|>try:
PYOMO3 = False
except ImportError:
PYOMO3 = True
base_directory = os.path.join('data', 'mnl')
building_shapefile = os.path.join(base_directory, 'building')
edge_shapefile = os.path.join(base_directory, 'edge')
vertex_shapefile = os.path.join(base_directory, 'vertex')
data_spreadsheet = os.path.join(base_directory, 'data.xlsx')
# load buildings and sum by type and nearest edge ID
# 1. read shapefile to DataFrame (with special geometry column)
# 2. group DataFrame by columns 'nearest' (ID of nearest edge) and 'type'
# (residential, commercial, industrial, other)
# 3. sum by group and unstack, i.e. convert secondary index 'type' to columns
buildings = pdshp.read_shp(building_shapefile)
buildings_grouped = buildings.groupby(['nearest', 'type'])
total_area = buildings_grouped.sum()['total_area'].unstack()
# load edges (streets) and join with summed areas
# 1. read shapefile to DataFrame (with geometry column)
# 2. join DataFrame total_area on index (=ID)
# 3. fill missing values with 0
edge = pdshp.read_shp(edge_shapefile)
edge = edge.set_index('Edge')
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pyomo.environ
import coopr.environ
import matplotlib.pyplot as plt
import os
import pandas as pd
from pyomo.opt.base import SolverFactory
from coopr.opt.base import SolverFactory
from rivus.utils import pandashp as pdshp
from rivus.main import rivus
and context:
# Path: rivus/utils/pandashp.py
# def read_shp(filename):
# def write_shp(filename, dataframe, write_index=True):
# def match_vertices_and_edges(vertices, edges, vertex_cols=('Vertex1', 'Vertex2')):
# def find_closest_edge(polygons, edges, to_attr='index', column='nearest'):
# def bounds(df):
# def total_bounds(df):
#
# Path: rivus/main/rivus.py
# COLORS = { # (R,G,B) tuples with range (0-255)
# # defaults
# 'base': (192, 192, 192),
# 'building': (192, 192, 192),
# 'decoration': (128, 128, 128),
# # commodities
# 'Heat': (230, 112, 36),
# 'Cool': (0, 0, 255),
# 'Elec': (255, 170, 0),
# 'Demand': (0, 255, 0),
# 'Gas': (128, 64, 0),
# # buildings
# 'industrial': (240, 198, 116),
# 'residential': (181, 189, 104),
# 'commercial': (129, 162, 190),
# 'basin': (110, 75, 56),
# 'chapel': (177, 121, 91),
# 'church': (177, 121, 91),
# 'farm': (202, 178, 214),
# 'farm_auxiliary': (106, 61, 154),
# 'garage': (253, 191, 111),
# 'greenhouse': (255, 127, 0),
# 'hospital': (129, 221, 190),
# 'hotel': (227, 26, 28),
# 'house': (181, 189, 104),
# 'office': (129, 162, 190),
# 'public': (129, 162, 190),
# 'restaurant': (227, 26, 28),
# 'retail': (129, 162, 190),
# 'school': (29, 103, 214),
# 'warehouse': (98, 134, 6),
# }
# def read_excel(filepath):
# def create_model(data, vertex, edge, peak_multiplier=None,
# hub_only_in_edge=True):
# def multiply_by_area_demand(series, column):
# def peak_satisfaction_rule(m, i, j, co, t):
# def edge_equation_rule(m, i, j, co, t):
# def arc_flow_by_capacity_rule(m, i, j, co, t):
# def arc_flow_unidirectionality_rule(m, i, j, co, t):
# def arc_unidirectionality_rule(m, i, j, co, t):
# def edge_capacity_rule(m, i, j, co):
# def hub_supply_rule(m, i, j, co, t):
# def hub_output_by_capacity_rule(m, i, j, h, t):
# def hub_capacity_rule(m, i, j, h):
# def vertex_equation_rule(m, v, co, t):
# def source_vertices_rule(m, v, co, t):
# def commodity_maximum_rule(m, co):
# def process_throughput_by_capacity_rule(m, v, p, t):
# def process_capacity_min_rule(m, v, p):
# def process_capacity_max_rule(m, v, p):
# def process_input_rule(m, v, p, co, t):
# def process_output_rule(m, v, p, co, t):
# def def_costs_rule(m, cost_type):
# def obj_rule(m):
# def hub_balance(m, i, j, co, t):
# def flow_balance(m, v, co, t):
# def process_balance(m, v, co, t):
# def find_matching_edge(m, i, j):
# def line_length(line):
# def pairs(lst):
# def get_entity(instance, name):
# def get_entities(instance, names):
# def list_entities(instance, entity_type):
# def filter_by_type(entity, entity_type):
# def get_onset_names(entity):
# def get_constants(prob):
# def get_timeseries(prob):
# def plot(prob, commodity, plot_demand=False, mapscale=False, tick_labels=True,
# annotations=True, buildings=None, shapefiles=None, decoration=True,
# boundary=False):
# def _calc_xytext_offset(line):
# def result_figures(prob, file_basename, buildings=None, shapefiles=None):
# def report(prob, filename):
# def save_log(result, filename):
# def save(prob, filepath):
# def load(filepath):
which might include code, classes, or functions. Output only the next line. | edge = edge.join(total_area) |
Predict the next line after this snippet: <|code_start|> # known LineStrings with length and LonLat(x-y) coordinates
lines = (LineString(((11.6625881, 48.2680606),
(11.6527176, 48.2493919),
(11.6424179, 48.2366107),
(11.6235352, 48.1952043),
(11.608429, 48.184218),
(11.5871429, 48.1647573),
(11.5795898, 48.1455182))),
LineString(((11.5795898, 48.1455182),
(11.6142654, 48.1379581),
(11.6630173, 48.1391036),
(11.6781235, 48.1372707),
(11.6963196, 48.142311),
(11.7581177, 48.1432274))),
LineString(((11.5710926, 48.1596505),
(11.5704918, 48.1586199),
(11.5718651, 48.1582764))),
LineString(((11.571908, 48.1490288),
(11.5755129, 48.1544401))))
lens = [15181, 13553, 232, 659]
for line, length in zip(lines, lens):
calculated = round(line_length(line), 0)
self.assertTrue(calculated == length,
msg=('Calculated line length is invalid. {}<>{}'
.format(calculated, length)))
def test_source_calculation(self):
pass
<|code_end|>
using the current file's imports:
import unittest
from rivus.main.rivus import line_length
from shapely.geometry import LineString
and any relevant context from other files:
# Path: rivus/main/rivus.py
# def line_length(line):
# """Calculate length of a line in meters, given in geographic coordinates.
#
# Args:
# line: a shapely LineString object with WGS 84 coordinates
#
# Returns:
# Length of line in meters
# """
# # Swap shapely (lonlat) to geopy (latlon) points
# latlon = lambda lonlat: (lonlat[1], lonlat[0])
# total_length = sum(distance(latlon(a), latlon(b)).meters
# for (a, b) in pairs(line.coords))
# return round(total_length, 0)
. Output only the next line. | def test_pair_vertex_to_edge(self): |
Given snippet: <|code_start|>
COLORS = {
# (R,G,B) tuples with range (0-255)
# defaults
'base': (192, 192, 192),
'building': (192, 192, 192),
'decoration': (128, 128, 128),
# commodities
'Heat': (230, 112, 36),
'Cool': (0, 0, 255),
'Elec': (255, 170, 0),
'Demand': (0, 255, 0),
'Gas': (128, 64, 0),
'CO2': (11, 12, 13),
# buildings
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from pandas import Series
from numpy import union1d
from mpl_toolkits.basemap import Basemap
from rivus.main.rivus import get_constants, get_timeseries, line_length
from rivus.utils.pandashp import total_bounds
import math
import time
and context:
# Path: rivus/main/rivus.py
# def get_constants(prob):
# """Retrieve time-independent variables/quantities.
#
# Args:
# prob: a rivus model instance
#
# Returns:
# (costs, pmax, kappa_hub, kappa_process) tuple
#
# Example:
# costs, pmax, kappa_hub, kappa_process = get_constants(prob)
# """
# costs = get_entity(prob, 'costs')
# Pmax = get_entity(prob, 'Pmax')
# Kappa_hub = get_entity(prob, 'Kappa_hub')
# Kappa_process = get_entity(prob, 'Kappa_process')
#
# # nicer index names
# Pmax.index.names = ['Vertex1', 'Vertex2', 'commodity']
# Kappa_hub.index.names = ['Vertex1', 'Vertex2', 'process']
#
# # drop all-zero rows
# Pmax = Pmax[Pmax > 0].unstack().fillna(0)
# Kappa_hub = Kappa_hub[Kappa_hub > 0].unstack().fillna(0)
# Kappa_process = Kappa_process[Kappa_process > 0].unstack().fillna(0)
#
# # Drop all 0 commodities
# for column in Pmax:
# if all(Pmax[column] == 0):
# del Pmax[column]
#
# # round to integers
# if Pmax.empty:
# Pmax = pd.DataFrame([])
# else:
# Pmax = Pmax.applymap(round)
# if Kappa_hub.empty:
# Kappa_hub = pd.DataFrame([])
# else:
# Kappa_hub = Kappa_hub.applymap(round)
# if Kappa_process.empty:
# Kappa_process = pd.DataFrame([])
# else:
# Kappa_process = Kappa_process.applymap(round)
# costs = costs.apply(round)
#
# return costs, Pmax, Kappa_hub, Kappa_process
#
# def get_timeseries(prob):
# """Retrieve time-dependent variables/quantities.
#
# Example:
# source, flows, hubs, proc_io, proc_tau = get_timeseries(prob)
#
# Args:
# prob: a rivus model instance
#
# Returns:
# (source, flows, hubs, proc_io, proc_tau) tuple
# """
#
# source = get_entity(prob, 'Rho')
# flows = get_entities(prob, ['Pin', 'Pot', 'Psi', 'Sigma'])
# hubs = get_entity(prob, 'Epsilon_hub')
# proc_io = get_entities(prob, ['Epsilon_in', 'Epsilon_out'])
# proc_tau = get_entity(prob, 'Tau')
#
# # fill NaN's
# flows.fillna(0, inplace=True)
# proc_io.fillna(0, inplace=True)
#
# # drop all-zero rows
# source = source[source > 0].unstack()
# flows = flows[flows.sum(axis=1) > 0].applymap(round)
#
# hubs = hubs[hubs > 0].unstack().fillna(0)
# if hubs.empty:
# hubs = pd.DataFrame([])
# else:
# hubs = hubs.applymap(round)
#
# proc_io = proc_io[proc_io.sum(axis=1) > 0]
# if not proc_io.empty:
# proc_io = proc_io.applymap(round)
#
# proc_tau = proc_tau[proc_tau.apply(round) > 0]
# if not proc_tau.empty:
# proc_tau = proc_tau.unstack().fillna(0).applymap(round)
#
# return source, flows, hubs, proc_io, proc_tau
#
# def line_length(line):
# """Calculate length of a line in meters, given in geographic coordinates.
#
# Args:
# line: a shapely LineString object with WGS 84 coordinates
#
# Returns:
# Length of line in meters
# """
# # Swap shapely (lonlat) to geopy (latlon) points
# latlon = lambda lonlat: (lonlat[1], lonlat[0])
# total_length = sum(distance(latlon(a), latlon(b)).meters
# for (a, b) in pairs(line.coords))
# return round(total_length, 0)
#
# Path: rivus/utils/pandashp.py
# def total_bounds(df):
# """Return bounding box (minx, miny, maxx, maxy) of all geometries. """
# b = bounds(df)
# return (b['minx'].min(),
# b['miny'].min(),
# b['maxx'].max(),
# b['maxy'].max())
which might include code, classes, or functions. Output only the next line. | 'industrial': (240, 198, 116), |
Here is a snippet: <|code_start|> # (R,G,B) tuples with range (0-255)
# defaults
'base': (192, 192, 192),
'building': (192, 192, 192),
'decoration': (128, 128, 128),
# commodities
'Heat': (230, 112, 36),
'Cool': (0, 0, 255),
'Elec': (255, 170, 0),
'Demand': (0, 255, 0),
'Gas': (128, 64, 0),
'CO2': (11, 12, 13),
# buildings
'industrial': (240, 198, 116),
'residential': (181, 189, 104),
'commercial': (129, 162, 190),
'basin': (110, 75, 56),
'chapel': (177, 121, 91),
'church': (177, 121, 91),
'farm': (202, 178, 214),
'farm_auxiliary': (106, 61, 154),
'garage': (253, 191, 111),
'greenhouse': (255, 127, 0),
'hospital': (129, 221, 190),
'hotel': (227, 26, 28),
'house': (181, 189, 104),
'office': (129, 162, 190),
'public': (129, 162, 190),
'restaurant': (227, 26, 28),
'retail': (129, 162, 190),
<|code_end|>
. Write the next line using the current file imports:
from pandas import Series
from numpy import union1d
from mpl_toolkits.basemap import Basemap
from rivus.main.rivus import get_constants, get_timeseries, line_length
from rivus.utils.pandashp import total_bounds
import math
import time
and context from other files:
# Path: rivus/main/rivus.py
# def get_constants(prob):
# """Retrieve time-independent variables/quantities.
#
# Args:
# prob: a rivus model instance
#
# Returns:
# (costs, pmax, kappa_hub, kappa_process) tuple
#
# Example:
# costs, pmax, kappa_hub, kappa_process = get_constants(prob)
# """
# costs = get_entity(prob, 'costs')
# Pmax = get_entity(prob, 'Pmax')
# Kappa_hub = get_entity(prob, 'Kappa_hub')
# Kappa_process = get_entity(prob, 'Kappa_process')
#
# # nicer index names
# Pmax.index.names = ['Vertex1', 'Vertex2', 'commodity']
# Kappa_hub.index.names = ['Vertex1', 'Vertex2', 'process']
#
# # drop all-zero rows
# Pmax = Pmax[Pmax > 0].unstack().fillna(0)
# Kappa_hub = Kappa_hub[Kappa_hub > 0].unstack().fillna(0)
# Kappa_process = Kappa_process[Kappa_process > 0].unstack().fillna(0)
#
# # Drop all 0 commodities
# for column in Pmax:
# if all(Pmax[column] == 0):
# del Pmax[column]
#
# # round to integers
# if Pmax.empty:
# Pmax = pd.DataFrame([])
# else:
# Pmax = Pmax.applymap(round)
# if Kappa_hub.empty:
# Kappa_hub = pd.DataFrame([])
# else:
# Kappa_hub = Kappa_hub.applymap(round)
# if Kappa_process.empty:
# Kappa_process = pd.DataFrame([])
# else:
# Kappa_process = Kappa_process.applymap(round)
# costs = costs.apply(round)
#
# return costs, Pmax, Kappa_hub, Kappa_process
#
# def get_timeseries(prob):
# """Retrieve time-dependent variables/quantities.
#
# Example:
# source, flows, hubs, proc_io, proc_tau = get_timeseries(prob)
#
# Args:
# prob: a rivus model instance
#
# Returns:
# (source, flows, hubs, proc_io, proc_tau) tuple
# """
#
# source = get_entity(prob, 'Rho')
# flows = get_entities(prob, ['Pin', 'Pot', 'Psi', 'Sigma'])
# hubs = get_entity(prob, 'Epsilon_hub')
# proc_io = get_entities(prob, ['Epsilon_in', 'Epsilon_out'])
# proc_tau = get_entity(prob, 'Tau')
#
# # fill NaN's
# flows.fillna(0, inplace=True)
# proc_io.fillna(0, inplace=True)
#
# # drop all-zero rows
# source = source[source > 0].unstack()
# flows = flows[flows.sum(axis=1) > 0].applymap(round)
#
# hubs = hubs[hubs > 0].unstack().fillna(0)
# if hubs.empty:
# hubs = pd.DataFrame([])
# else:
# hubs = hubs.applymap(round)
#
# proc_io = proc_io[proc_io.sum(axis=1) > 0]
# if not proc_io.empty:
# proc_io = proc_io.applymap(round)
#
# proc_tau = proc_tau[proc_tau.apply(round) > 0]
# if not proc_tau.empty:
# proc_tau = proc_tau.unstack().fillna(0).applymap(round)
#
# return source, flows, hubs, proc_io, proc_tau
#
# def line_length(line):
# """Calculate length of a line in meters, given in geographic coordinates.
#
# Args:
# line: a shapely LineString object with WGS 84 coordinates
#
# Returns:
# Length of line in meters
# """
# # Swap shapely (lonlat) to geopy (latlon) points
# latlon = lambda lonlat: (lonlat[1], lonlat[0])
# total_length = sum(distance(latlon(a), latlon(b)).meters
# for (a, b) in pairs(line.coords))
# return round(total_length, 0)
#
# Path: rivus/utils/pandashp.py
# def total_bounds(df):
# """Return bounding box (minx, miny, maxx, maxy) of all geometries. """
# b = bounds(df)
# return (b['minx'].min(),
# b['miny'].min(),
# b['maxx'].max(),
# b['maxy'].max())
, which may include functions, classes, or code. Output only the next line. | 'school': (29, 103, 214), |
Given the code snippet: <|code_start|>COLORS = {
# (R,G,B) tuples with range (0-255)
# defaults
'base': (192, 192, 192),
'building': (192, 192, 192),
'decoration': (128, 128, 128),
# commodities
'Heat': (230, 112, 36),
'Cool': (0, 0, 255),
'Elec': (255, 170, 0),
'Demand': (0, 255, 0),
'Gas': (128, 64, 0),
'CO2': (11, 12, 13),
# buildings
'industrial': (240, 198, 116),
'residential': (181, 189, 104),
'commercial': (129, 162, 190),
'basin': (110, 75, 56),
'chapel': (177, 121, 91),
'church': (177, 121, 91),
'farm': (202, 178, 214),
'farm_auxiliary': (106, 61, 154),
'garage': (253, 191, 111),
'greenhouse': (255, 127, 0),
'hospital': (129, 221, 190),
'hotel': (227, 26, 28),
'house': (181, 189, 104),
'office': (129, 162, 190),
'public': (129, 162, 190),
'restaurant': (227, 26, 28),
<|code_end|>
, generate the next line using the imports in this file:
from pandas import Series
from numpy import union1d
from mpl_toolkits.basemap import Basemap
from rivus.main.rivus import get_constants, get_timeseries, line_length
from rivus.utils.pandashp import total_bounds
import math
import time
and context (functions, classes, or occasionally code) from other files:
# Path: rivus/main/rivus.py
# def get_constants(prob):
# """Retrieve time-independent variables/quantities.
#
# Args:
# prob: a rivus model instance
#
# Returns:
# (costs, pmax, kappa_hub, kappa_process) tuple
#
# Example:
# costs, pmax, kappa_hub, kappa_process = get_constants(prob)
# """
# costs = get_entity(prob, 'costs')
# Pmax = get_entity(prob, 'Pmax')
# Kappa_hub = get_entity(prob, 'Kappa_hub')
# Kappa_process = get_entity(prob, 'Kappa_process')
#
# # nicer index names
# Pmax.index.names = ['Vertex1', 'Vertex2', 'commodity']
# Kappa_hub.index.names = ['Vertex1', 'Vertex2', 'process']
#
# # drop all-zero rows
# Pmax = Pmax[Pmax > 0].unstack().fillna(0)
# Kappa_hub = Kappa_hub[Kappa_hub > 0].unstack().fillna(0)
# Kappa_process = Kappa_process[Kappa_process > 0].unstack().fillna(0)
#
# # Drop all 0 commodities
# for column in Pmax:
# if all(Pmax[column] == 0):
# del Pmax[column]
#
# # round to integers
# if Pmax.empty:
# Pmax = pd.DataFrame([])
# else:
# Pmax = Pmax.applymap(round)
# if Kappa_hub.empty:
# Kappa_hub = pd.DataFrame([])
# else:
# Kappa_hub = Kappa_hub.applymap(round)
# if Kappa_process.empty:
# Kappa_process = pd.DataFrame([])
# else:
# Kappa_process = Kappa_process.applymap(round)
# costs = costs.apply(round)
#
# return costs, Pmax, Kappa_hub, Kappa_process
#
# def get_timeseries(prob):
# """Retrieve time-dependent variables/quantities.
#
# Example:
# source, flows, hubs, proc_io, proc_tau = get_timeseries(prob)
#
# Args:
# prob: a rivus model instance
#
# Returns:
# (source, flows, hubs, proc_io, proc_tau) tuple
# """
#
# source = get_entity(prob, 'Rho')
# flows = get_entities(prob, ['Pin', 'Pot', 'Psi', 'Sigma'])
# hubs = get_entity(prob, 'Epsilon_hub')
# proc_io = get_entities(prob, ['Epsilon_in', 'Epsilon_out'])
# proc_tau = get_entity(prob, 'Tau')
#
# # fill NaN's
# flows.fillna(0, inplace=True)
# proc_io.fillna(0, inplace=True)
#
# # drop all-zero rows
# source = source[source > 0].unstack()
# flows = flows[flows.sum(axis=1) > 0].applymap(round)
#
# hubs = hubs[hubs > 0].unstack().fillna(0)
# if hubs.empty:
# hubs = pd.DataFrame([])
# else:
# hubs = hubs.applymap(round)
#
# proc_io = proc_io[proc_io.sum(axis=1) > 0]
# if not proc_io.empty:
# proc_io = proc_io.applymap(round)
#
# proc_tau = proc_tau[proc_tau.apply(round) > 0]
# if not proc_tau.empty:
# proc_tau = proc_tau.unstack().fillna(0).applymap(round)
#
# return source, flows, hubs, proc_io, proc_tau
#
# def line_length(line):
# """Calculate length of a line in meters, given in geographic coordinates.
#
# Args:
# line: a shapely LineString object with WGS 84 coordinates
#
# Returns:
# Length of line in meters
# """
# # Swap shapely (lonlat) to geopy (latlon) points
# latlon = lambda lonlat: (lonlat[1], lonlat[0])
# total_length = sum(distance(latlon(a), latlon(b)).meters
# for (a, b) in pairs(line.coords))
# return round(total_length, 0)
#
# Path: rivus/utils/pandashp.py
# def total_bounds(df):
# """Return bounding box (minx, miny, maxx, maxy) of all geometries. """
# b = bounds(df)
# return (b['minx'].min(),
# b['miny'].min(),
# b['maxx'].max(),
# b['maxy'].max())
. Output only the next line. | 'retail': (129, 162, 190), |
Using the snippet: <|code_start|>
COLORS = {
# (R,G,B) tuples with range (0-255)
# defaults
'base': (192, 192, 192),
'building': (192, 192, 192),
'decoration': (128, 128, 128),
# commodities
'Heat': (230, 112, 36),
'Cool': (0, 0, 255),
'Elec': (255, 170, 0),
'Demand': (0, 255, 0),
'Gas': (128, 64, 0),
'CO2': (11, 12, 13),
# buildings
'industrial': (240, 198, 116),
'residential': (181, 189, 104),
'commercial': (129, 162, 190),
'basin': (110, 75, 56),
'chapel': (177, 121, 91),
'church': (177, 121, 91),
'farm': (202, 178, 214),
'farm_auxiliary': (106, 61, 154),
'garage': (253, 191, 111),
'greenhouse': (255, 127, 0),
<|code_end|>
, determine the next line of code. You have imports:
from pandas import Series
from numpy import union1d
from mpl_toolkits.basemap import Basemap
from rivus.main.rivus import get_constants, get_timeseries, line_length
from rivus.utils.pandashp import total_bounds
import math
import time
and context (class names, function names, or code) available:
# Path: rivus/main/rivus.py
# def get_constants(prob):
# """Retrieve time-independent variables/quantities.
#
# Args:
# prob: a rivus model instance
#
# Returns:
# (costs, pmax, kappa_hub, kappa_process) tuple
#
# Example:
# costs, pmax, kappa_hub, kappa_process = get_constants(prob)
# """
# costs = get_entity(prob, 'costs')
# Pmax = get_entity(prob, 'Pmax')
# Kappa_hub = get_entity(prob, 'Kappa_hub')
# Kappa_process = get_entity(prob, 'Kappa_process')
#
# # nicer index names
# Pmax.index.names = ['Vertex1', 'Vertex2', 'commodity']
# Kappa_hub.index.names = ['Vertex1', 'Vertex2', 'process']
#
# # drop all-zero rows
# Pmax = Pmax[Pmax > 0].unstack().fillna(0)
# Kappa_hub = Kappa_hub[Kappa_hub > 0].unstack().fillna(0)
# Kappa_process = Kappa_process[Kappa_process > 0].unstack().fillna(0)
#
# # Drop all 0 commodities
# for column in Pmax:
# if all(Pmax[column] == 0):
# del Pmax[column]
#
# # round to integers
# if Pmax.empty:
# Pmax = pd.DataFrame([])
# else:
# Pmax = Pmax.applymap(round)
# if Kappa_hub.empty:
# Kappa_hub = pd.DataFrame([])
# else:
# Kappa_hub = Kappa_hub.applymap(round)
# if Kappa_process.empty:
# Kappa_process = pd.DataFrame([])
# else:
# Kappa_process = Kappa_process.applymap(round)
# costs = costs.apply(round)
#
# return costs, Pmax, Kappa_hub, Kappa_process
#
# def get_timeseries(prob):
# """Retrieve time-dependent variables/quantities.
#
# Example:
# source, flows, hubs, proc_io, proc_tau = get_timeseries(prob)
#
# Args:
# prob: a rivus model instance
#
# Returns:
# (source, flows, hubs, proc_io, proc_tau) tuple
# """
#
# source = get_entity(prob, 'Rho')
# flows = get_entities(prob, ['Pin', 'Pot', 'Psi', 'Sigma'])
# hubs = get_entity(prob, 'Epsilon_hub')
# proc_io = get_entities(prob, ['Epsilon_in', 'Epsilon_out'])
# proc_tau = get_entity(prob, 'Tau')
#
# # fill NaN's
# flows.fillna(0, inplace=True)
# proc_io.fillna(0, inplace=True)
#
# # drop all-zero rows
# source = source[source > 0].unstack()
# flows = flows[flows.sum(axis=1) > 0].applymap(round)
#
# hubs = hubs[hubs > 0].unstack().fillna(0)
# if hubs.empty:
# hubs = pd.DataFrame([])
# else:
# hubs = hubs.applymap(round)
#
# proc_io = proc_io[proc_io.sum(axis=1) > 0]
# if not proc_io.empty:
# proc_io = proc_io.applymap(round)
#
# proc_tau = proc_tau[proc_tau.apply(round) > 0]
# if not proc_tau.empty:
# proc_tau = proc_tau.unstack().fillna(0).applymap(round)
#
# return source, flows, hubs, proc_io, proc_tau
#
# def line_length(line):
# """Calculate length of a line in meters, given in geographic coordinates.
#
# Args:
# line: a shapely LineString object with WGS 84 coordinates
#
# Returns:
# Length of line in meters
# """
# # Swap shapely (lonlat) to geopy (latlon) points
# latlon = lambda lonlat: (lonlat[1], lonlat[0])
# total_length = sum(distance(latlon(a), latlon(b)).meters
# for (a, b) in pairs(line.coords))
# return round(total_length, 0)
#
# Path: rivus/utils/pandashp.py
# def total_bounds(df):
# """Return bounding box (minx, miny, maxx, maxy) of all geometries. """
# b = bounds(df)
# return (b['minx'].min(),
# b['miny'].min(),
# b['maxx'].max(),
# b['maxy'].max())
. Output only the next line. | 'hospital': (129, 221, 190), |
Next line prediction: <|code_start|> values = dict(row, process=key[0], commodity=key[1],
direction=key[2].lower(), run_id=run_id)
with connection.cursor() as curs:
curs.execute("""
INSERT INTO process_commodity
(process_id, commodity_id, direction, ratio)
VALUES (
(SELECT process_id FROM process
WHERE run_id = %(run_id)s AND
process LIKE %(process)s),
(SELECT commodity_id FROM commodity
WHERE run_id = %(run_id)s AND
commodity LIKE %(commodity)s),
%(direction)s,
%(ratio)s);
""", values)
connection.commit()
finally:
connection.close()
elif frame == 'source':
connection = engine.raw_connection()
try:
df.fillna(0, inplace=True)
for (vertex, comm), row in df.iterrows():
for time_step, val in row.iteritems():
values = dict(run_id=run_id, vertex=vertex, commodity=comm,
time_step=time_step, value=int(val))
with connection.cursor() as curs:
curs.execute("""
INSERT INTO {0}
<|code_end|>
. Use current file imports:
(import warnings
import json
from datetime import datetime
from pandas import Series, DataFrame, read_sql
from geopandas import GeoDataFrame
from shapely.wkt import loads as wkt_load
from ..main.rivus import get_timeseries, get_constants)
and context including class names, function names, or small code snippets from other files:
# Path: rivus/main/rivus.py
# def get_timeseries(prob):
# """Retrieve time-dependent variables/quantities.
#
# Example:
# source, flows, hubs, proc_io, proc_tau = get_timeseries(prob)
#
# Args:
# prob: a rivus model instance
#
# Returns:
# (source, flows, hubs, proc_io, proc_tau) tuple
# """
#
# source = get_entity(prob, 'Rho')
# flows = get_entities(prob, ['Pin', 'Pot', 'Psi', 'Sigma'])
# hubs = get_entity(prob, 'Epsilon_hub')
# proc_io = get_entities(prob, ['Epsilon_in', 'Epsilon_out'])
# proc_tau = get_entity(prob, 'Tau')
#
# # fill NaN's
# flows.fillna(0, inplace=True)
# proc_io.fillna(0, inplace=True)
#
# # drop all-zero rows
# source = source[source > 0].unstack()
# flows = flows[flows.sum(axis=1) > 0].applymap(round)
#
# hubs = hubs[hubs > 0].unstack().fillna(0)
# if hubs.empty:
# hubs = pd.DataFrame([])
# else:
# hubs = hubs.applymap(round)
#
# proc_io = proc_io[proc_io.sum(axis=1) > 0]
# if not proc_io.empty:
# proc_io = proc_io.applymap(round)
#
# proc_tau = proc_tau[proc_tau.apply(round) > 0]
# if not proc_tau.empty:
# proc_tau = proc_tau.unstack().fillna(0).applymap(round)
#
# return source, flows, hubs, proc_io, proc_tau
#
# def get_constants(prob):
# """Retrieve time-independent variables/quantities.
#
# Args:
# prob: a rivus model instance
#
# Returns:
# (costs, pmax, kappa_hub, kappa_process) tuple
#
# Example:
# costs, pmax, kappa_hub, kappa_process = get_constants(prob)
# """
# costs = get_entity(prob, 'costs')
# Pmax = get_entity(prob, 'Pmax')
# Kappa_hub = get_entity(prob, 'Kappa_hub')
# Kappa_process = get_entity(prob, 'Kappa_process')
#
# # nicer index names
# Pmax.index.names = ['Vertex1', 'Vertex2', 'commodity']
# Kappa_hub.index.names = ['Vertex1', 'Vertex2', 'process']
#
# # drop all-zero rows
# Pmax = Pmax[Pmax > 0].unstack().fillna(0)
# Kappa_hub = Kappa_hub[Kappa_hub > 0].unstack().fillna(0)
# Kappa_process = Kappa_process[Kappa_process > 0].unstack().fillna(0)
#
# # Drop all 0 commodities
# for column in Pmax:
# if all(Pmax[column] == 0):
# del Pmax[column]
#
# # round to integers
# if Pmax.empty:
# Pmax = pd.DataFrame([])
# else:
# Pmax = Pmax.applymap(round)
# if Kappa_hub.empty:
# Kappa_hub = pd.DataFrame([])
# else:
# Kappa_hub = Kappa_hub.applymap(round)
# if Kappa_process.empty:
# Kappa_process = pd.DataFrame([])
# else:
# Kappa_process = Kappa_process.applymap(round)
# costs = costs.apply(round)
#
# return costs, Pmax, Kappa_hub, Kappa_process
. Output only the next line. | (vertex_id, commodity_id, time_id, capacity) |
Next line prediction: <|code_start|> WHERE E.run_id = %s
ORDER BY 1,2;
"""
df = read_sql(sql, engine, params=(run_id,),
index_col=['Vertex1', 'Vertex2', 'commodity']
).unstack(level=-1).fillna(0)
df = df['capacity']
elif fname == 'kappa_hub':
sql = """
SELECT E.vertex1 AS "Vertex1", E.vertex2 AS "Vertex2", P.process,
KH.capacity
FROM kappa_hub AS KH
JOIN edge AS E ON E.edge_id = KH.edge_id
JOIN process AS P ON P.process_id = KH.process_id
WHERE E.run_id = %s
ORDER BY 1,2;
"""
df = read_sql(sql, engine, params=(run_id,),
index_col=['Vertex1', 'Vertex2', 'process']
).unstack(level=-1).fillna(0)
df = df['capacity']
elif fname == 'kappa_process':
# TODO test
sql = """
SELECT V.vertex_num AS "Vertex", P.process, KP.capacity
FROM kappa_process AS KP
JOIN vertex AS V ON V.vertex_id = KP.vertex_id
JOIN process AS P ON P.process_id = KP.process_id
<|code_end|>
. Use current file imports:
(import warnings
import json
from datetime import datetime
from pandas import Series, DataFrame, read_sql
from geopandas import GeoDataFrame
from shapely.wkt import loads as wkt_load
from ..main.rivus import get_timeseries, get_constants)
and context including class names, function names, or small code snippets from other files:
# Path: rivus/main/rivus.py
# def get_timeseries(prob):
# """Retrieve time-dependent variables/quantities.
#
# Example:
# source, flows, hubs, proc_io, proc_tau = get_timeseries(prob)
#
# Args:
# prob: a rivus model instance
#
# Returns:
# (source, flows, hubs, proc_io, proc_tau) tuple
# """
#
# source = get_entity(prob, 'Rho')
# flows = get_entities(prob, ['Pin', 'Pot', 'Psi', 'Sigma'])
# hubs = get_entity(prob, 'Epsilon_hub')
# proc_io = get_entities(prob, ['Epsilon_in', 'Epsilon_out'])
# proc_tau = get_entity(prob, 'Tau')
#
# # fill NaN's
# flows.fillna(0, inplace=True)
# proc_io.fillna(0, inplace=True)
#
# # drop all-zero rows
# source = source[source > 0].unstack()
# flows = flows[flows.sum(axis=1) > 0].applymap(round)
#
# hubs = hubs[hubs > 0].unstack().fillna(0)
# if hubs.empty:
# hubs = pd.DataFrame([])
# else:
# hubs = hubs.applymap(round)
#
# proc_io = proc_io[proc_io.sum(axis=1) > 0]
# if not proc_io.empty:
# proc_io = proc_io.applymap(round)
#
# proc_tau = proc_tau[proc_tau.apply(round) > 0]
# if not proc_tau.empty:
# proc_tau = proc_tau.unstack().fillna(0).applymap(round)
#
# return source, flows, hubs, proc_io, proc_tau
#
# def get_constants(prob):
# """Retrieve time-independent variables/quantities.
#
# Args:
# prob: a rivus model instance
#
# Returns:
# (costs, pmax, kappa_hub, kappa_process) tuple
#
# Example:
# costs, pmax, kappa_hub, kappa_process = get_constants(prob)
# """
# costs = get_entity(prob, 'costs')
# Pmax = get_entity(prob, 'Pmax')
# Kappa_hub = get_entity(prob, 'Kappa_hub')
# Kappa_process = get_entity(prob, 'Kappa_process')
#
# # nicer index names
# Pmax.index.names = ['Vertex1', 'Vertex2', 'commodity']
# Kappa_hub.index.names = ['Vertex1', 'Vertex2', 'process']
#
# # drop all-zero rows
# Pmax = Pmax[Pmax > 0].unstack().fillna(0)
# Kappa_hub = Kappa_hub[Kappa_hub > 0].unstack().fillna(0)
# Kappa_process = Kappa_process[Kappa_process > 0].unstack().fillna(0)
#
# # Drop all 0 commodities
# for column in Pmax:
# if all(Pmax[column] == 0):
# del Pmax[column]
#
# # round to integers
# if Pmax.empty:
# Pmax = pd.DataFrame([])
# else:
# Pmax = Pmax.applymap(round)
# if Kappa_hub.empty:
# Kappa_hub = pd.DataFrame([])
# else:
# Kappa_hub = Kappa_hub.applymap(round)
# if Kappa_process.empty:
# Kappa_process = pd.DataFrame([])
# else:
# Kappa_process = Kappa_process.applymap(round)
# costs = costs.apply(round)
#
# return costs, Pmax, Kappa_hub, Kappa_process
. Output only the next line. | WHERE V.run_id = %s |
Predict the next line after this snippet: <|code_start|>
# from django.contrib.auth.decorators import login_required
def home(request):
return render_to_response("home/base.html",
context_instance=RequestContext(request))
<|code_end|>
using the current file's imports:
import time
import re
import warnings
from calendar import month_name
from taggit.models import Tag
from django.conf import settings
from django.http import Http404
from django.core.urlresolvers import reverse
from django.views.generic import TemplateView
from django.contrib.auth.models import User
from django.contrib import messages
from django.contrib.auth import authenticate, login, get_user_model
from django.contrib.auth import logout as auth_logout
from django.core.mail import send_mail, BadHeaderError
from django.views.decorators.csrf import csrf_protect
from django.template import RequestContext
from django.template.loader import Context, get_template
from django.template.response import TemplateResponse
from django.utils.http import urlsafe_base64_decode
from django.utils.translation import ugettext as _
from django.shortcuts import resolve_url
from django.db.models import Q
from django.contrib.auth.forms import PasswordResetForm, SetPasswordForm
from django.contrib.auth.tokens import default_token_generator
from django.core.paginator import Paginator, \
InvalidPage, EmptyPage
from django.shortcuts import render, render_to_response, \
HttpResponseRedirect, HttpResponse, get_object_or_404, redirect
from .models import Post, Comment
from .forms import CommentsForm, CommentForm, RegistrationForm, \
LoginForm, FeedbackForm
and any relevant context from other files:
# Path: blog/models.py
# class Post(models.Model):
# title = models.CharField(max_length=60)
# tags = TaggableManager()
# author = models.ForeignKey(User, null=True)
# body = models.TextField()
# created = models.DateTimeField(auto_now_add=True)
#
# class Meta:
# ordering = ['-created']
#
# def __unicode__(self):
# return self.title
# return unicode(self.created)
#
# class Comment(models.Model):
# created = models.DateTimeField(auto_now_add=True)
# name = models.CharField(max_length=60)
# email = models.EmailField(max_length=35, null=True)
# body = models.TextField()
# post = models.ForeignKey(Post)
#
# class meta:
# ordering = ['-created']
#
# def __unicode__(self):
# return unicode("%s: %s" % (self.post, self.body[:60]))
#
# Path: blog/forms.py
# class CommentsForm(forms.Form):
# name = forms.CharField(widget=forms.TextInput(
# attrs={'size': '48',
# 'class': 'form-control'}))
# # A CharField that checks that the value is a valid email address.
# email = forms.EmailField(widget=forms.TextInput(
# attrs={'size': '48',
# 'class': 'form-control'}))
# Body = forms.CharField(widget=forms.Textarea(
# attrs={'cols': 50, 'rows': 5,
# 'class': 'form-control'}))
#
# class CommentForm(ModelForm):
# class Meta:
# model = Comment
# exclude = ["post"]
#
# class RegistrationForm(forms.Form):
# username = forms.RegexField(regex=r'^\w+$', widget=forms.TextInput(attrs=dict(required=True, max_length=30)), label=_("Username"), error_messages={'invalid': _("This value must contain only letters, numbers and underscores.")})
# email = forms.EmailField(widget=forms.TextInput(attrs=dict(required=True, max_length=30)), label=_("Email address"))
# password1 = forms.CharField(widget=forms.PasswordInput(attrs=dict(required=True, max_length=30, render_value=False)), label=_("Password"))
# password2 = forms.CharField(widget=forms.PasswordInput(attrs=dict(required=True, max_length=30, render_value=False)), label=_("Password (again)"))
#
# def clean_username(self):
# try:
# User.objects.get(username__iexact=self.cleaned_data['username'])
# except User.DoesNotExist:
# return self.cleaned_data['username']
# raise forms.ValidationError(_("The username already exists."))
#
# def clean_email(self):
# try:
# User.objects.get(email=self.cleaned_data['email'])
# raise forms.ValidationError("This email already exist")
# except User.DoesNotExist:
# return self.cleaned_data['email']
#
# def clean(self):
# if 'password1' in self.cleaned_data and 'password2' in self.cleaned_data:
# if self.cleaned_data['password1'] != self.cleaned_data['password2']:
# raise forms.ValidationError(_("The two password fields did not match."))
# return self.cleaned_data
#
# class LoginForm(forms.Form):
# email = forms.EmailField(widget=forms.TextInput(
# attrs={'size': '48',
# 'class': 'form-control'}))
# password = forms.CharField(max_length=32, widget=forms.PasswordInput)
#
# class FeedbackForm(ModelForm):
# class Meta:
# model = Feedback
. Output only the next line. | def post(request, post_id): |
Given snippet: <|code_start|>
# from django.contrib.auth.decorators import login_required
def home(request):
return render_to_response("home/base.html",
context_instance=RequestContext(request))
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import time
import re
import warnings
from calendar import month_name
from taggit.models import Tag
from django.conf import settings
from django.http import Http404
from django.core.urlresolvers import reverse
from django.views.generic import TemplateView
from django.contrib.auth.models import User
from django.contrib import messages
from django.contrib.auth import authenticate, login, get_user_model
from django.contrib.auth import logout as auth_logout
from django.core.mail import send_mail, BadHeaderError
from django.views.decorators.csrf import csrf_protect
from django.template import RequestContext
from django.template.loader import Context, get_template
from django.template.response import TemplateResponse
from django.utils.http import urlsafe_base64_decode
from django.utils.translation import ugettext as _
from django.shortcuts import resolve_url
from django.db.models import Q
from django.contrib.auth.forms import PasswordResetForm, SetPasswordForm
from django.contrib.auth.tokens import default_token_generator
from django.core.paginator import Paginator, \
InvalidPage, EmptyPage
from django.shortcuts import render, render_to_response, \
HttpResponseRedirect, HttpResponse, get_object_or_404, redirect
from .models import Post, Comment
from .forms import CommentsForm, CommentForm, RegistrationForm, \
LoginForm, FeedbackForm
and context:
# Path: blog/models.py
# class Post(models.Model):
# title = models.CharField(max_length=60)
# tags = TaggableManager()
# author = models.ForeignKey(User, null=True)
# body = models.TextField()
# created = models.DateTimeField(auto_now_add=True)
#
# class Meta:
# ordering = ['-created']
#
# def __unicode__(self):
# return self.title
# return unicode(self.created)
#
# class Comment(models.Model):
# created = models.DateTimeField(auto_now_add=True)
# name = models.CharField(max_length=60)
# email = models.EmailField(max_length=35, null=True)
# body = models.TextField()
# post = models.ForeignKey(Post)
#
# class meta:
# ordering = ['-created']
#
# def __unicode__(self):
# return unicode("%s: %s" % (self.post, self.body[:60]))
#
# Path: blog/forms.py
# class CommentsForm(forms.Form):
# name = forms.CharField(widget=forms.TextInput(
# attrs={'size': '48',
# 'class': 'form-control'}))
# # A CharField that checks that the value is a valid email address.
# email = forms.EmailField(widget=forms.TextInput(
# attrs={'size': '48',
# 'class': 'form-control'}))
# Body = forms.CharField(widget=forms.Textarea(
# attrs={'cols': 50, 'rows': 5,
# 'class': 'form-control'}))
#
# class CommentForm(ModelForm):
# class Meta:
# model = Comment
# exclude = ["post"]
#
# class RegistrationForm(forms.Form):
# username = forms.RegexField(regex=r'^\w+$', widget=forms.TextInput(attrs=dict(required=True, max_length=30)), label=_("Username"), error_messages={'invalid': _("This value must contain only letters, numbers and underscores.")})
# email = forms.EmailField(widget=forms.TextInput(attrs=dict(required=True, max_length=30)), label=_("Email address"))
# password1 = forms.CharField(widget=forms.PasswordInput(attrs=dict(required=True, max_length=30, render_value=False)), label=_("Password"))
# password2 = forms.CharField(widget=forms.PasswordInput(attrs=dict(required=True, max_length=30, render_value=False)), label=_("Password (again)"))
#
# def clean_username(self):
# try:
# User.objects.get(username__iexact=self.cleaned_data['username'])
# except User.DoesNotExist:
# return self.cleaned_data['username']
# raise forms.ValidationError(_("The username already exists."))
#
# def clean_email(self):
# try:
# User.objects.get(email=self.cleaned_data['email'])
# raise forms.ValidationError("This email already exist")
# except User.DoesNotExist:
# return self.cleaned_data['email']
#
# def clean(self):
# if 'password1' in self.cleaned_data and 'password2' in self.cleaned_data:
# if self.cleaned_data['password1'] != self.cleaned_data['password2']:
# raise forms.ValidationError(_("The two password fields did not match."))
# return self.cleaned_data
#
# class LoginForm(forms.Form):
# email = forms.EmailField(widget=forms.TextInput(
# attrs={'size': '48',
# 'class': 'form-control'}))
# password = forms.CharField(max_length=32, widget=forms.PasswordInput)
#
# class FeedbackForm(ModelForm):
# class Meta:
# model = Feedback
which might include code, classes, or functions. Output only the next line. | def post(request, post_id): |
Given the following code snippet before the placeholder: <|code_start|>
class LoginForm(forms.Form):
email = forms.EmailField(widget=forms.TextInput(
attrs={'size': '48',
'class': 'form-control'}))
password = forms.CharField(max_length=32, widget=forms.PasswordInput)
class RegistrationForm(forms.Form):
username = forms.RegexField(regex=r'^\w+$', widget=forms.TextInput(attrs=dict(required=True, max_length=30)), label=_("Username"), error_messages={'invalid': _("This value must contain only letters, numbers and underscores.")})
email = forms.EmailField(widget=forms.TextInput(attrs=dict(required=True, max_length=30)), label=_("Email address"))
password1 = forms.CharField(widget=forms.PasswordInput(attrs=dict(required=True, max_length=30, render_value=False)), label=_("Password"))
password2 = forms.CharField(widget=forms.PasswordInput(attrs=dict(required=True, max_length=30, render_value=False)), label=_("Password (again)"))
def clean_username(self):
try:
User.objects.get(username__iexact=self.cleaned_data['username'])
except User.DoesNotExist:
return self.cleaned_data['username']
raise forms.ValidationError(_("The username already exists."))
def clean_email(self):
try:
User.objects.get(email=self.cleaned_data['email'])
raise forms.ValidationError("This email already exist")
except User.DoesNotExist:
return self.cleaned_data['email']
def clean(self):
<|code_end|>
, predict the next line using imports from the current file:
from django.forms import ModelForm
from django import forms
from django.contrib.auth.models import User
from django.utils.translation import ugettext_lazy as _
from .models import Comment, Feedback
and context including class names, function names, and sometimes code from other files:
# Path: blog/models.py
# class Comment(models.Model):
# created = models.DateTimeField(auto_now_add=True)
# name = models.CharField(max_length=60)
# email = models.EmailField(max_length=35, null=True)
# body = models.TextField()
# post = models.ForeignKey(Post)
#
# class meta:
# ordering = ['-created']
#
# def __unicode__(self):
# return unicode("%s: %s" % (self.post, self.body[:60]))
#
# class Feedback(models.Model):
# created = models.DateTimeField(auto_now_add=True)
# name = models.CharField(max_length=75)
# email = models.EmailField(max_length=75)
# feedback = models.TextField()
#
# class meta:
# ordering = ['-created']
#
# def __unicode__(self):
# return unicode("%s: %s" % (self.email, self.feedback[:60]))
. Output only the next line. | if 'password1' in self.cleaned_data and 'password2' in self.cleaned_data: |
Continue the code snippet: <|code_start|> # A CharField that checks that the value is a valid email address.
email = forms.EmailField(widget=forms.TextInput(
attrs={'size': '48',
'class': 'form-control'}))
Body = forms.CharField(widget=forms.Textarea(
attrs={'cols': 50, 'rows': 5,
'class': 'form-control'}))
class FeedbackForm(ModelForm):
class Meta:
model = Feedback
class PostForm(forms.Form):
title = forms.CharField(max_length=50)
body = forms.CharField(widget=forms.Textarea, required=False)
class LoginForm(forms.Form):
email = forms.EmailField(widget=forms.TextInput(
attrs={'size': '48',
'class': 'form-control'}))
password = forms.CharField(max_length=32, widget=forms.PasswordInput)
class RegistrationForm(forms.Form):
username = forms.RegexField(regex=r'^\w+$', widget=forms.TextInput(attrs=dict(required=True, max_length=30)), label=_("Username"), error_messages={'invalid': _("This value must contain only letters, numbers and underscores.")})
email = forms.EmailField(widget=forms.TextInput(attrs=dict(required=True, max_length=30)), label=_("Email address"))
password1 = forms.CharField(widget=forms.PasswordInput(attrs=dict(required=True, max_length=30, render_value=False)), label=_("Password"))
<|code_end|>
. Use current file imports:
from django.forms import ModelForm
from django import forms
from django.contrib.auth.models import User
from django.utils.translation import ugettext_lazy as _
from .models import Comment, Feedback
and context (classes, functions, or code) from other files:
# Path: blog/models.py
# class Comment(models.Model):
# created = models.DateTimeField(auto_now_add=True)
# name = models.CharField(max_length=60)
# email = models.EmailField(max_length=35, null=True)
# body = models.TextField()
# post = models.ForeignKey(Post)
#
# class meta:
# ordering = ['-created']
#
# def __unicode__(self):
# return unicode("%s: %s" % (self.post, self.body[:60]))
#
# class Feedback(models.Model):
# created = models.DateTimeField(auto_now_add=True)
# name = models.CharField(max_length=75)
# email = models.EmailField(max_length=75)
# feedback = models.TextField()
#
# class meta:
# ordering = ['-created']
#
# def __unicode__(self):
# return unicode("%s: %s" % (self.email, self.feedback[:60]))
. Output only the next line. | password2 = forms.CharField(widget=forms.PasswordInput(attrs=dict(required=True, max_length=30, render_value=False)), label=_("Password (again)")) |
Based on the snippet: <|code_start|>
class BlogEntriesTest(TestCase):
def setUp(self):
self.c = Client()
self.author = User.objects.create(username="Yashwanth",
email="yashwanth@agiliq.com",
password="yashwanth")
self.post = Post.objects.create(author=self.author, title='Test',
body='Testcase1',
created=time.localtime()[:2])
self.comment = Comment.objects.create(post=self.post,
name="Yashwanth",
email="yashwanth@agiliq.com",
body="testcase1",
created=time.localtime()[:2])
<|code_end|>
, predict the immediate next line with the help of imports:
import time
from django.test import TestCase
from django.test.client import Client
from django.core.urlresolvers import reverse
from django.contrib.auth.models import User
from .models import Post, Comment
and context (classes, functions, sometimes code) from other files:
# Path: blog/models.py
# class Post(models.Model):
# title = models.CharField(max_length=60)
# tags = TaggableManager()
# author = models.ForeignKey(User, null=True)
# body = models.TextField()
# created = models.DateTimeField(auto_now_add=True)
#
# class Meta:
# ordering = ['-created']
#
# def __unicode__(self):
# return self.title
# return unicode(self.created)
#
# class Comment(models.Model):
# created = models.DateTimeField(auto_now_add=True)
# name = models.CharField(max_length=60)
# email = models.EmailField(max_length=35, null=True)
# body = models.TextField()
# post = models.ForeignKey(Post)
#
# class meta:
# ordering = ['-created']
#
# def __unicode__(self):
# return unicode("%s: %s" % (self.post, self.body[:60]))
. Output only the next line. | def test_blog_access(self): |
Next line prediction: <|code_start|> response = self.c.get(reverse('post', args=[self.post.id]))
self.assertEqual(200, response.status_code)
def test_blog_post_add_comment_access(self):
response = self.c.get(reverse('add_comment', args=[self.post.id]))
self.assertEqual(200, response.status_code)
def test_blog_post_monthly_archive_access(self):
response = self.c.get(reverse('month', args=[self.post.created.year,
self.post.created.month]))
self.assertEqual(200, response.status_code)
def test_blog_post_delete_bulk_comment_access(self):
response = self.c.get(reverse('delete_comment', args=[self.post.id]))
self.assertEqual(302, response.status_code)
if self.c.login(username="Yashwanth", password="yashwanth"):
response = self.c.get(reverse('delete_comment',
args=[self.post.id]))
self.assertEqual(200, response.status_code)
def test_blog_post_delete_single_comment_access(self):
response = self.c.get(reverse('delete_single_comment',
args=[self.post.id, self.comment.id]))
self.assertEqual(302, response.status_code)
if self.c.login(username="Yashwanth", password="yashwanth"):
response = self.c.get(reverse('delete_single_comment',
args=[self.post.id,
self.comment.id]))
self.assertEqual(200, response.status_code)
<|code_end|>
. Use current file imports:
(import time
from django.test import TestCase
from django.test.client import Client
from django.core.urlresolvers import reverse
from django.contrib.auth.models import User
from .models import Post, Comment)
and context including class names, function names, or small code snippets from other files:
# Path: blog/models.py
# class Post(models.Model):
# title = models.CharField(max_length=60)
# tags = TaggableManager()
# author = models.ForeignKey(User, null=True)
# body = models.TextField()
# created = models.DateTimeField(auto_now_add=True)
#
# class Meta:
# ordering = ['-created']
#
# def __unicode__(self):
# return self.title
# return unicode(self.created)
#
# class Comment(models.Model):
# created = models.DateTimeField(auto_now_add=True)
# name = models.CharField(max_length=60)
# email = models.EmailField(max_length=35, null=True)
# body = models.TextField()
# post = models.ForeignKey(Post)
#
# class meta:
# ordering = ['-created']
#
# def __unicode__(self):
# return unicode("%s: %s" % (self.post, self.body[:60]))
. Output only the next line. | def test_blog_recent_posts_access(self): |
Continue the code snippet: <|code_start|>
class TraverseTreeDepthFirst(CreateTree):
def traverse(self, marker, tree, node):
marker.append(node)
tree.stats.traversed_nodes += 1
tree.sync()
for child in node.children:
self.traverse(marker, tree, child)
<|code_end|>
. Use current file imports:
from alvi.client.scenes.create_tree import CreateTree
and context (classes, functions, or code) from other files:
# Path: alvi/client/scenes/create_tree.py
# class CreateTree(base.Scene):
# def run(self, **kwargs):
# tree = kwargs['container']
# data_generator = kwargs['data_generator']
# nodes = []
# value = next(data_generator.values)
# node = tree.create_root(value)
# nodes.append(node)
# tree.sync()
# for i, value in enumerate(data_generator.values):
# x = random.randint(0, i)
# parent = nodes[x]
# node = parent.children.create(value)
# nodes.append(node)
# tree.sync()
#
# @staticmethod
# def container_class():
# return alvi.client.containers.Tree
. Output only the next line. | def run(self, **kwargs): |
Predict the next line for this snippet: <|code_start|>
class TestSequenced(unittest.TestCase):
def test_ascending(self):
generator = SequencedDataGenerator(dict(n=8))
self.assertEquals(next(generator.values), 0)
self.assertEquals(list(generator.values), [1, 2, 3, 4, 5, 6, 7])
def test_descending(self):
generator = SequencedDataGenerator(dict(
<|code_end|>
with the help of current file imports:
import unittest
from alvi.client.data_generators.sequenced import SequencedDataGenerator
and context from other files:
# Path: alvi/client/data_generators/sequenced.py
# class SequencedDataGenerator(DataGenerator):
# class Form(DataGenerator.Form):
# descending = forms.BooleanField(label="Descending", initial=True, required=False)
#
# def _values(self):
# return ((self.quantity()-i-1 if self.descending else i) for i in range(self.quantity())).__iter__()
#
# @property
# def descending(self):
# return self._options['descending']
, which may contain function names, class names, or code. Output only the next line. | n=8, |
Predict the next line for this snippet: <|code_start|>
logger = logging.getLogger(__name__)
class TestScenes(TestContainer):
def test_check_scenes(self):
home_page = pages.Home(self._browser.driver)
home_page.goto()
scene_links = home_page.scene_links
self.assertEqual(len(self._client.scenes),
len(scene_links),
<|code_end|>
with the help of current file imports:
import logging
import alvi.tests.pages as pages
from alvi.tests.test_client.base import TestContainer
and context from other files:
# Path: alvi/tests/test_client/base.py
# class TestContainer(unittest.TestCase):
# @classmethod
# def setUpClass(cls):
# config_path = os.path.join(os.path.dirname(__file__), "config.py")
# cls._backend = Backend.create(config_path)
# cls._client = Client.create()
# cls._browser = Browser.create()
#
# @classmethod
# def tearDownClass(cls):
# cls._browser.destroy()
# cls._client.destroy()
# cls._backend.destroy()
, which may contain function names, class names, or code. Output only the next line. | "not all client processes (scenes) were successfully connected") |
Next line prediction: <|code_start|>
class InsertionSort(Sort):
def sort(self, **kwargs):
array = kwargs['container']
right_marker = array.create_marker("right", 0)
left_marker = array.create_marker("left", 0)
left1_marker = array.create_marker("left+1", 0)
<|code_end|>
. Use current file imports:
(from alvi.client.scenes.sort import Sort)
and context including class names, function names, or small code snippets from other files:
# Path: alvi/client/scenes/sort.py
# class Sort(base.Scene):
# """abstract scene, not to be used directly"""
# def swap(self, array, index_a, index_b):
# t = array[index_a]
# array[index_a] = array[index_b]
# array[index_b] = t
# array.stats.assignments += 2
#
# def init(self, array, n):
# array.stats.comparisons = 0
# array.stats.assignments = 0
# array.init(n)
# array.sync()
#
# def generate_points(self, array, data_generator):
# for i, value in enumerate(data_generator.values):
# array[i] = value
# array.sync()
#
# @abc.abstractmethod
# def sort(self, **kwargs):
# raise NotImplementedError
#
# def run(self, **kwargs):
# data_generator = kwargs['data_generator']
# array = kwargs['container']
# array.stats.elements = data_generator.quantity()
# self.init(array, data_generator.quantity())
# self.generate_points(array, data_generator)
# self.sort(**kwargs)
#
# @staticmethod
# def container_class():
# return alvi.client.containers.Array
#
# def test(self, array, test_case):
# for i in range(1, array.size()):
# previous = array[i-1]
# current = array[i]
# test_case.assertLessEqual(previous, current)
. Output only the next line. | array.sync() |
Continue the code snippet: <|code_start|>
class TreeMultiMarker(TreeCreateNode):
def run(self, **kwargs):
tree = kwargs['container']
marker = tree.create_multi_marker("multi marker")
super().run(**kwargs)
tree.sync()
marker.append(self.nodes[0])
marker.append(self.nodes[1])
marker.append(self.nodes[3])
<|code_end|>
. Use current file imports:
from alvi.tests.resources.client.local_python_client.scenes.tree.create_node import TreeCreateNode
and context (classes, functions, or code) from other files:
# Path: alvi/tests/resources/client/local_python_client/scenes/tree/create_node.py
# class TreeCreateNode(Scene):
# class Form(Scene.Form):
# parents = forms.CharField(initial="0, 0, 1, 1, 4, 4")
#
# def __init__(self, *args, **kwargs):
# super().__init__(*args, **kwargs)
# self.nodes = []
#
# def run(self, **kwargs):
# tree = kwargs['container']
# data_generator = kwargs['data_generator']
# options = kwargs['options']
# parents = [int(parent) for parent in options['parents'].split(',')]
# value = next(data_generator.values)
# node = tree.create_root(value=value)
# self.nodes.append(node)
# #parents = [0, 0, 1, 1, 4, 4] # TODO this list could be passed from test case by custom form field
# for value, parent in zip(data_generator.values, parents):
# node = self.nodes[parent].children.create(value=value)
# self.nodes.append(node)
# tree.sync()
#
# @classmethod
# def container_class(cls):
# return Tree
. Output only the next line. | marker.remove(self.nodes[1]) |
Continue the code snippet: <|code_start|>
class BoobleSort(Sort):
def sort(self, **kwargs):
array = kwargs['container']
changed = True
right_marker = array.create_marker("right", array.size()-1)
array.sync()
right = array.size()
while changed:
changed = False
for j in range(1, right):
item_a = array[j]
item_b = array[j - 1]
if item_a < item_b:
self.swap(array, j, j - 1)
changed = True
array.stats.comparisons += 1
<|code_end|>
. Use current file imports:
from alvi.client.scenes.sort import Sort
and context (classes, functions, or code) from other files:
# Path: alvi/client/scenes/sort.py
# class Sort(base.Scene):
# """abstract scene, not to be used directly"""
# def swap(self, array, index_a, index_b):
# t = array[index_a]
# array[index_a] = array[index_b]
# array[index_b] = t
# array.stats.assignments += 2
#
# def init(self, array, n):
# array.stats.comparisons = 0
# array.stats.assignments = 0
# array.init(n)
# array.sync()
#
# def generate_points(self, array, data_generator):
# for i, value in enumerate(data_generator.values):
# array[i] = value
# array.sync()
#
# @abc.abstractmethod
# def sort(self, **kwargs):
# raise NotImplementedError
#
# def run(self, **kwargs):
# data_generator = kwargs['data_generator']
# array = kwargs['container']
# array.stats.elements = data_generator.quantity()
# self.init(array, data_generator.quantity())
# self.generate_points(array, data_generator)
# self.sort(**kwargs)
#
# @staticmethod
# def container_class():
# return alvi.client.containers.Array
#
# def test(self, array, test_case):
# for i in range(1, array.size()):
# previous = array[i-1]
# current = array[i]
# test_case.assertLessEqual(previous, current)
. Output only the next line. | right -= 1 |
Given the code snippet: <|code_start|>
logger = logging.getLogger(__name__)
class Backend(ResourceFactory):
@staticmethod
def create(config_path):
return LocalBackend(config_path)
class LocalBackend(Resource):
def __init__(self, config_path):
logger.info("setting up backend")
self._process = multiprocessing.Process(target=server.run, args=(config_path, ))
<|code_end|>
, generate the next line using the imports in this file:
import time
import logging
import multiprocessing
from alvi import server
from alvi.tests.resources.base import ResourceFactory
from alvi.tests.resources.base import Resource
and context (functions, classes, or occasionally code) from other files:
# Path: alvi/server.py
# API_URL_SCENE_REGISTER = 'api/scene/register'
# API_URL_SCENE_SYNC = 'api/scene/sync'
# def get_json_data(request):
# def post(self, *args, **kwargs):
# def on_connection_close(self):
# def post(self, *args, **kwargs):
# def run(config_path=""):
# def register_scene(*args, **kwargs):
# class RegisterSceneHandler(tornado.web.RequestHandler):
# class SyncSceneHandler(tornado.web.RequestHandler):
#
# Path: alvi/tests/resources/base.py
# class ResourceFactory(metaclass=abc.ABCMeta):
# @staticmethod
# @abc.abstractmethod
# def create(*args, **kwargs):
# raise NotImplementedError()
#
# Path: alvi/tests/resources/base.py
# class Resource(metaclass=abc.ABCMeta):
# @abc.abstractmethod
# def destroy(self):
# raise NotImplementedError()
. Output only the next line. | self._process.start() |
Next line prediction: <|code_start|>
logger = logging.getLogger(__name__)
class Backend(ResourceFactory):
@staticmethod
<|code_end|>
. Use current file imports:
(import time
import logging
import multiprocessing
from alvi import server
from alvi.tests.resources.base import ResourceFactory
from alvi.tests.resources.base import Resource)
and context including class names, function names, or small code snippets from other files:
# Path: alvi/server.py
# API_URL_SCENE_REGISTER = 'api/scene/register'
# API_URL_SCENE_SYNC = 'api/scene/sync'
# def get_json_data(request):
# def post(self, *args, **kwargs):
# def on_connection_close(self):
# def post(self, *args, **kwargs):
# def run(config_path=""):
# def register_scene(*args, **kwargs):
# class RegisterSceneHandler(tornado.web.RequestHandler):
# class SyncSceneHandler(tornado.web.RequestHandler):
#
# Path: alvi/tests/resources/base.py
# class ResourceFactory(metaclass=abc.ABCMeta):
# @staticmethod
# @abc.abstractmethod
# def create(*args, **kwargs):
# raise NotImplementedError()
#
# Path: alvi/tests/resources/base.py
# class Resource(metaclass=abc.ABCMeta):
# @abc.abstractmethod
# def destroy(self):
# raise NotImplementedError()
. Output only the next line. | def create(config_path): |
Using the snippet: <|code_start|>
logger = logging.getLogger(__name__)
class Backend(ResourceFactory):
@staticmethod
def create(config_path):
<|code_end|>
, determine the next line of code. You have imports:
import time
import logging
import multiprocessing
from alvi import server
from alvi.tests.resources.base import ResourceFactory
from alvi.tests.resources.base import Resource
and context (class names, function names, or code) available:
# Path: alvi/server.py
# API_URL_SCENE_REGISTER = 'api/scene/register'
# API_URL_SCENE_SYNC = 'api/scene/sync'
# def get_json_data(request):
# def post(self, *args, **kwargs):
# def on_connection_close(self):
# def post(self, *args, **kwargs):
# def run(config_path=""):
# def register_scene(*args, **kwargs):
# class RegisterSceneHandler(tornado.web.RequestHandler):
# class SyncSceneHandler(tornado.web.RequestHandler):
#
# Path: alvi/tests/resources/base.py
# class ResourceFactory(metaclass=abc.ABCMeta):
# @staticmethod
# @abc.abstractmethod
# def create(*args, **kwargs):
# raise NotImplementedError()
#
# Path: alvi/tests/resources/base.py
# class Resource(metaclass=abc.ABCMeta):
# @abc.abstractmethod
# def destroy(self):
# raise NotImplementedError()
. Output only the next line. | return LocalBackend(config_path) |
Here is a snippet: <|code_start|>
logger = logging.getLogger(__name__)
class TestTree(TestContainer):
options = dict(n=7, parents="0, 0, 1, 1, 4, 4")
def test_create_node(self):
page = pages.Tree(self._browser.driver, "TreeCreateNode")
page.run(options=TestTree.options)
self.assertEqual(7, len(page.svg.nodes), "create_node does not work properly")
<|code_end|>
. Write the next line using the current file imports:
import logging
import alvi.tests.pages as pages
from alvi.tests.test_client.base import TestContainer
and context from other files:
# Path: alvi/tests/test_client/base.py
# class TestContainer(unittest.TestCase):
# @classmethod
# def setUpClass(cls):
# config_path = os.path.join(os.path.dirname(__file__), "config.py")
# cls._backend = Backend.create(config_path)
# cls._client = Client.create()
# cls._browser = Browser.create()
#
# @classmethod
# def tearDownClass(cls):
# cls._browser.destroy()
# cls._client.destroy()
# cls._backend.destroy()
, which may include functions, classes, or code. Output only the next line. | node_data = sorted(page.svg.node_data, key=lambda d: d['id']) |
Predict the next line for this snippet: <|code_start|>
class RandomDataGenerator(DataGenerator):
def _values(self):
qty = self.quantity()
<|code_end|>
with the help of current file imports:
import random
from alvi.client.data_generators.base import DataGenerator
and context from other files:
# Path: alvi/client/data_generators/base.py
# class DataGenerator(metaclass=abc.ABCMeta):
# class Form(forms.Form):
# n = forms.IntegerField(min_value=1, max_value=256, label='Elements', initial=64)
#
# def __init__(self, options):
# form = self.Form(options)
# if not form.is_valid():
# raise forms.ValidationError(form.errors)
# self._options = form.cleaned_data
# self._values_iterator = None
#
# @property
# def values(self):
# """
# return iterator over self.quantity of subsequent generated values
# """
# if not self._values_iterator:
# self._values_iterator = self._values()
# return self._values_iterator
#
# @abc.abstractmethod
# def _values(self):
# """abstract method that shall return iterator to subsequent generated values"""
# raise NotImplementedError
#
# def quantity(self):
# return self._options['n']
, which may contain function names, class names, or code. Output only the next line. | return (random.randint(1, qty) for _ in range(qty)).__iter__() |
Predict the next line after this snippet: <|code_start|>
logger = logging.getLogger(__name__)
class TestArray(TestContainer):
def test_array(self):
cartesian_scene = pages.Cartesian(self._browser.driver, "ArrayCreateNode")
cartesian_scene.run(options=dict(n=4))
self.assertEqual(4, len(cartesian_scene.svg.nodes), "create_element does not work properly")
node_values = [d['y'] for d in cartesian_scene.svg.node_data]
self.assertEqual([0, 1, 2, 3], node_values, "create_element does not work properly")
def test_update(self):
cartesian_page = pages.Cartesian(self._browser.driver, "ArrayUpdateNode")
cartesian_page.run(options=dict(n=4))
self.assertEqual(4, len(cartesian_page.svg.nodes), "create_element does not work properly")
<|code_end|>
using the current file's imports:
import logging
import alvi.tests.pages as pages
from alvi.tests.test_client.base import TestContainer
and any relevant context from other files:
# Path: alvi/tests/test_client/base.py
# class TestContainer(unittest.TestCase):
# @classmethod
# def setUpClass(cls):
# config_path = os.path.join(os.path.dirname(__file__), "config.py")
# cls._backend = Backend.create(config_path)
# cls._client = Client.create()
# cls._browser = Browser.create()
#
# @classmethod
# def tearDownClass(cls):
# cls._browser.destroy()
# cls._client.destroy()
# cls._backend.destroy()
. Output only the next line. | node_values = [d['y'] for d in cartesian_page.svg.node_data] |
Predict the next line after this snippet: <|code_start|> def sort(self, **kwargs):
array = kwargs['container']
right_marker = array.create_marker("right", 0)
left_marker = array.create_marker("left", 0)
left_h_marker = array.create_marker("left+h", 0)
array.sync()
h = 1
while h < array.size() // 3:
h = 3 * h + 1
while h >= 1:
array.stats.h = h
array.sync()
right = 0
while right < array.size()-h:
right_marker.move(right+h)
left = right
while left >= 0:
left_marker.move(left)
left_h_marker.move(left+h)
#array.sync()
array.stats.comparisons += 1
if array[left] > array[left+h]:
self.swap(array, left, left+h)
#array.sync()
else:
break
left -= h
right += h
array.sync()
h //= 3
<|code_end|>
using the current file's imports:
from alvi.client.scenes.sort import Sort
and any relevant context from other files:
# Path: alvi/client/scenes/sort.py
# class Sort(base.Scene):
# """abstract scene, not to be used directly"""
# def swap(self, array, index_a, index_b):
# t = array[index_a]
# array[index_a] = array[index_b]
# array[index_b] = t
# array.stats.assignments += 2
#
# def init(self, array, n):
# array.stats.comparisons = 0
# array.stats.assignments = 0
# array.init(n)
# array.sync()
#
# def generate_points(self, array, data_generator):
# for i, value in enumerate(data_generator.values):
# array[i] = value
# array.sync()
#
# @abc.abstractmethod
# def sort(self, **kwargs):
# raise NotImplementedError
#
# def run(self, **kwargs):
# data_generator = kwargs['data_generator']
# array = kwargs['container']
# array.stats.elements = data_generator.quantity()
# self.init(array, data_generator.quantity())
# self.generate_points(array, data_generator)
# self.sort(**kwargs)
#
# @staticmethod
# def container_class():
# return alvi.client.containers.Array
#
# def test(self, array, test_case):
# for i in range(1, array.size()):
# previous = array[i-1]
# current = array[i]
# test_case.assertLessEqual(previous, current)
. Output only the next line. | array.sync() |
Next line prediction: <|code_start|>
logger = logging.getLogger(__name__)
class Browser(ResourceFactory):
@staticmethod
def create():
return LocalBrowser()
class LocalBrowser(Resource):
<|code_end|>
. Use current file imports:
(import logging
from alvi.tests.resources.base import Resource
from alvi.tests.resources.base import ResourceFactory
from selenium import webdriver)
and context including class names, function names, or small code snippets from other files:
# Path: alvi/tests/resources/base.py
# class Resource(metaclass=abc.ABCMeta):
# @abc.abstractmethod
# def destroy(self):
# raise NotImplementedError()
#
# Path: alvi/tests/resources/base.py
# class ResourceFactory(metaclass=abc.ABCMeta):
# @staticmethod
# @abc.abstractmethod
# def create(*args, **kwargs):
# raise NotImplementedError()
. Output only the next line. | def __init__(self): |
Based on the snippet: <|code_start|>
logger = logging.getLogger(__name__)
class Browser(ResourceFactory):
@staticmethod
def create():
return LocalBrowser()
class LocalBrowser(Resource):
def __init__(self):
logger.info("setting up browser")
#TODO config
<|code_end|>
, predict the immediate next line with the help of imports:
import logging
from alvi.tests.resources.base import Resource
from alvi.tests.resources.base import ResourceFactory
from selenium import webdriver
and context (classes, functions, sometimes code) from other files:
# Path: alvi/tests/resources/base.py
# class Resource(metaclass=abc.ABCMeta):
# @abc.abstractmethod
# def destroy(self):
# raise NotImplementedError()
#
# Path: alvi/tests/resources/base.py
# class ResourceFactory(metaclass=abc.ABCMeta):
# @staticmethod
# @abc.abstractmethod
# def create(*args, **kwargs):
# raise NotImplementedError()
. Output only the next line. | self._driver = webdriver.Firefox() |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.