Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Predict the next line after this snippet: <|code_start|># Various HTTP calls against HTTPBin
def test_get_graph(url, query_params):
http_params = dict(url=url, query=query_params, mime_type='application/json',
verify_ssl=False)
v = value.Value(value=url)
h = http.Get(**http_params)
p = printer.ConsolePrinter()
g = graph.Graph('test_get_graph', [v, h, p])
g.connect(p, h, 'message')
g.connect(h, v, 'url')
return g
def test_post_graph(url, post_data):
http_params = dict(url=url, mime_type='application/json', verify_ssl=False)
v = value.Value(value=url)
post_data = value.Value(value=post_data)
h = http.Post(**http_params)
p = printer.ConsolePrinter()
g = graph.Graph('test_post_graph', [v, post_data, h, p])
g.connect(p, h, 'message')
g.connect(h, v, 'url')
<|code_end|>
using the current file's imports:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import printer, value, http
and any relevant context from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/http.py
# class HttpClient(node.Node):
# class StatusCode(node.Node):
# class StatusCodeOk(node.Node):
# class RawGet(HttpClient):
# class Get(RawGet):
# class RawPost(HttpClient):
# class Post(RawPost):
# class RawPut(HttpClient):
# class Put(RawPut):
# class RawDelete(HttpClient):
# class Delete(RawDelete):
# DEFAULT_TIMEOUT_SECS = 3
# def _encode_payload(self, response, mime_type):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
. Output only the next line. | g.connect(h, post_data, 'post_data') |
Predict the next line for this snippet: <|code_start|> v = value.Value(value=url)
post_data = value.Value(value=post_data)
h = http.Post(**http_params)
p = printer.ConsolePrinter()
g = graph.Graph('test_post_graph', [v, post_data, h, p])
g.connect(p, h, 'message')
g.connect(h, v, 'url')
g.connect(h, post_data, 'post_data')
return g
def test_put_graph(url, put_data):
http_params = dict(url=url, post_data=put_data, mime_type='application/json',
verify_ssl=False)
v = value.Value(value=url)
h = http.Put(**http_params)
p = printer.ConsolePrinter()
g = graph.Graph('test_put_graph', [v, h, p])
g.connect(p, h, 'message')
g.connect(h, v, 'url')
return g
def test_delete_graph(url):
<|code_end|>
with the help of current file imports:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import printer, value, http
and context from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/http.py
# class HttpClient(node.Node):
# class StatusCode(node.Node):
# class StatusCodeOk(node.Node):
# class RawGet(HttpClient):
# class Get(RawGet):
# class RawPost(HttpClient):
# class Post(RawPost):
# class RawPut(HttpClient):
# class Put(RawPut):
# class RawDelete(HttpClient):
# class Delete(RawDelete):
# DEFAULT_TIMEOUT_SECS = 3
# def _encode_payload(self, response, mime_type):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
, which may contain function names, class names, or code. Output only the next line. | http_params = dict(url=url, mime_type='application/json', verify_ssl=False) |
Here is a snippet: <|code_start|> instance.input(dict(argument=[True, False, False]))
instance.set_output_label('any')
assert instance.output() == [False, True, True]
def test_and():
expected_reqs = ['function', 'argument']
instance = logics.And()
assert instance.requirements == expected_reqs
instance.input(dict(argument=[True, True]))
instance.set_output_label('any')
assert instance.output()
instance = logics.And()
instance.input(dict(argument=[True, False]))
instance.set_output_label('any')
assert not instance.output()
def test_or():
expected_reqs = ['function', 'argument']
instance = logics.Or()
assert instance.requirements == expected_reqs
instance.input(dict(argument=[True, False]))
instance.set_output_label('any')
assert instance.output()
instance = logics.Or()
instance.input(dict(argument=[False, False]))
instance.set_output_label('any')
<|code_end|>
. Write the next line using the current file imports:
from robograph.datamodel.nodes.lib import logics
and context from other files:
# Path: robograph/datamodel/nodes/lib/logics.py
# class Not(apply.Apply):
# class And(apply.Apply):
# class Or(apply.Apply):
# class All(apply.Apply):
# class Nil(apply.Apply):
# class Any(apply.Apply):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
, which may include functions, classes, or code. Output only the next line. | assert not instance.output() |
Predict the next line for this snippet: <|code_start|> instance.connect(root, leaf1, 'any1')
instance.connect(root, leaf2, 'any2')
result = instance.root_node
assert result == root
def test_remove_node():
root = Identity(name='root')
leaf1 = Identity(name='leaf1')
leaf2 = Identity(name='leaf2')
instance = graph.Graph('testgraph', [leaf1, leaf2, root])
instance.connect(root, leaf1, 'any1')
instance.connect(root, leaf2, 'any2')
assert len(instance.nodes) == 3
instance.remove_node(leaf1)
nodes = instance.nodes
assert len(nodes) == 2
assert root in nodes
assert leaf2 in nodes
assert not leaf1 in nodes
def test_remove_nodes():
root = Identity(name='root')
leaf1 = Identity(name='leaf1')
leaf2 = Identity(name='leaf2')
instance = graph.Graph('testgraph', [leaf1, leaf2, root])
instance.connect(root, leaf1, 'any1')
instance.connect(root, leaf2, 'any2')
assert len(instance.nodes) == 3
<|code_end|>
with the help of current file imports:
import pytest
from robograph.datamodel.base import graph, node, exceptions
and context from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/base/node.py
# class Node:
# def __init__(self, **args):
# def name(self):
# def requirements(self):
# def parameters(self):
# def output_label(self):
# def input(self, context):
# def set_output_label(self, output_label):
# def output(self):
# def execute(self):
# def reset(self):
# def __repr__(self):
#
# Path: robograph/datamodel/base/exceptions.py
# class NodeOutputLabelUndefinedError(Exception):
# class GraphError(Exception):
# class NodeConnectionError(GraphError):
# class NodeDeletionError(GraphError):
# class StopGraphExecutionSignal(Exception):
# class GraphExecutionError(GraphError):
, which may contain function names, class names, or code. Output only the next line. | instance.remove_nodes([leaf1, leaf2]) |
Given snippet: <|code_start|>
def test_len():
root = Identity(name='root')
leaf1 = Identity(name='leaf1')
leaf2 = Identity(name='leaf2')
instance = graph.Graph('testgraph', [leaf1, leaf2, root])
assert len(instance) == 3
def test_has_isles():
root = Identity(name='root')
med1 = Identity(name='med1')
med2 = Identity(name='med2')
leaf1 = Identity(name='leaf1')
leaf2 = Identity(name='leaf2')
g = graph.Graph('testgraph', [leaf1, med1, med2, leaf2, root])
g.connect(root, med1, '1')
g.connect(root, med2, '2')
g.connect(med1, leaf1, '3')
g.connect(med2, leaf2, '4')
assert not g.has_isles()
g.remove_node(med2)
assert g.has_isles()
def test_reset():
n1 = WithParameters(a=1, b=2)
n2 = WithParameters(c=1, d=2)
g = graph.Graph('testgraph', [n1, n2])
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import pytest
from robograph.datamodel.base import graph, node, exceptions
and context:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/base/node.py
# class Node:
# def __init__(self, **args):
# def name(self):
# def requirements(self):
# def parameters(self):
# def output_label(self):
# def input(self, context):
# def set_output_label(self, output_label):
# def output(self):
# def execute(self):
# def reset(self):
# def __repr__(self):
#
# Path: robograph/datamodel/base/exceptions.py
# class NodeOutputLabelUndefinedError(Exception):
# class GraphError(Exception):
# class NodeConnectionError(GraphError):
# class NodeDeletionError(GraphError):
# class StopGraphExecutionSignal(Exception):
# class GraphExecutionError(GraphError):
which might include code, classes, or functions. Output only the next line. | for n in g.nodes: |
Predict the next line after this snippet: <|code_start|>
# Tests
def test_get_nodes():
n1 = Identity(name='testnode')
n2 = Identity(name='testnode')
instance = graph.Graph('testgraph', [n1, n2])
nodes = instance.nodes
assert len(nodes) == 2
assert n1 in nodes
assert n2 in nodes
def test_add_node():
n = Identity(name='testnode')
instance = graph.Graph('testgraph')
assert len(instance.nodes) == 0
instance.add_node(n)
nodes = instance.nodes
assert len(nodes) == 1
assert n in nodes
def test_add_nodes():
n1 = Identity(name='testnode')
n2 = Identity(name='testnode')
instance = graph.Graph('testgraph')
assert len(instance.nodes) == 0
instance.add_nodes([n1, n2])
<|code_end|>
using the current file's imports:
import pytest
from robograph.datamodel.base import graph, node, exceptions
and any relevant context from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/base/node.py
# class Node:
# def __init__(self, **args):
# def name(self):
# def requirements(self):
# def parameters(self):
# def output_label(self):
# def input(self, context):
# def set_output_label(self, output_label):
# def output(self):
# def execute(self):
# def reset(self):
# def __repr__(self):
#
# Path: robograph/datamodel/base/exceptions.py
# class NodeOutputLabelUndefinedError(Exception):
# class GraphError(Exception):
# class NodeConnectionError(GraphError):
# class NodeDeletionError(GraphError):
# class StopGraphExecutionSignal(Exception):
# class GraphExecutionError(GraphError):
. Output only the next line. | nodes = instance.nodes |
Here is a snippet: <|code_start|>
def test_reducer():
seq = [1, 2, 3, 4]
expected_result = -24
expected_reqs = ['reducing_function', 'sequence']
instance = fo.Reducer()
assert instance.requirements == expected_reqs
instance.input(dict(reducing_function=lambda x, y: -x*y, sequence=seq))
instance.set_output_label('any')
assert instance.output() == expected_result
def test_filter():
seq = [1, 2, 3, 4]
expected_seq = [2, 4]
expected_reqs = ['filtering_function', 'sequence']
instance = fo.Filter()
assert instance.requirements == expected_reqs
instance.input(dict(filtering_function=lambda x: x % 2 == 0, sequence=seq))
instance.set_output_label('any')
assert instance.output() == expected_seq
def test_sorter():
d1 = dict(a=7, b=9)
d2 = dict(a=0, b=5)
d3 = dict(a=2, b=15)
seq = [d1, d2, d3]
expected_seq = [d2, d3, d1]
<|code_end|>
. Write the next line using the current file imports:
from robograph.datamodel.nodes.lib import functional_operators as fo
and context from other files:
# Path: robograph/datamodel/nodes/lib/functional_operators.py
# class Mapper(node.Node):
# class Reducer(node.Node):
# class Filter(node.Node):
# class Sorter(node.Node):
# class ReverseSorter(Sorter):
# class Uniquer(node.Node):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
, which may include functions, classes, or code. Output only the next line. | expected_reqs = ['sorting_function', 'sequence'] |
Using the snippet: <|code_start|>
def check_date(year, month, day):
assert len(year) == 4
assert len(month) == 2
m = int(month)
assert 1 <= m <= 12
assert len(day) == 2
d = int(day)
assert 1 <= d <= 31
def check_time(hours, minutes, seconds):
assert len(hours) == 2
hh = int(hours)
assert 0 <= hh <= 23
assert len(minutes) == 2
mm = int(minutes)
assert 0 <= mm <= 59
assert len(seconds) == 2
<|code_end|>
, determine the next line of code. You have imports:
from robograph.datamodel.nodes.lib import clock
and context (class names, function names, or code) available:
# Path: robograph/datamodel/nodes/lib/clock.py
# class Date(node.Node):
# class FormattedDate(Date):
# class Now(node.Node):
# class UtcNow(Now):
# DEFAULT_DATE_FORMAT = '%Y-%m-%d'
# DEFAULT_DATETIME_FORMAT = '%Y-%m-%dT%H:%M:%S%z'
# def output(self):
# def output(self):
# def output(self):
# def output(self):
. Output only the next line. | ss = int(seconds) |
Predict the next line for this snippet: <|code_start|>
def sort_and_unique(input_file_path, output_file_path):
file_reader = files.TextFileReader(filepath=input_file_path,
encoding='UTF-8',
name="file_reader")
to_string_list = apply.Apply(function=lambda c: c.split('\n'),
name="to_string_list")
def remove_duplicates_from(collection):
coll_type = type(collection)
items = set(collection)
return coll_type(items)
uniquer = apply.Apply(function=remove_duplicates_from,
name='uniquer')
sorter = apply.Apply(function=lambda unsorted: sorted(unsorted),
name="sorter")
to_string = apply.Apply(function=lambda token_list: '\n'.join(token_list),
name='to_string')
file_writer = files.TextFileWriter(filepath=output_file_path,
encoding='UTF-8',
name='file_writer')
g = graph.Graph('sort_and_unique', [file_reader, to_string_list, sorter,
uniquer, to_string, file_writer])
g.connect(file_writer, to_string, 'data')
g.connect(to_string, sorter, 'argument')
g.connect(sorter, uniquer, 'argument')
<|code_end|>
with the help of current file imports:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import files, apply
and context from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/files.py
# class File(node.Node):
# class TextFile(File):
# class TextFileReader(TextFile):
# class BinaryFileReader(File):
# class TextFileWriter(TextFile):
# class BinaryFileWriter(File):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
, which may contain function names, class names, or code. Output only the next line. | g.connect(uniquer, to_string_list, 'argument') |
Given the code snippet: <|code_start|># Read from an input file a list of strings, remove duplicates, sort remaining
# items and then write them back to a different file
def sort_and_unique(input_file_path, output_file_path):
file_reader = files.TextFileReader(filepath=input_file_path,
encoding='UTF-8',
name="file_reader")
to_string_list = apply.Apply(function=lambda c: c.split('\n'),
name="to_string_list")
def remove_duplicates_from(collection):
coll_type = type(collection)
items = set(collection)
return coll_type(items)
uniquer = apply.Apply(function=remove_duplicates_from,
name='uniquer')
sorter = apply.Apply(function=lambda unsorted: sorted(unsorted),
name="sorter")
to_string = apply.Apply(function=lambda token_list: '\n'.join(token_list),
name='to_string')
file_writer = files.TextFileWriter(filepath=output_file_path,
<|code_end|>
, generate the next line using the imports in this file:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import files, apply
and context (functions, classes, or occasionally code) from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/files.py
# class File(node.Node):
# class TextFile(File):
# class TextFileReader(TextFile):
# class BinaryFileReader(File):
# class TextFileWriter(TextFile):
# class BinaryFileWriter(File):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
. Output only the next line. | encoding='UTF-8', |
Based on the snippet: <|code_start|># Read from an input file a list of strings, remove duplicates, sort remaining
# items and then write them back to a different file
def sort_and_unique(input_file_path, output_file_path):
file_reader = files.TextFileReader(filepath=input_file_path,
encoding='UTF-8',
name="file_reader")
to_string_list = apply.Apply(function=lambda c: c.split('\n'),
<|code_end|>
, predict the immediate next line with the help of imports:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import files, apply
and context (classes, functions, sometimes code) from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/files.py
# class File(node.Node):
# class TextFile(File):
# class TextFileReader(TextFile):
# class BinaryFileReader(File):
# class TextFileWriter(TextFile):
# class BinaryFileWriter(File):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
. Output only the next line. | name="to_string_list") |
Based on the snippet: <|code_start|># Demo on how to stop a graph execution
def execution_stop(number):
def stop_here(value):
if value >= 0:
raise exceptions.StopGraphExecutionSignal('arg is positive')
raise exceptions.StopGraphExecutionSignal('arg is negative')
v = value.Value(value=number)
a = apply.Apply(function=stop_here)
g = graph.Graph('execution_stop', [a, v])
<|code_end|>
, predict the immediate next line with the help of imports:
from robograph.datamodel.base import graph, exceptions
from robograph.datamodel.nodes.lib import value, apply
and context (classes, functions, sometimes code) from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/base/exceptions.py
# class NodeOutputLabelUndefinedError(Exception):
# class GraphError(Exception):
# class NodeConnectionError(GraphError):
# class NodeDeletionError(GraphError):
# class StopGraphExecutionSignal(Exception):
# class GraphExecutionError(GraphError):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
. Output only the next line. | g.connect(a, v, 'argument') |
Predict the next line for this snippet: <|code_start|># Demo on how to stop a graph execution
def execution_stop(number):
def stop_here(value):
if value >= 0:
raise exceptions.StopGraphExecutionSignal('arg is positive')
raise exceptions.StopGraphExecutionSignal('arg is negative')
v = value.Value(value=number)
a = apply.Apply(function=stop_here)
g = graph.Graph('execution_stop', [a, v])
<|code_end|>
with the help of current file imports:
from robograph.datamodel.base import graph, exceptions
from robograph.datamodel.nodes.lib import value, apply
and context from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/base/exceptions.py
# class NodeOutputLabelUndefinedError(Exception):
# class GraphError(Exception):
# class NodeConnectionError(GraphError):
# class NodeDeletionError(GraphError):
# class StopGraphExecutionSignal(Exception):
# class GraphExecutionError(GraphError):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
, which may contain function names, class names, or code. Output only the next line. | g.connect(a, v, 'argument') |
Based on the snippet: <|code_start|>
def test_requirements():
expected = ['function', 'argument']
instance = apply.Apply()
<|code_end|>
, predict the immediate next line with the help of imports:
from robograph.datamodel.nodes.lib import apply
and context (classes, functions, sometimes code) from other files:
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
. Output only the next line. | assert instance.requirements == expected |
Given the following code snippet before the placeholder: <|code_start|># Given a text, replace occurrences of the word "hello" with "ciao" - if any.
# If no occurrence is found, replace all whitespaces with "_" instead
def replace_word(text):
t = value.Value(value=text, name="text")
s = branching.IfThenApply(condition=lambda x: "hello" in x,
function_true=lambda x: x.replace("hello", "ciao"),
function_false=lambda x: x.replace(" ", "_"),
<|code_end|>
, predict the next line using imports from the current file:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import printer, branching, value
and context including class names, function names, and sometimes code from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/branching.py
# class IfThenApply(node.Node):
# class IfThenReturn(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
. Output only the next line. | name="if") |
Using the snippet: <|code_start|># Given a text, replace occurrences of the word "hello" with "ciao" - if any.
# If no occurrence is found, replace all whitespaces with "_" instead
def replace_word(text):
t = value.Value(value=text, name="text")
s = branching.IfThenApply(condition=lambda x: "hello" in x,
function_true=lambda x: x.replace("hello", "ciao"),
function_false=lambda x: x.replace(" ", "_"),
name="if")
p = printer.ConsolePrinter()
g = graph.Graph('replace_word', [t, s, p])
<|code_end|>
, determine the next line of code. You have imports:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import printer, branching, value
and context (class names, function names, or code) available:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/branching.py
# class IfThenApply(node.Node):
# class IfThenReturn(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
. Output only the next line. | g.connect(p, s, 'message') |
Using the snippet: <|code_start|># Given a text, replace occurrences of the word "hello" with "ciao" - if any.
# If no occurrence is found, replace all whitespaces with "_" instead
def replace_word(text):
t = value.Value(value=text, name="text")
s = branching.IfThenApply(condition=lambda x: "hello" in x,
function_true=lambda x: x.replace("hello", "ciao"),
function_false=lambda x: x.replace(" ", "_"),
<|code_end|>
, determine the next line of code. You have imports:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import printer, branching, value
and context (class names, function names, or code) available:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/branching.py
# class IfThenApply(node.Node):
# class IfThenReturn(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
. Output only the next line. | name="if") |
Predict the next line after this snippet: <|code_start|># Given a text, replace occurrences of the word "hello" with "ciao" - if any.
# If no occurrence is found, replace all whitespaces with "_" instead
def replace_word(text):
t = value.Value(value=text, name="text")
s = branching.IfThenApply(condition=lambda x: "hello" in x,
function_true=lambda x: x.replace("hello", "ciao"),
<|code_end|>
using the current file's imports:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import printer, branching, value
and any relevant context from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/branching.py
# class IfThenApply(node.Node):
# class IfThenReturn(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
. Output only the next line. | function_false=lambda x: x.replace(" ", "_"), |
Based on the snippet: <|code_start|># Given an IP address, geolocate it and send the result over via e-mail
def email_geolocated_ip(recipients_list, smtp_server_params, ip_addr):
subject = value.Value(value='Test mail')
smtp_server_params['sender'] = 'test@test.com'
<|code_end|>
, predict the immediate next line with the help of imports:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import value, email, http
and context (classes, functions, sometimes code) from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/email.py
# class SmtpClient:
# class SmtpEmail(node.Node):
# def __init__(self, server_hostname, server_port, username, password,
# use_tls=True):
# def send(self, subject, body, recipients_list, sender, mime='html'):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/http.py
# class HttpClient(node.Node):
# class StatusCode(node.Node):
# class StatusCodeOk(node.Node):
# class RawGet(HttpClient):
# class Get(RawGet):
# class RawPost(HttpClient):
# class Post(RawPost):
# class RawPut(HttpClient):
# class Put(RawPut):
# class RawDelete(HttpClient):
# class Delete(RawDelete):
# DEFAULT_TIMEOUT_SECS = 3
# def _encode_payload(self, response, mime_type):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
. Output only the next line. | smtp_server_params['mime_type'] = 'text/html' |
Given the following code snippet before the placeholder: <|code_start|># Given an IP address, geolocate it and send the result over via e-mail
def email_geolocated_ip(recipients_list, smtp_server_params, ip_addr):
subject = value.Value(value='Test mail')
smtp_server_params['sender'] = 'test@test.com'
smtp_server_params['mime_type'] = 'text/html'
smtp_server_params['recipients_list'] = recipients_list
sendmail = email.SmtpEmail(**smtp_server_params)
http_params = dict(url='https://api.ip2country.info/ip?'+ip_addr,
mime_type='application/json')
geolocate = http.Get(**http_params)
g = graph.Graph('email_geolocated_ip', [subject, geolocate, sendmail])
g.connect(sendmail, geolocate, 'body')
g.connect(sendmail, subject, 'subject')
<|code_end|>
, predict the next line using imports from the current file:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import value, email, http
and context including class names, function names, and sometimes code from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/email.py
# class SmtpClient:
# class SmtpEmail(node.Node):
# def __init__(self, server_hostname, server_port, username, password,
# use_tls=True):
# def send(self, subject, body, recipients_list, sender, mime='html'):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/http.py
# class HttpClient(node.Node):
# class StatusCode(node.Node):
# class StatusCodeOk(node.Node):
# class RawGet(HttpClient):
# class Get(RawGet):
# class RawPost(HttpClient):
# class Post(RawPost):
# class RawPut(HttpClient):
# class Put(RawPut):
# class RawDelete(HttpClient):
# class Delete(RawDelete):
# DEFAULT_TIMEOUT_SECS = 3
# def _encode_payload(self, response, mime_type):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
. Output only the next line. | return g |
Predict the next line for this snippet: <|code_start|># Given an IP address, geolocate it and send the result over via e-mail
def email_geolocated_ip(recipients_list, smtp_server_params, ip_addr):
subject = value.Value(value='Test mail')
smtp_server_params['sender'] = 'test@test.com'
smtp_server_params['mime_type'] = 'text/html'
smtp_server_params['recipients_list'] = recipients_list
sendmail = email.SmtpEmail(**smtp_server_params)
<|code_end|>
with the help of current file imports:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import value, email, http
and context from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/email.py
# class SmtpClient:
# class SmtpEmail(node.Node):
# def __init__(self, server_hostname, server_port, username, password,
# use_tls=True):
# def send(self, subject, body, recipients_list, sender, mime='html'):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/http.py
# class HttpClient(node.Node):
# class StatusCode(node.Node):
# class StatusCodeOk(node.Node):
# class RawGet(HttpClient):
# class Get(RawGet):
# class RawPost(HttpClient):
# class Post(RawPost):
# class RawPut(HttpClient):
# class Put(RawPut):
# class RawDelete(HttpClient):
# class Delete(RawDelete):
# DEFAULT_TIMEOUT_SECS = 3
# def _encode_payload(self, response, mime_type):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
, which may contain function names, class names, or code. Output only the next line. | http_params = dict(url='https://api.ip2country.info/ip?'+ip_addr, |
Predict the next line for this snippet: <|code_start|>
g = graph.Graph('sum_and_product', [v, s, m, p, b])
g.connect(p, b, 'message')
g.connect(b, s, 'sum value')
g.connect(b, m, 'product value')
g.connect(s, v, 'argument')
g.connect(m, v, 'argument')
return g
def logged_sum_and_product(list_of_numbers):
v = value.Value(value=list_of_numbers)
s = apply.Apply(function=sum)
m = apply.Apply(function=lambda c: reduce(lambda x, y: x * y, c))
b = buffers.Buffer()
logging.basicConfig(level=logging.ERROR)
p = printer.LogPrinter(logger=logging.getLogger(__name__),
loglevel=logging.ERROR)
g = graph.Graph('logged_sum_and_product', [v, s, m, b, p])
g.connect(p, b, 'message')
g.connect(b, s, 'sum value')
g.connect(b, m, 'product value')
g.connect(s, v, 'argument')
g.connect(m, v, 'argument')
<|code_end|>
with the help of current file imports:
import logging
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import apply, printer, value, buffers
and context from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/buffers.py
# class Buffer(node.Node):
# class DelayedBuffer(Buffer):
# def __init__(self, **args):
# def input(self, context):
# def output(self):
# def reset(self):
# def output(self):
, which may contain function names, class names, or code. Output only the next line. | return g |
Given the following code snippet before the placeholder: <|code_start|> m = apply.Apply(function=lambda c: reduce(lambda x, y: x * y, c))
b = buffers.Buffer()
p = printer.ConsolePrinter()
g = graph.Graph('sum_and_product', [v, s, m, p, b])
g.connect(p, b, 'message')
g.connect(b, s, 'sum value')
g.connect(b, m, 'product value')
g.connect(s, v, 'argument')
g.connect(m, v, 'argument')
return g
def logged_sum_and_product(list_of_numbers):
v = value.Value(value=list_of_numbers)
s = apply.Apply(function=sum)
m = apply.Apply(function=lambda c: reduce(lambda x, y: x * y, c))
b = buffers.Buffer()
logging.basicConfig(level=logging.ERROR)
p = printer.LogPrinter(logger=logging.getLogger(__name__),
loglevel=logging.ERROR)
g = graph.Graph('logged_sum_and_product', [v, s, m, b, p])
g.connect(p, b, 'message')
g.connect(b, s, 'sum value')
g.connect(b, m, 'product value')
<|code_end|>
, predict the next line using imports from the current file:
import logging
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import apply, printer, value, buffers
and context including class names, function names, and sometimes code from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/buffers.py
# class Buffer(node.Node):
# class DelayedBuffer(Buffer):
# def __init__(self, **args):
# def input(self, context):
# def output(self):
# def reset(self):
# def output(self):
. Output only the next line. | g.connect(s, v, 'argument') |
Here is a snippet: <|code_start|> v = value.Value(value=list_of_numbers)
s = apply.Apply(function=sum)
m = apply.Apply(function=lambda c: reduce(lambda x, y: x * y, c))
b = buffers.Buffer()
p = printer.ConsolePrinter()
g = graph.Graph('sum_and_product', [v, s, m, p, b])
g.connect(p, b, 'message')
g.connect(b, s, 'sum value')
g.connect(b, m, 'product value')
g.connect(s, v, 'argument')
g.connect(m, v, 'argument')
return g
def logged_sum_and_product(list_of_numbers):
v = value.Value(value=list_of_numbers)
s = apply.Apply(function=sum)
m = apply.Apply(function=lambda c: reduce(lambda x, y: x * y, c))
b = buffers.Buffer()
logging.basicConfig(level=logging.ERROR)
p = printer.LogPrinter(logger=logging.getLogger(__name__),
loglevel=logging.ERROR)
g = graph.Graph('logged_sum_and_product', [v, s, m, b, p])
g.connect(p, b, 'message')
<|code_end|>
. Write the next line using the current file imports:
import logging
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import apply, printer, value, buffers
and context from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/buffers.py
# class Buffer(node.Node):
# class DelayedBuffer(Buffer):
# def __init__(self, **args):
# def input(self, context):
# def output(self):
# def reset(self):
# def output(self):
, which may include functions, classes, or code. Output only the next line. | g.connect(b, s, 'sum value') |
Using the snippet: <|code_start|> m = apply.Apply(function=lambda c: reduce(lambda x, y: x * y, c))
b = buffers.Buffer()
p = printer.ConsolePrinter()
g = graph.Graph('sum_and_product', [v, s, m, p, b])
g.connect(p, b, 'message')
g.connect(b, s, 'sum value')
g.connect(b, m, 'product value')
g.connect(s, v, 'argument')
g.connect(m, v, 'argument')
return g
def logged_sum_and_product(list_of_numbers):
v = value.Value(value=list_of_numbers)
s = apply.Apply(function=sum)
m = apply.Apply(function=lambda c: reduce(lambda x, y: x * y, c))
b = buffers.Buffer()
logging.basicConfig(level=logging.ERROR)
p = printer.LogPrinter(logger=logging.getLogger(__name__),
loglevel=logging.ERROR)
g = graph.Graph('logged_sum_and_product', [v, s, m, b, p])
g.connect(p, b, 'message')
g.connect(b, s, 'sum value')
g.connect(b, m, 'product value')
<|code_end|>
, determine the next line of code. You have imports:
import logging
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import apply, printer, value, buffers
and context (class names, function names, or code) available:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/buffers.py
# class Buffer(node.Node):
# class DelayedBuffer(Buffer):
# def __init__(self, **args):
# def input(self, context):
# def output(self):
# def reset(self):
# def output(self):
. Output only the next line. | g.connect(s, v, 'argument') |
Continue the code snippet: <|code_start|> v = value.Value(value=list_of_numbers)
s = apply.Apply(function=sum)
m = apply.Apply(function=lambda c: reduce(lambda x, y: x * y, c))
b = buffers.Buffer()
p = printer.ConsolePrinter()
g = graph.Graph('sum_and_product', [v, s, m, p, b])
g.connect(p, b, 'message')
g.connect(b, s, 'sum value')
g.connect(b, m, 'product value')
g.connect(s, v, 'argument')
g.connect(m, v, 'argument')
return g
def logged_sum_and_product(list_of_numbers):
v = value.Value(value=list_of_numbers)
s = apply.Apply(function=sum)
m = apply.Apply(function=lambda c: reduce(lambda x, y: x * y, c))
b = buffers.Buffer()
logging.basicConfig(level=logging.ERROR)
p = printer.LogPrinter(logger=logging.getLogger(__name__),
loglevel=logging.ERROR)
g = graph.Graph('logged_sum_and_product', [v, s, m, b, p])
g.connect(p, b, 'message')
<|code_end|>
. Use current file imports:
import logging
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import apply, printer, value, buffers
and context (classes, functions, or code) from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/buffers.py
# class Buffer(node.Node):
# class DelayedBuffer(Buffer):
# def __init__(self, **args):
# def input(self, context):
# def output(self):
# def reset(self):
# def output(self):
. Output only the next line. | g.connect(b, s, 'sum value') |
Given the code snippet: <|code_start|>
g = graph.Graph('sum_and_product', [v, s, m, p, b])
g.connect(p, b, 'message')
g.connect(b, s, 'sum value')
g.connect(b, m, 'product value')
g.connect(s, v, 'argument')
g.connect(m, v, 'argument')
return g
def logged_sum_and_product(list_of_numbers):
v = value.Value(value=list_of_numbers)
s = apply.Apply(function=sum)
m = apply.Apply(function=lambda c: reduce(lambda x, y: x * y, c))
b = buffers.Buffer()
logging.basicConfig(level=logging.ERROR)
p = printer.LogPrinter(logger=logging.getLogger(__name__),
loglevel=logging.ERROR)
g = graph.Graph('logged_sum_and_product', [v, s, m, b, p])
g.connect(p, b, 'message')
g.connect(b, s, 'sum value')
g.connect(b, m, 'product value')
g.connect(s, v, 'argument')
g.connect(m, v, 'argument')
<|code_end|>
, generate the next line using the imports in this file:
import logging
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import printer, value, buffers, apply
and context (functions, classes, or occasionally code) from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/buffers.py
# class Buffer(node.Node):
# class DelayedBuffer(Buffer):
# def __init__(self, **args):
# def input(self, context):
# def output(self):
# def reset(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
. Output only the next line. | return g |
Predict the next line after this snippet: <|code_start|># Given a list of numbers, calculate its sum and product and print it on screen
def sum_and_product(list_of_numbers):
v = value.Value(value=list_of_numbers)
s = apply.Apply(function=sum)
m = apply.Apply(function=lambda c: reduce(lambda x, y: x * y, c))
b = buffers.Buffer()
p = printer.ConsolePrinter()
g = graph.Graph('sum_and_product', [v, s, m, p, b])
g.connect(p, b, 'message')
g.connect(b, s, 'sum value')
g.connect(b, m, 'product value')
<|code_end|>
using the current file's imports:
import logging
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import printer, value, buffers, apply
and any relevant context from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/buffers.py
# class Buffer(node.Node):
# class DelayedBuffer(Buffer):
# def __init__(self, **args):
# def input(self, context):
# def output(self):
# def reset(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
. Output only the next line. | g.connect(s, v, 'argument') |
Next line prediction: <|code_start|> b = buffers.Buffer()
p = printer.ConsolePrinter()
g = graph.Graph('sum_and_product', [v, s, m, p, b])
g.connect(p, b, 'message')
g.connect(b, s, 'sum value')
g.connect(b, m, 'product value')
g.connect(s, v, 'argument')
g.connect(m, v, 'argument')
return g
def logged_sum_and_product(list_of_numbers):
v = value.Value(value=list_of_numbers)
s = apply.Apply(function=sum)
m = apply.Apply(function=lambda c: reduce(lambda x, y: x * y, c))
b = buffers.Buffer()
logging.basicConfig(level=logging.ERROR)
p = printer.LogPrinter(logger=logging.getLogger(__name__),
loglevel=logging.ERROR)
g = graph.Graph('logged_sum_and_product', [v, s, m, b, p])
g.connect(p, b, 'message')
g.connect(b, s, 'sum value')
g.connect(b, m, 'product value')
g.connect(s, v, 'argument')
<|code_end|>
. Use current file imports:
(import logging
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import printer, value, buffers, apply)
and context including class names, function names, or small code snippets from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/buffers.py
# class Buffer(node.Node):
# class DelayedBuffer(Buffer):
# def __init__(self, **args):
# def input(self, context):
# def output(self):
# def reset(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
. Output only the next line. | g.connect(m, v, 'argument') |
Continue the code snippet: <|code_start|># Given a list of numbers, calculate its sum and product and print it on screen
def sum_and_product(list_of_numbers):
v = value.Value(value=list_of_numbers)
s = apply.Apply(function=sum)
m = apply.Apply(function=lambda c: reduce(lambda x, y: x * y, c))
b = buffers.Buffer()
p = printer.ConsolePrinter()
g = graph.Graph('sum_and_product', [v, s, m, p, b])
g.connect(p, b, 'message')
<|code_end|>
. Use current file imports:
import logging
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import printer, value, buffers, apply
and context (classes, functions, or code) from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/buffers.py
# class Buffer(node.Node):
# class DelayedBuffer(Buffer):
# def __init__(self, **args):
# def input(self, context):
# def output(self):
# def reset(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
. Output only the next line. | g.connect(b, s, 'sum value') |
Predict the next line after this snippet: <|code_start|># Given a list of numbers, calculate its sum and product and print it on screen
def sum_and_product(list_of_numbers):
v = value.Value(value=list_of_numbers)
s = apply.Apply(function=sum)
m = apply.Apply(function=lambda c: reduce(lambda x, y: x * y, c))
b = buffers.Buffer()
p = printer.ConsolePrinter()
g = graph.Graph('sum_and_product', [v, s, m, p, b])
g.connect(p, b, 'message')
g.connect(b, s, 'sum value')
g.connect(b, m, 'product value')
<|code_end|>
using the current file's imports:
import logging
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import printer, value, buffers, apply
and any relevant context from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/printer.py
# class ConsolePrinter(node.Node):
# class LogPrinter(node.Node):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/buffers.py
# class Buffer(node.Node):
# class DelayedBuffer(Buffer):
# def __init__(self, **args):
# def input(self, context):
# def output(self):
# def reset(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/apply.py
# class Apply(node.Node):
# def output(self):
. Output only the next line. | g.connect(s, v, 'argument') |
Continue the code snippet: <|code_start|>
def test_sum():
seq = [1, -4, 7, 3]
instance = maths.Sum()
instance.input(dict(argument=seq))
instance.set_output_label('any')
assert 7 == instance.output()
def test_product():
seq = [1, -4, 7, 3]
instance = maths.Product(argument=seq)
instance.set_output_label('any')
assert -84 == instance.output()
def test_floor():
instance = maths.Floor(argument=4.237)
instance.set_output_label('any')
assert 4 == instance.output()
def test_ceil():
instance = maths.Ceil(argument=4.237)
instance.set_output_label('any')
assert 5 == instance.output()
<|code_end|>
. Use current file imports:
from robograph.datamodel.nodes.lib import maths
and context (classes, functions, or code) from other files:
# Path: robograph/datamodel/nodes/lib/maths.py
# class Pi(value.Value):
# class E(value.Value):
# class Sum(apply.Apply):
# class Product(apply.Apply):
# class Floor(apply.Apply):
# class Ceil(apply.Apply):
# class Sqrt(apply.Apply):
# class Max(apply.Apply):
# class Min(apply.Apply):
# class Sin(apply.Apply):
# class Cos(apply.Apply):
# class Abs(apply.Apply):
# class Exp(apply.Apply):
# class Power(Node):
# class Log(apply.Apply):
# class Log10(apply.Apply):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
# def __init__(self, **args):
# def output(self):
# def __init__(self, **args):
# def __init__(self, **args):
. Output only the next line. | def test_sqrt(): |
Continue the code snippet: <|code_start|># Downloads an image from a remote HTTP server and saves it to a local file
def scraper_image(img_url, target_path):
url = value.Value(value=img_url)
client = http.Get(mime_type='image/png', )
writer = files.BinaryFileWriter(filepath=target_path)
g = graph.Graph('scrape_image', [url, client, writer])
g.connect(writer, client, 'data')
<|code_end|>
. Use current file imports:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import files, value, http
and context (classes, functions, or code) from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/files.py
# class File(node.Node):
# class TextFile(File):
# class TextFileReader(TextFile):
# class BinaryFileReader(File):
# class TextFileWriter(TextFile):
# class BinaryFileWriter(File):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/http.py
# class HttpClient(node.Node):
# class StatusCode(node.Node):
# class StatusCodeOk(node.Node):
# class RawGet(HttpClient):
# class Get(RawGet):
# class RawPost(HttpClient):
# class Post(RawPost):
# class RawPut(HttpClient):
# class Put(RawPut):
# class RawDelete(HttpClient):
# class Delete(RawDelete):
# DEFAULT_TIMEOUT_SECS = 3
# def _encode_payload(self, response, mime_type):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
. Output only the next line. | g.connect(client, url, 'url') |
Given the following code snippet before the placeholder: <|code_start|># Downloads an image from a remote HTTP server and saves it to a local file
def scraper_image(img_url, target_path):
url = value.Value(value=img_url)
client = http.Get(mime_type='image/png', )
writer = files.BinaryFileWriter(filepath=target_path)
g = graph.Graph('scrape_image', [url, client, writer])
g.connect(writer, client, 'data')
<|code_end|>
, predict the next line using imports from the current file:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import files, value, http
and context including class names, function names, and sometimes code from other files:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/files.py
# class File(node.Node):
# class TextFile(File):
# class TextFileReader(TextFile):
# class BinaryFileReader(File):
# class TextFileWriter(TextFile):
# class BinaryFileWriter(File):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/http.py
# class HttpClient(node.Node):
# class StatusCode(node.Node):
# class StatusCodeOk(node.Node):
# class RawGet(HttpClient):
# class Get(RawGet):
# class RawPost(HttpClient):
# class Post(RawPost):
# class RawPut(HttpClient):
# class Put(RawPut):
# class RawDelete(HttpClient):
# class Delete(RawDelete):
# DEFAULT_TIMEOUT_SECS = 3
# def _encode_payload(self, response, mime_type):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
. Output only the next line. | g.connect(client, url, 'url') |
Given snippet: <|code_start|># Downloads an image from a remote HTTP server and saves it to a local file
def scraper_image(img_url, target_path):
url = value.Value(value=img_url)
client = http.Get(mime_type='image/png', )
writer = files.BinaryFileWriter(filepath=target_path)
g = graph.Graph('scrape_image', [url, client, writer])
g.connect(writer, client, 'data')
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from robograph.datamodel.base import graph
from robograph.datamodel.nodes.lib import files, value, http
and context:
# Path: robograph/datamodel/base/graph.py
# class Graph:
# def __init__(self, name, nodes=None):
# def root_node(self):
# def nodes(self):
# def edges(self):
# def nxgraph(self):
# def name(self):
# def add_node(self, node):
# def add_nodes(self, sequence_of_nodes):
# def remove_node(self, node):
# def remove_nodes(self, sequence_of_nodes):
# def connect(self, node_from, node_to, output_label):
# def has_isles(self):
# def execute(self, result_label="result"):
# def reset(self):
# def __repr__(self):
# def __len__(self):
#
# Path: robograph/datamodel/nodes/lib/files.py
# class File(node.Node):
# class TextFile(File):
# class TextFileReader(TextFile):
# class BinaryFileReader(File):
# class TextFileWriter(TextFile):
# class BinaryFileWriter(File):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/value.py
# class Value(node.Node):
# def output(self):
#
# Path: robograph/datamodel/nodes/lib/http.py
# class HttpClient(node.Node):
# class StatusCode(node.Node):
# class StatusCodeOk(node.Node):
# class RawGet(HttpClient):
# class Get(RawGet):
# class RawPost(HttpClient):
# class Post(RawPost):
# class RawPut(HttpClient):
# class Put(RawPut):
# class RawDelete(HttpClient):
# class Delete(RawDelete):
# DEFAULT_TIMEOUT_SECS = 3
# def _encode_payload(self, response, mime_type):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
# def output(self):
which might include code, classes, or functions. Output only the next line. | g.connect(client, url, 'url') |
Continue the code snippet: <|code_start|>
class PWETimeSeriesModule:
CONSTANT_STATE_KEYWORD = 'constant'
@staticmethod
def group_by_time(dfs, rels):
time_to_state_mapper = {}
temporal_rels = [rel for rel in rels
if ((META_DATA_TEMPORAL_DEC_KEYWORD in rel.meta_data) and (len(rel.meta_data[META_DATA_TEMPORAL_DEC_KEYWORD]) > 0))]
# i.e. it has atleast one temporal column
# In fact at this point we only use the first temporal column
temporal_rel_names = {rel.relation_name for rel in temporal_rels}
non_temporal_rel_names = set(dfs.keys()) - temporal_rel_names
time_to_state_mapper[PWETimeSeriesModule.CONSTANT_STATE_KEYWORD] = {}
for rl_name in non_temporal_rel_names:
time_to_state_mapper[PWETimeSeriesModule.CONSTANT_STATE_KEYWORD][rl_name] = dfs[rl_name]
for rl in temporal_rels:
rl_name = rl.relation_name
temporal_index = rl.meta_data[META_DATA_TEMPORAL_DEC_KEYWORD][0]
df = dfs[rl_name]
temporal_col_name = df.columns[temporal_index + 1] # +1 to a/c for the 'pw' column
df_grouped_by_time_step = df.groupby(temporal_col_name)
for t, df_at_t in df_grouped_by_time_step:
<|code_end|>
. Use current file imports:
from .Input_Parsers.Meta_Data_Parser.meta_data_parser import META_DATA_TEMPORAL_DEC_KEYWORD
and context (classes, functions, or code) from other files:
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# META_DATA_TEMPORAL_DEC_KEYWORD = 'temporal_dec'
. Output only the next line. | if t not in time_to_state_mapper: |
Given the following code snippet before the placeholder: <|code_start|>
def parse_pwe_meta_data(asp_rules, silent=False, print_parse_tree=False):
if isinstance(asp_rules, str):
asp_rules = asp_rules.splitlines()
md_comments = preprocess(asp_rules)
md_comments = "\n".join(md_comments)
parsed_meta_data = parse_meta_data_from_string(md_comments, silent, print_parse_tree)
return parsed_meta_data
def parse_pwe_meta_data_from_file(fname, silent=False, print_parse_tree=False):
with open(fname, 'r') as f:
asp_rules = f.read()
<|code_end|>
, predict the next line using imports from the current file:
from .Input_Parsers.Meta_Data_Parser.meta_data_parser import (
parse_meta_data_from_string,
preprocess,
)
and context including class names, function names, and sometimes code from other files:
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# def parse_meta_data_from_string(asp_input_string, silent=False, print_parse_tree=False):
# input_stream = InputStream(asp_input_string)
# return __parse_meta_data__(input_stream, silent, print_parse_tree)
#
# def preprocess(lines):
#
# def has_a_comment(line):
# return line.find(ASP_COMMENT_SYMBOL) != -1
#
# def extract_comment(comment_line):
# comment_start_idx = comment_line.find(ASP_COMMENT_SYMBOL)
# comment = comment_line[comment_start_idx:].strip()
# return comment
#
# def is_a_valid_meta_data_comment(comment):
# pattern = re.compile(META_DATA_COMMENT_REGEX)
# return pattern.search(comment) is not None
#
# lines_with_comments = filter(has_a_comment, lines)
# comments = map(extract_comment, lines_with_comments)
# comments_with_meta_data = filter(is_a_valid_meta_data_comment, comments)
#
# return list(comments_with_meta_data)
. Output only the next line. | return parse_pwe_meta_data(asp_rules, silent, print_parse_tree) |
Continue the code snippet: <|code_start|>
def get_colors_list(df, id):
idx = list(map(int, list(df[df.pw == id].x1)))
clrs = list(df[df.pw == id].x2)
ordered_clrs = [x for _, x in sorted(zip(idx, clrs))]
return ordered_clrs
def visualize(**kwargs):
kwargs = defaultdict(lambda: None, kwargs)
dfs = kwargs['dfs']
relations = kwargs['relations']
save_to_folder = kwargs['save_to_folder']
dist_matrix = kwargs['dist_matrix']
if relations is None or dfs is None:
print("No objects passed.")
exit(1)
db = DBSCAN(metric='precomputed', eps=0.5, min_samples=1)
labels = db.fit_predict(dist_matrix)
unique_indices = {}
label_counts = {}
for i, label in enumerate(labels):
if label not in unique_indices:
unique_indices[label] = i
label_counts[label] = 1
<|code_end|>
. Use current file imports:
from sklearn.cluster import DBSCAN
from ..helper import mkdir_p
from collections import defaultdict
import matplotlib.pyplot as plt
import os
and context (classes, functions, or code) from other files:
# Path: PW_explorer/helper.py
# def mkdir_p(path):
# """Make a directory if it doesn't already exist"""
# try:
# os.makedirs(path)
# except OSError as exc: # Python >2.5
# if exc.errno == errno.EEXIST and os.path.isdir(path):
# pass
# else:
# raise
. Output only the next line. | else: |
Continue the code snippet: <|code_start|>
def build_nx_from_metadata(pw_rel_dfs: dict, graphviz_meta_data: dict):
graph_type = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_GRAPH_TYPE]
if graph_type == META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD:
G = nx.Graph()
elif graph_type == META_DATA_GRAPHVIZ_DIRECTED_KEYWORD:
G = nx.DiGraph()
else:
print("Unrecognized {} attribute. Choose one of ({})".
format(META_DATA_GRAPHVIZ_GRAPH_TYPE,
", ".join([META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD, META_DATA_GRAPHVIZ_DIRECTED_KEYWORD])))
return None
graph_styles = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_STYLES_KEYWORD]
for prop_name, prop_type, prop_value in graph_styles:
G.graph[prop_name] = prop_value
sort_by_ord_key = lambda x: x[1][META_DATA_GRAPHVIZ_ORD_KEYWORD]
for edge_rel_name, edge_rel_details in sorted(graphviz_meta_data[META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD].items(),
key=sort_by_ord_key):
if edge_rel_name in pw_rel_dfs:
rel_df = pw_rel_dfs[edge_rel_name]
edge_head_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD] + 1]
edge_tail_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD] + 1]
edge_styles = edge_rel_details[META_DATA_GRAPHVIZ_STYLES_KEYWORD]
for i, row in rel_df.iterrows():
<|code_end|>
. Use current file imports:
import networkx as nx
from ..Input_Parsers.Meta_Data_Parser.meta_data_parser import (
META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_STYLES_KEYWORD,
META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE,
META_DATA_GRAPHVIZ_ORD_KEYWORD,
META_DATA_GRAPHVIZ_GRAPH_TYPE,
META_DATA_GRAPHVIZ_DIRECTED_KEYWORD,
META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD,
)
and context (classes, functions, or code) from other files:
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD = 'graph'
#
# META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD = 'node'
#
# META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD = 'edge'
#
# META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD = 'head'
#
# META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD = 'tail'
#
# META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD = 'node_id'
#
# META_DATA_GRAPHVIZ_STYLES_KEYWORD = 'styles'
#
# META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE = 'arg_idx'
#
# META_DATA_GRAPHVIZ_ORD_KEYWORD = 'ord'
#
# META_DATA_GRAPHVIZ_GRAPH_TYPE = 'graph_type'
#
# META_DATA_GRAPHVIZ_DIRECTED_KEYWORD = 'directed'
#
# META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD = 'undirected'
. Output only the next line. | head, tail = row[edge_head_attr_name], row[edge_tail_attr_name] |
Predict the next line after this snippet: <|code_start|>
for i, row in rel_df.iterrows():
head, tail = row[edge_head_attr_name], row[edge_tail_attr_name]
curr_edge_style = {}
for prop_name, prop_type, prop_value in edge_styles:
if prop_type == META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE:
prop_value = row[rel_df.columns[prop_value - 1 + 1]]
# -1 to convert from 1-indexed user input to 0-indexed machine index and
# +1 to account for the first column that is 'pw'
curr_edge_style[prop_name] = prop_value
G.add_edge(head, tail, **curr_edge_style)
for node_rel_name, node_rel_details in sorted(graphviz_meta_data[META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD].items(),
key=sort_by_ord_key):
if node_rel_name in pw_rel_dfs:
rel_df = pw_rel_dfs[node_rel_name]
node_id_idx = node_rel_details[META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD]
node_styles = node_rel_details[META_DATA_GRAPHVIZ_STYLES_KEYWORD]
node_id_idx_attr_name = rel_df.columns[node_id_idx + 1]
for i, row in rel_df.iterrows():
node_name = row[node_id_idx_attr_name]
curr_node_style = {}
for prop_name, prop_type, prop_value in node_styles:
if prop_type == META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE:
prop_value = row[rel_df.columns[prop_value - 1 + 1]]
# -1 to convert from 1-indexed user input to 0-indexed machine index and
# +1 to account for the first column that is 'pw'
curr_node_style[prop_name] = prop_value
G.add_node(node_name, **curr_node_style)
<|code_end|>
using the current file's imports:
import networkx as nx
from ..Input_Parsers.Meta_Data_Parser.meta_data_parser import (
META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_STYLES_KEYWORD,
META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE,
META_DATA_GRAPHVIZ_ORD_KEYWORD,
META_DATA_GRAPHVIZ_GRAPH_TYPE,
META_DATA_GRAPHVIZ_DIRECTED_KEYWORD,
META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD,
)
and any relevant context from other files:
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD = 'graph'
#
# META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD = 'node'
#
# META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD = 'edge'
#
# META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD = 'head'
#
# META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD = 'tail'
#
# META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD = 'node_id'
#
# META_DATA_GRAPHVIZ_STYLES_KEYWORD = 'styles'
#
# META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE = 'arg_idx'
#
# META_DATA_GRAPHVIZ_ORD_KEYWORD = 'ord'
#
# META_DATA_GRAPHVIZ_GRAPH_TYPE = 'graph_type'
#
# META_DATA_GRAPHVIZ_DIRECTED_KEYWORD = 'directed'
#
# META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD = 'undirected'
. Output only the next line. | return G |
Here is a snippet: <|code_start|>def build_nx_from_metadata(pw_rel_dfs: dict, graphviz_meta_data: dict):
graph_type = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_GRAPH_TYPE]
if graph_type == META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD:
G = nx.Graph()
elif graph_type == META_DATA_GRAPHVIZ_DIRECTED_KEYWORD:
G = nx.DiGraph()
else:
print("Unrecognized {} attribute. Choose one of ({})".
format(META_DATA_GRAPHVIZ_GRAPH_TYPE,
", ".join([META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD, META_DATA_GRAPHVIZ_DIRECTED_KEYWORD])))
return None
graph_styles = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_STYLES_KEYWORD]
for prop_name, prop_type, prop_value in graph_styles:
G.graph[prop_name] = prop_value
sort_by_ord_key = lambda x: x[1][META_DATA_GRAPHVIZ_ORD_KEYWORD]
for edge_rel_name, edge_rel_details in sorted(graphviz_meta_data[META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD].items(),
key=sort_by_ord_key):
if edge_rel_name in pw_rel_dfs:
rel_df = pw_rel_dfs[edge_rel_name]
edge_head_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD] + 1]
edge_tail_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD] + 1]
edge_styles = edge_rel_details[META_DATA_GRAPHVIZ_STYLES_KEYWORD]
for i, row in rel_df.iterrows():
head, tail = row[edge_head_attr_name], row[edge_tail_attr_name]
curr_edge_style = {}
<|code_end|>
. Write the next line using the current file imports:
import networkx as nx
from ..Input_Parsers.Meta_Data_Parser.meta_data_parser import (
META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_STYLES_KEYWORD,
META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE,
META_DATA_GRAPHVIZ_ORD_KEYWORD,
META_DATA_GRAPHVIZ_GRAPH_TYPE,
META_DATA_GRAPHVIZ_DIRECTED_KEYWORD,
META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD,
)
and context from other files:
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD = 'graph'
#
# META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD = 'node'
#
# META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD = 'edge'
#
# META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD = 'head'
#
# META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD = 'tail'
#
# META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD = 'node_id'
#
# META_DATA_GRAPHVIZ_STYLES_KEYWORD = 'styles'
#
# META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE = 'arg_idx'
#
# META_DATA_GRAPHVIZ_ORD_KEYWORD = 'ord'
#
# META_DATA_GRAPHVIZ_GRAPH_TYPE = 'graph_type'
#
# META_DATA_GRAPHVIZ_DIRECTED_KEYWORD = 'directed'
#
# META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD = 'undirected'
, which may include functions, classes, or code. Output only the next line. | for prop_name, prop_type, prop_value in edge_styles: |
Given snippet: <|code_start|>
def build_nx_from_metadata(pw_rel_dfs: dict, graphviz_meta_data: dict):
graph_type = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_GRAPH_TYPE]
if graph_type == META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD:
G = nx.Graph()
elif graph_type == META_DATA_GRAPHVIZ_DIRECTED_KEYWORD:
G = nx.DiGraph()
else:
print("Unrecognized {} attribute. Choose one of ({})".
format(META_DATA_GRAPHVIZ_GRAPH_TYPE,
", ".join([META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD, META_DATA_GRAPHVIZ_DIRECTED_KEYWORD])))
return None
graph_styles = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_STYLES_KEYWORD]
for prop_name, prop_type, prop_value in graph_styles:
G.graph[prop_name] = prop_value
sort_by_ord_key = lambda x: x[1][META_DATA_GRAPHVIZ_ORD_KEYWORD]
for edge_rel_name, edge_rel_details in sorted(graphviz_meta_data[META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD].items(),
key=sort_by_ord_key):
if edge_rel_name in pw_rel_dfs:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import networkx as nx
from ..Input_Parsers.Meta_Data_Parser.meta_data_parser import (
META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_STYLES_KEYWORD,
META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE,
META_DATA_GRAPHVIZ_ORD_KEYWORD,
META_DATA_GRAPHVIZ_GRAPH_TYPE,
META_DATA_GRAPHVIZ_DIRECTED_KEYWORD,
META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD,
)
and context:
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD = 'graph'
#
# META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD = 'node'
#
# META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD = 'edge'
#
# META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD = 'head'
#
# META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD = 'tail'
#
# META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD = 'node_id'
#
# META_DATA_GRAPHVIZ_STYLES_KEYWORD = 'styles'
#
# META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE = 'arg_idx'
#
# META_DATA_GRAPHVIZ_ORD_KEYWORD = 'ord'
#
# META_DATA_GRAPHVIZ_GRAPH_TYPE = 'graph_type'
#
# META_DATA_GRAPHVIZ_DIRECTED_KEYWORD = 'directed'
#
# META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD = 'undirected'
which might include code, classes, or functions. Output only the next line. | rel_df = pw_rel_dfs[edge_rel_name] |
Next line prediction: <|code_start|>
def build_nx_from_metadata(pw_rel_dfs: dict, graphviz_meta_data: dict):
graph_type = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_GRAPH_TYPE]
if graph_type == META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD:
G = nx.Graph()
elif graph_type == META_DATA_GRAPHVIZ_DIRECTED_KEYWORD:
G = nx.DiGraph()
else:
print("Unrecognized {} attribute. Choose one of ({})".
format(META_DATA_GRAPHVIZ_GRAPH_TYPE,
", ".join([META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD, META_DATA_GRAPHVIZ_DIRECTED_KEYWORD])))
return None
graph_styles = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_STYLES_KEYWORD]
for prop_name, prop_type, prop_value in graph_styles:
G.graph[prop_name] = prop_value
sort_by_ord_key = lambda x: x[1][META_DATA_GRAPHVIZ_ORD_KEYWORD]
for edge_rel_name, edge_rel_details in sorted(graphviz_meta_data[META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD].items(),
key=sort_by_ord_key):
if edge_rel_name in pw_rel_dfs:
rel_df = pw_rel_dfs[edge_rel_name]
edge_head_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD] + 1]
edge_tail_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD] + 1]
edge_styles = edge_rel_details[META_DATA_GRAPHVIZ_STYLES_KEYWORD]
for i, row in rel_df.iterrows():
<|code_end|>
. Use current file imports:
(import networkx as nx
from ..Input_Parsers.Meta_Data_Parser.meta_data_parser import (
META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_STYLES_KEYWORD,
META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE,
META_DATA_GRAPHVIZ_ORD_KEYWORD,
META_DATA_GRAPHVIZ_GRAPH_TYPE,
META_DATA_GRAPHVIZ_DIRECTED_KEYWORD,
META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD,
))
and context including class names, function names, or small code snippets from other files:
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD = 'graph'
#
# META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD = 'node'
#
# META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD = 'edge'
#
# META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD = 'head'
#
# META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD = 'tail'
#
# META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD = 'node_id'
#
# META_DATA_GRAPHVIZ_STYLES_KEYWORD = 'styles'
#
# META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE = 'arg_idx'
#
# META_DATA_GRAPHVIZ_ORD_KEYWORD = 'ord'
#
# META_DATA_GRAPHVIZ_GRAPH_TYPE = 'graph_type'
#
# META_DATA_GRAPHVIZ_DIRECTED_KEYWORD = 'directed'
#
# META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD = 'undirected'
. Output only the next line. | head, tail = row[edge_head_attr_name], row[edge_tail_attr_name] |
Continue the code snippet: <|code_start|>
def build_nx_from_metadata(pw_rel_dfs: dict, graphviz_meta_data: dict):
graph_type = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_GRAPH_TYPE]
if graph_type == META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD:
G = nx.Graph()
elif graph_type == META_DATA_GRAPHVIZ_DIRECTED_KEYWORD:
G = nx.DiGraph()
<|code_end|>
. Use current file imports:
import networkx as nx
from ..Input_Parsers.Meta_Data_Parser.meta_data_parser import (
META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_STYLES_KEYWORD,
META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE,
META_DATA_GRAPHVIZ_ORD_KEYWORD,
META_DATA_GRAPHVIZ_GRAPH_TYPE,
META_DATA_GRAPHVIZ_DIRECTED_KEYWORD,
META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD,
)
and context (classes, functions, or code) from other files:
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD = 'graph'
#
# META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD = 'node'
#
# META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD = 'edge'
#
# META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD = 'head'
#
# META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD = 'tail'
#
# META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD = 'node_id'
#
# META_DATA_GRAPHVIZ_STYLES_KEYWORD = 'styles'
#
# META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE = 'arg_idx'
#
# META_DATA_GRAPHVIZ_ORD_KEYWORD = 'ord'
#
# META_DATA_GRAPHVIZ_GRAPH_TYPE = 'graph_type'
#
# META_DATA_GRAPHVIZ_DIRECTED_KEYWORD = 'directed'
#
# META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD = 'undirected'
. Output only the next line. | else: |
Using the snippet: <|code_start|> edge_head_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD] + 1]
edge_tail_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD] + 1]
edge_styles = edge_rel_details[META_DATA_GRAPHVIZ_STYLES_KEYWORD]
for i, row in rel_df.iterrows():
head, tail = row[edge_head_attr_name], row[edge_tail_attr_name]
curr_edge_style = {}
for prop_name, prop_type, prop_value in edge_styles:
if prop_type == META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE:
prop_value = row[rel_df.columns[prop_value - 1 + 1]]
# -1 to convert from 1-indexed user input to 0-indexed machine index and
# +1 to account for the first column that is 'pw'
curr_edge_style[prop_name] = prop_value
G.add_edge(head, tail, **curr_edge_style)
for node_rel_name, node_rel_details in sorted(graphviz_meta_data[META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD].items(),
key=sort_by_ord_key):
if node_rel_name in pw_rel_dfs:
rel_df = pw_rel_dfs[node_rel_name]
node_id_idx = node_rel_details[META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD]
node_styles = node_rel_details[META_DATA_GRAPHVIZ_STYLES_KEYWORD]
node_id_idx_attr_name = rel_df.columns[node_id_idx + 1]
for i, row in rel_df.iterrows():
node_name = row[node_id_idx_attr_name]
curr_node_style = {}
for prop_name, prop_type, prop_value in node_styles:
if prop_type == META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE:
prop_value = row[rel_df.columns[prop_value - 1 + 1]]
# -1 to convert from 1-indexed user input to 0-indexed machine index and
# +1 to account for the first column that is 'pw'
<|code_end|>
, determine the next line of code. You have imports:
import networkx as nx
from ..Input_Parsers.Meta_Data_Parser.meta_data_parser import (
META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_STYLES_KEYWORD,
META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE,
META_DATA_GRAPHVIZ_ORD_KEYWORD,
META_DATA_GRAPHVIZ_GRAPH_TYPE,
META_DATA_GRAPHVIZ_DIRECTED_KEYWORD,
META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD,
)
and context (class names, function names, or code) available:
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD = 'graph'
#
# META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD = 'node'
#
# META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD = 'edge'
#
# META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD = 'head'
#
# META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD = 'tail'
#
# META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD = 'node_id'
#
# META_DATA_GRAPHVIZ_STYLES_KEYWORD = 'styles'
#
# META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE = 'arg_idx'
#
# META_DATA_GRAPHVIZ_ORD_KEYWORD = 'ord'
#
# META_DATA_GRAPHVIZ_GRAPH_TYPE = 'graph_type'
#
# META_DATA_GRAPHVIZ_DIRECTED_KEYWORD = 'directed'
#
# META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD = 'undirected'
. Output only the next line. | curr_node_style[prop_name] = prop_value |
Based on the snippet: <|code_start|>
def build_nx_from_metadata(pw_rel_dfs: dict, graphviz_meta_data: dict):
graph_type = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_GRAPH_TYPE]
if graph_type == META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD:
<|code_end|>
, predict the immediate next line with the help of imports:
import networkx as nx
from ..Input_Parsers.Meta_Data_Parser.meta_data_parser import (
META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_STYLES_KEYWORD,
META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE,
META_DATA_GRAPHVIZ_ORD_KEYWORD,
META_DATA_GRAPHVIZ_GRAPH_TYPE,
META_DATA_GRAPHVIZ_DIRECTED_KEYWORD,
META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD,
)
and context (classes, functions, sometimes code) from other files:
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD = 'graph'
#
# META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD = 'node'
#
# META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD = 'edge'
#
# META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD = 'head'
#
# META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD = 'tail'
#
# META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD = 'node_id'
#
# META_DATA_GRAPHVIZ_STYLES_KEYWORD = 'styles'
#
# META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE = 'arg_idx'
#
# META_DATA_GRAPHVIZ_ORD_KEYWORD = 'ord'
#
# META_DATA_GRAPHVIZ_GRAPH_TYPE = 'graph_type'
#
# META_DATA_GRAPHVIZ_DIRECTED_KEYWORD = 'directed'
#
# META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD = 'undirected'
. Output only the next line. | G = nx.Graph() |
Continue the code snippet: <|code_start|>def build_nx_from_metadata(pw_rel_dfs: dict, graphviz_meta_data: dict):
graph_type = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_GRAPH_TYPE]
if graph_type == META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD:
G = nx.Graph()
elif graph_type == META_DATA_GRAPHVIZ_DIRECTED_KEYWORD:
G = nx.DiGraph()
else:
print("Unrecognized {} attribute. Choose one of ({})".
format(META_DATA_GRAPHVIZ_GRAPH_TYPE,
", ".join([META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD, META_DATA_GRAPHVIZ_DIRECTED_KEYWORD])))
return None
graph_styles = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_STYLES_KEYWORD]
for prop_name, prop_type, prop_value in graph_styles:
G.graph[prop_name] = prop_value
sort_by_ord_key = lambda x: x[1][META_DATA_GRAPHVIZ_ORD_KEYWORD]
for edge_rel_name, edge_rel_details in sorted(graphviz_meta_data[META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD].items(),
key=sort_by_ord_key):
if edge_rel_name in pw_rel_dfs:
rel_df = pw_rel_dfs[edge_rel_name]
edge_head_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD] + 1]
edge_tail_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD] + 1]
edge_styles = edge_rel_details[META_DATA_GRAPHVIZ_STYLES_KEYWORD]
for i, row in rel_df.iterrows():
head, tail = row[edge_head_attr_name], row[edge_tail_attr_name]
curr_edge_style = {}
<|code_end|>
. Use current file imports:
import networkx as nx
from ..Input_Parsers.Meta_Data_Parser.meta_data_parser import (
META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_STYLES_KEYWORD,
META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE,
META_DATA_GRAPHVIZ_ORD_KEYWORD,
META_DATA_GRAPHVIZ_GRAPH_TYPE,
META_DATA_GRAPHVIZ_DIRECTED_KEYWORD,
META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD,
)
and context (classes, functions, or code) from other files:
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD = 'graph'
#
# META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD = 'node'
#
# META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD = 'edge'
#
# META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD = 'head'
#
# META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD = 'tail'
#
# META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD = 'node_id'
#
# META_DATA_GRAPHVIZ_STYLES_KEYWORD = 'styles'
#
# META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE = 'arg_idx'
#
# META_DATA_GRAPHVIZ_ORD_KEYWORD = 'ord'
#
# META_DATA_GRAPHVIZ_GRAPH_TYPE = 'graph_type'
#
# META_DATA_GRAPHVIZ_DIRECTED_KEYWORD = 'directed'
#
# META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD = 'undirected'
. Output only the next line. | for prop_name, prop_type, prop_value in edge_styles: |
Next line prediction: <|code_start|>
def build_nx_from_metadata(pw_rel_dfs: dict, graphviz_meta_data: dict):
graph_type = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_GRAPH_TYPE]
if graph_type == META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD:
G = nx.Graph()
elif graph_type == META_DATA_GRAPHVIZ_DIRECTED_KEYWORD:
G = nx.DiGraph()
<|code_end|>
. Use current file imports:
(import networkx as nx
from ..Input_Parsers.Meta_Data_Parser.meta_data_parser import (
META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_STYLES_KEYWORD,
META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE,
META_DATA_GRAPHVIZ_ORD_KEYWORD,
META_DATA_GRAPHVIZ_GRAPH_TYPE,
META_DATA_GRAPHVIZ_DIRECTED_KEYWORD,
META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD,
))
and context including class names, function names, or small code snippets from other files:
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD = 'graph'
#
# META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD = 'node'
#
# META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD = 'edge'
#
# META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD = 'head'
#
# META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD = 'tail'
#
# META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD = 'node_id'
#
# META_DATA_GRAPHVIZ_STYLES_KEYWORD = 'styles'
#
# META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE = 'arg_idx'
#
# META_DATA_GRAPHVIZ_ORD_KEYWORD = 'ord'
#
# META_DATA_GRAPHVIZ_GRAPH_TYPE = 'graph_type'
#
# META_DATA_GRAPHVIZ_DIRECTED_KEYWORD = 'directed'
#
# META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD = 'undirected'
. Output only the next line. | else: |
Given snippet: <|code_start|>
for edge_rel_name, edge_rel_details in sorted(graphviz_meta_data[META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD].items(),
key=sort_by_ord_key):
if edge_rel_name in pw_rel_dfs:
rel_df = pw_rel_dfs[edge_rel_name]
edge_head_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD] + 1]
edge_tail_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD] + 1]
edge_styles = edge_rel_details[META_DATA_GRAPHVIZ_STYLES_KEYWORD]
for i, row in rel_df.iterrows():
head, tail = row[edge_head_attr_name], row[edge_tail_attr_name]
curr_edge_style = {}
for prop_name, prop_type, prop_value in edge_styles:
if prop_type == META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE:
prop_value = row[rel_df.columns[prop_value - 1 + 1]]
# -1 to convert from 1-indexed user input to 0-indexed machine index and
# +1 to account for the first column that is 'pw'
curr_edge_style[prop_name] = prop_value
G.add_edge(head, tail, **curr_edge_style)
for node_rel_name, node_rel_details in sorted(graphviz_meta_data[META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD].items(),
key=sort_by_ord_key):
if node_rel_name in pw_rel_dfs:
rel_df = pw_rel_dfs[node_rel_name]
node_id_idx = node_rel_details[META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD]
node_styles = node_rel_details[META_DATA_GRAPHVIZ_STYLES_KEYWORD]
node_id_idx_attr_name = rel_df.columns[node_id_idx + 1]
for i, row in rel_df.iterrows():
node_name = row[node_id_idx_attr_name]
curr_node_style = {}
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import networkx as nx
from ..Input_Parsers.Meta_Data_Parser.meta_data_parser import (
META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_STYLES_KEYWORD,
META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE,
META_DATA_GRAPHVIZ_ORD_KEYWORD,
META_DATA_GRAPHVIZ_GRAPH_TYPE,
META_DATA_GRAPHVIZ_DIRECTED_KEYWORD,
META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD,
)
and context:
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD = 'graph'
#
# META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD = 'node'
#
# META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD = 'edge'
#
# META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD = 'head'
#
# META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD = 'tail'
#
# META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD = 'node_id'
#
# META_DATA_GRAPHVIZ_STYLES_KEYWORD = 'styles'
#
# META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE = 'arg_idx'
#
# META_DATA_GRAPHVIZ_ORD_KEYWORD = 'ord'
#
# META_DATA_GRAPHVIZ_GRAPH_TYPE = 'graph_type'
#
# META_DATA_GRAPHVIZ_DIRECTED_KEYWORD = 'directed'
#
# META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD = 'undirected'
which might include code, classes, or functions. Output only the next line. | for prop_name, prop_type, prop_value in node_styles: |
Given snippet: <|code_start|> G = nx.DiGraph()
else:
print("Unrecognized {} attribute. Choose one of ({})".
format(META_DATA_GRAPHVIZ_GRAPH_TYPE,
", ".join([META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD, META_DATA_GRAPHVIZ_DIRECTED_KEYWORD])))
return None
graph_styles = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_STYLES_KEYWORD]
for prop_name, prop_type, prop_value in graph_styles:
G.graph[prop_name] = prop_value
sort_by_ord_key = lambda x: x[1][META_DATA_GRAPHVIZ_ORD_KEYWORD]
for edge_rel_name, edge_rel_details in sorted(graphviz_meta_data[META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD].items(),
key=sort_by_ord_key):
if edge_rel_name in pw_rel_dfs:
rel_df = pw_rel_dfs[edge_rel_name]
edge_head_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD] + 1]
edge_tail_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD] + 1]
edge_styles = edge_rel_details[META_DATA_GRAPHVIZ_STYLES_KEYWORD]
for i, row in rel_df.iterrows():
head, tail = row[edge_head_attr_name], row[edge_tail_attr_name]
curr_edge_style = {}
for prop_name, prop_type, prop_value in edge_styles:
if prop_type == META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE:
prop_value = row[rel_df.columns[prop_value - 1 + 1]]
# -1 to convert from 1-indexed user input to 0-indexed machine index and
# +1 to account for the first column that is 'pw'
curr_edge_style[prop_name] = prop_value
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import networkx as nx
from ..Input_Parsers.Meta_Data_Parser.meta_data_parser import (
META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD,
META_DATA_GRAPHVIZ_STYLES_KEYWORD,
META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE,
META_DATA_GRAPHVIZ_ORD_KEYWORD,
META_DATA_GRAPHVIZ_GRAPH_TYPE,
META_DATA_GRAPHVIZ_DIRECTED_KEYWORD,
META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD,
)
and context:
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD = 'graph'
#
# META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD = 'node'
#
# META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD = 'edge'
#
# META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD = 'head'
#
# META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD = 'tail'
#
# META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD = 'node_id'
#
# META_DATA_GRAPHVIZ_STYLES_KEYWORD = 'styles'
#
# META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE = 'arg_idx'
#
# META_DATA_GRAPHVIZ_ORD_KEYWORD = 'ord'
#
# META_DATA_GRAPHVIZ_GRAPH_TYPE = 'graph_type'
#
# META_DATA_GRAPHVIZ_DIRECTED_KEYWORD = 'directed'
#
# META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD = 'undirected'
which might include code, classes, or functions. Output only the next line. | G.add_edge(head, tail, **curr_edge_style) |
Here is a snippet: <|code_start|>#!/usr/bin/env python3
class PWEExport:
@staticmethod
def get_sqlite_schema(dfs):
# this approach will take constant time since there is just one row in the exported database.
TEST_DB_LOCATION = os.path.abspath("test.db")
conn_t = sqlite3.connect(TEST_DB_LOCATION)
for rl_name, df in dfs.items():
t = df.ix[0:0]
<|code_end|>
. Write the next line using the current file imports:
import pandas as pd
import os
import sqlite3
from .helper import (
mkdir_p,
turn_list_into_str,
)
from .Input_Parsers.Meta_Data_Parser.meta_data_parser import (
ASP_COMMENT_SYMBOL,
ASP_SYNTAX_ATTRIBUTE_DEF_KEYWORD,
)
and context from other files:
# Path: PW_explorer/helper.py
# def mkdir_p(path):
# """Make a directory if it doesn't already exist"""
# try:
# os.makedirs(path)
# except OSError as exc: # Python >2.5
# if exc.errno == errno.EEXIST and os.path.isdir(path):
# pass
# else:
# raise
#
# def turn_list_into_str(l):
#
# if isinstance(l, (list,set,frozenset)):
# if len(l) > 1:
# l_ = [turn_list_into_str(l1) for l1 in l[1:]]
# return "{}({})".format(l[0], ",".join(l_))
# elif len(l) == 1:
# return "{}".format(l[0])
# else:
# return ""
# else:
# return l
#
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# ASP_COMMENT_SYMBOL = '%'
#
# ASP_SYNTAX_ATTRIBUTE_DEF_KEYWORD = 'schema'
, which may include functions, classes, or code. Output only the next line. | t.to_sql(str(rl_name), conn_t, if_exists='replace') |
Based on the snippet: <|code_start|>#!/usr/bin/env python3
class PWEExport:
@staticmethod
def get_sqlite_schema(dfs):
# this approach will take constant time since there is just one row in the exported database.
TEST_DB_LOCATION = os.path.abspath("test.db")
conn_t = sqlite3.connect(TEST_DB_LOCATION)
for rl_name, df in dfs.items():
t = df.ix[0:0]
t.to_sql(str(rl_name), conn_t, if_exists='replace')
schema_q = conn_t.execute("SELECT * FROM sqlite_master WHERE type='table' ORDER BY name;")
schemas = []
for row in schema_q.fetchall():
schemas.append(row[4])
for rl_name, df in dfs.items():
conn_t.execute('DROP TABLE ' + str(rl_name))
conn_t.commit()
conn_t.close()
<|code_end|>
, predict the immediate next line with the help of imports:
import pandas as pd
import os
import sqlite3
from .helper import (
mkdir_p,
turn_list_into_str,
)
from .Input_Parsers.Meta_Data_Parser.meta_data_parser import (
ASP_COMMENT_SYMBOL,
ASP_SYNTAX_ATTRIBUTE_DEF_KEYWORD,
)
and context (classes, functions, sometimes code) from other files:
# Path: PW_explorer/helper.py
# def mkdir_p(path):
# """Make a directory if it doesn't already exist"""
# try:
# os.makedirs(path)
# except OSError as exc: # Python >2.5
# if exc.errno == errno.EEXIST and os.path.isdir(path):
# pass
# else:
# raise
#
# def turn_list_into_str(l):
#
# if isinstance(l, (list,set,frozenset)):
# if len(l) > 1:
# l_ = [turn_list_into_str(l1) for l1 in l[1:]]
# return "{}({})".format(l[0], ",".join(l_))
# elif len(l) == 1:
# return "{}".format(l[0])
# else:
# return ""
# else:
# return l
#
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# ASP_COMMENT_SYMBOL = '%'
#
# ASP_SYNTAX_ATTRIBUTE_DEF_KEYWORD = 'schema'
. Output only the next line. | os.remove(TEST_DB_LOCATION) |
Continue the code snippet: <|code_start|>#!/usr/bin/env python3
class PWEExport:
@staticmethod
def get_sqlite_schema(dfs):
# this approach will take constant time since there is just one row in the exported database.
TEST_DB_LOCATION = os.path.abspath("test.db")
conn_t = sqlite3.connect(TEST_DB_LOCATION)
for rl_name, df in dfs.items():
t = df.ix[0:0]
t.to_sql(str(rl_name), conn_t, if_exists='replace')
schema_q = conn_t.execute("SELECT * FROM sqlite_master WHERE type='table' ORDER BY name;")
schemas = []
for row in schema_q.fetchall():
<|code_end|>
. Use current file imports:
import pandas as pd
import os
import sqlite3
from .helper import (
mkdir_p,
turn_list_into_str,
)
from .Input_Parsers.Meta_Data_Parser.meta_data_parser import (
ASP_COMMENT_SYMBOL,
ASP_SYNTAX_ATTRIBUTE_DEF_KEYWORD,
)
and context (classes, functions, or code) from other files:
# Path: PW_explorer/helper.py
# def mkdir_p(path):
# """Make a directory if it doesn't already exist"""
# try:
# os.makedirs(path)
# except OSError as exc: # Python >2.5
# if exc.errno == errno.EEXIST and os.path.isdir(path):
# pass
# else:
# raise
#
# def turn_list_into_str(l):
#
# if isinstance(l, (list,set,frozenset)):
# if len(l) > 1:
# l_ = [turn_list_into_str(l1) for l1 in l[1:]]
# return "{}({})".format(l[0], ",".join(l_))
# elif len(l) == 1:
# return "{}".format(l[0])
# else:
# return ""
# else:
# return l
#
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# ASP_COMMENT_SYMBOL = '%'
#
# ASP_SYNTAX_ATTRIBUTE_DEF_KEYWORD = 'schema'
. Output only the next line. | schemas.append(row[4]) |
Continue the code snippet: <|code_start|>#!/usr/bin/env python3
class PWEExport:
@staticmethod
def get_sqlite_schema(dfs):
# this approach will take constant time since there is just one row in the exported database.
TEST_DB_LOCATION = os.path.abspath("test.db")
conn_t = sqlite3.connect(TEST_DB_LOCATION)
for rl_name, df in dfs.items():
t = df.ix[0:0]
t.to_sql(str(rl_name), conn_t, if_exists='replace')
schema_q = conn_t.execute("SELECT * FROM sqlite_master WHERE type='table' ORDER BY name;")
schemas = []
for row in schema_q.fetchall():
schemas.append(row[4])
<|code_end|>
. Use current file imports:
import pandas as pd
import os
import sqlite3
from .helper import (
mkdir_p,
turn_list_into_str,
)
from .Input_Parsers.Meta_Data_Parser.meta_data_parser import (
ASP_COMMENT_SYMBOL,
ASP_SYNTAX_ATTRIBUTE_DEF_KEYWORD,
)
and context (classes, functions, or code) from other files:
# Path: PW_explorer/helper.py
# def mkdir_p(path):
# """Make a directory if it doesn't already exist"""
# try:
# os.makedirs(path)
# except OSError as exc: # Python >2.5
# if exc.errno == errno.EEXIST and os.path.isdir(path):
# pass
# else:
# raise
#
# def turn_list_into_str(l):
#
# if isinstance(l, (list,set,frozenset)):
# if len(l) > 1:
# l_ = [turn_list_into_str(l1) for l1 in l[1:]]
# return "{}({})".format(l[0], ",".join(l_))
# elif len(l) == 1:
# return "{}".format(l[0])
# else:
# return ""
# else:
# return l
#
# Path: PW_explorer/Input_Parsers/Meta_Data_Parser/meta_data_parser.py
# ASP_COMMENT_SYMBOL = '%'
#
# ASP_SYNTAX_ATTRIBUTE_DEF_KEYWORD = 'schema'
. Output only the next line. | for rl_name, df in dfs.items(): |
Using the snippet: <|code_start|>#!/usr/bin/env python3
# from sklearn.decomposition import PCA
class PWEVisualization:
@staticmethod
def dbscan_clustering(dist_matrix, save_to_file=None):
fig, ax = plt.subplots()
db = DBSCAN(metric='precomputed', eps=0.5, min_samples=1)
labels = db.fit_predict(dist_matrix)
core_samples_mask = np.zeros_like(db.labels_, dtype=bool)
core_samples_mask[db.core_sample_indices_] = True
<|code_end|>
, determine the next line of code. You have imports:
import pandas as pd
import numpy as np
import os
import matplotlib.pyplot as plt
import networkx as nx
import seaborn as sns
from sklearn.cluster import DBSCAN
from scipy.spatial.distance import squareform
from scipy.cluster.hierarchy import dendrogram, linkage
from sklearn.manifold import MDS
from .Custom_Visualization_Functions.graphviz_meta_data_based_visualization import build_nx_from_metadata
and context (class names, function names, or code) available:
# Path: PW_explorer/Custom_Visualization_Functions/graphviz_meta_data_based_visualization.py
# def build_nx_from_metadata(pw_rel_dfs: dict, graphviz_meta_data: dict):
#
# graph_type = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_GRAPH_TYPE]
# if graph_type == META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD:
# G = nx.Graph()
# elif graph_type == META_DATA_GRAPHVIZ_DIRECTED_KEYWORD:
# G = nx.DiGraph()
# else:
# print("Unrecognized {} attribute. Choose one of ({})".
# format(META_DATA_GRAPHVIZ_GRAPH_TYPE,
# ", ".join([META_DATA_GRAPHVIZ_UNDIRECTED_KEYWORD, META_DATA_GRAPHVIZ_DIRECTED_KEYWORD])))
# return None
#
# graph_styles = graphviz_meta_data[META_DATA_GRAPHVIZ_GRAPH_DEF_KEYWORD][META_DATA_GRAPHVIZ_STYLES_KEYWORD]
# for prop_name, prop_type, prop_value in graph_styles:
# G.graph[prop_name] = prop_value
#
# sort_by_ord_key = lambda x: x[1][META_DATA_GRAPHVIZ_ORD_KEYWORD]
#
# for edge_rel_name, edge_rel_details in sorted(graphviz_meta_data[META_DATA_GRAPHVIZ_EDGE_DEF_KEYWORD].items(),
# key=sort_by_ord_key):
# if edge_rel_name in pw_rel_dfs:
# rel_df = pw_rel_dfs[edge_rel_name]
# edge_head_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_HEAD_IDX_DEF_KEYWORD] + 1]
# edge_tail_attr_name = rel_df.columns[edge_rel_details[META_DATA_GRAPHVIZ_EDGE_TAIL_IDX_DEF_KEYWORD] + 1]
# edge_styles = edge_rel_details[META_DATA_GRAPHVIZ_STYLES_KEYWORD]
#
# for i, row in rel_df.iterrows():
# head, tail = row[edge_head_attr_name], row[edge_tail_attr_name]
# curr_edge_style = {}
# for prop_name, prop_type, prop_value in edge_styles:
# if prop_type == META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE:
# prop_value = row[rel_df.columns[prop_value - 1 + 1]]
# # -1 to convert from 1-indexed user input to 0-indexed machine index and
# # +1 to account for the first column that is 'pw'
# curr_edge_style[prop_name] = prop_value
# G.add_edge(head, tail, **curr_edge_style)
#
# for node_rel_name, node_rel_details in sorted(graphviz_meta_data[META_DATA_GRAPHVIZ_NODE_DEF_KEYWORD].items(),
# key=sort_by_ord_key):
# if node_rel_name in pw_rel_dfs:
# rel_df = pw_rel_dfs[node_rel_name]
# node_id_idx = node_rel_details[META_DATA_GRAPHVIZ_NODE_ID_IDX_DEF_KEYWORD]
# node_styles = node_rel_details[META_DATA_GRAPHVIZ_STYLES_KEYWORD]
# node_id_idx_attr_name = rel_df.columns[node_id_idx + 1]
# for i, row in rel_df.iterrows():
# node_name = row[node_id_idx_attr_name]
# curr_node_style = {}
# for prop_name, prop_type, prop_value in node_styles:
# if prop_type == META_DATA_GRAPHVIZ_STYLE_PROPERTY_ARG_IDX_TYPE:
# prop_value = row[rel_df.columns[prop_value - 1 + 1]]
# # -1 to convert from 1-indexed user input to 0-indexed machine index and
# # +1 to account for the first column that is 'pw'
# curr_node_style[prop_name] = prop_value
# G.add_node(node_name, **curr_node_style)
#
# return G
. Output only the next line. | labels = db.labels_ |
Next line prediction: <|code_start|>
def get_telingo_output(telingo_in_fnames: list, num_solutions: int=0):
t = ['telingo', '-n {}'.format(num_solutions), '-Wnone']
t.extend(telingo_in_fnames)
process_ = subprocess.Popen(t, stdout=subprocess.PIPE)
telingo_output = process_.communicate()[0]
# clingo_output = subprocess.check_output()
<|code_end|>
. Use current file imports:
(import os
import subprocess as subprocess
from .helper import (
preprocess_telingo_output,
)
from .meta_data_parser import parse_pwe_meta_data)
and context including class names, function names, or small code snippets from other files:
# Path: PW_explorer/helper.py
# def preprocess_telingo_output(clingo_raw_output: list):
# # TODO Take another look at this to ensure correctness
# start = 0
# for i, line in enumerate(clingo_raw_output):
# if line.strip() == 'Solving...':
# start = i + 1
#
# return clingo_raw_output[start:]
#
# Path: PW_explorer/meta_data_parser.py
# def parse_pwe_meta_data(asp_rules, silent=False, print_parse_tree=False):
# if isinstance(asp_rules, str):
# asp_rules = asp_rules.splitlines()
# md_comments = preprocess(asp_rules)
# md_comments = "\n".join(md_comments)
# parsed_meta_data = parse_meta_data_from_string(md_comments, silent, print_parse_tree)
# return parsed_meta_data
. Output only the next line. | meta_data = {} |
Using the snippet: <|code_start|>
def get_telingo_output(telingo_in_fnames: list, num_solutions: int=0):
t = ['telingo', '-n {}'.format(num_solutions), '-Wnone']
t.extend(telingo_in_fnames)
process_ = subprocess.Popen(t, stdout=subprocess.PIPE)
telingo_output = process_.communicate()[0]
# clingo_output = subprocess.check_output()
meta_data = {}
#attribute_defs = {}
#temporal_decs = {}
for fname in telingo_in_fnames:
with open(fname, 'r') as f:
telingo_rules = f.read().splitlines()
f_meta_data = parse_pwe_meta_data(telingo_rules)
for md_type, md in f_meta_data.items():
if md_type in meta_data:
meta_data[md_type].update(md)
else:
meta_data[md_type] = md
<|code_end|>
, determine the next line of code. You have imports:
import os
import subprocess as subprocess
from .helper import (
preprocess_telingo_output,
)
from .meta_data_parser import parse_pwe_meta_data
and context (class names, function names, or code) available:
# Path: PW_explorer/helper.py
# def preprocess_telingo_output(clingo_raw_output: list):
# # TODO Take another look at this to ensure correctness
# start = 0
# for i, line in enumerate(clingo_raw_output):
# if line.strip() == 'Solving...':
# start = i + 1
#
# return clingo_raw_output[start:]
#
# Path: PW_explorer/meta_data_parser.py
# def parse_pwe_meta_data(asp_rules, silent=False, print_parse_tree=False):
# if isinstance(asp_rules, str):
# asp_rules = asp_rules.splitlines()
# md_comments = preprocess(asp_rules)
# md_comments = "\n".join(md_comments)
# parsed_meta_data = parse_meta_data_from_string(md_comments, silent, print_parse_tree)
# return parsed_meta_data
. Output only the next line. | teling_out_lines = telingo_output.splitlines() |
Given snippet: <|code_start|>
def get_clingo_output(clingo_in_fnames: list, num_solutions: int=0, show_warnings=False, other_args: list=None):
t = ['clingo', '-n {}'.format(num_solutions)]
# TODO The thing below won't do much if warnings are sent to stderr which I suspect they are.
# TODO Also need to shift preprocessing burden to load_world instead
if not show_warnings:
t.append('-Wnone')
t.extend(clingo_in_fnames)
if other_args:
t.extend(other_args)
process_ = subprocess.Popen(t, stdout=subprocess.PIPE)
clingo_output = process_.communicate()[0]
# clingo_output = subprocess.check_output()
meta_data = {}
#attribute_defs = {}
#temporal_decs = {}
for fname in clingo_in_fnames:
with open(fname, 'r') as f:
clingo_rules = f.read().splitlines()
f_meta_data = parse_pwe_meta_data(clingo_rules)
for md_type, md in f_meta_data.items():
if md_type in meta_data:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import subprocess as subprocess
from .helper import (
preprocess_clingo_output,
)
from .meta_data_parser import parse_pwe_meta_data
and context:
# Path: PW_explorer/helper.py
# def preprocess_clingo_output(clingo_raw_output: list):
#
# start = 0
# for i, line in enumerate(clingo_raw_output):
# if line.strip() == 'Solving...':
# start = i + 1
# break
#
# return clingo_raw_output[start:]
#
# Path: PW_explorer/meta_data_parser.py
# def parse_pwe_meta_data(asp_rules, silent=False, print_parse_tree=False):
# if isinstance(asp_rules, str):
# asp_rules = asp_rules.splitlines()
# md_comments = preprocess(asp_rules)
# md_comments = "\n".join(md_comments)
# parsed_meta_data = parse_meta_data_from_string(md_comments, silent, print_parse_tree)
# return parsed_meta_data
which might include code, classes, or functions. Output only the next line. | meta_data[md_type].update(md) |
Predict the next line after this snippet: <|code_start|>
def get_clingo_output(clingo_in_fnames: list, num_solutions: int=0, show_warnings=False, other_args: list=None):
t = ['clingo', '-n {}'.format(num_solutions)]
# TODO The thing below won't do much if warnings are sent to stderr which I suspect they are.
# TODO Also need to shift preprocessing burden to load_world instead
if not show_warnings:
t.append('-Wnone')
t.extend(clingo_in_fnames)
if other_args:
t.extend(other_args)
process_ = subprocess.Popen(t, stdout=subprocess.PIPE)
clingo_output = process_.communicate()[0]
# clingo_output = subprocess.check_output()
meta_data = {}
#attribute_defs = {}
#temporal_decs = {}
for fname in clingo_in_fnames:
with open(fname, 'r') as f:
clingo_rules = f.read().splitlines()
f_meta_data = parse_pwe_meta_data(clingo_rules)
<|code_end|>
using the current file's imports:
import os
import subprocess as subprocess
from .helper import (
preprocess_clingo_output,
)
from .meta_data_parser import parse_pwe_meta_data
and any relevant context from other files:
# Path: PW_explorer/helper.py
# def preprocess_clingo_output(clingo_raw_output: list):
#
# start = 0
# for i, line in enumerate(clingo_raw_output):
# if line.strip() == 'Solving...':
# start = i + 1
# break
#
# return clingo_raw_output[start:]
#
# Path: PW_explorer/meta_data_parser.py
# def parse_pwe_meta_data(asp_rules, silent=False, print_parse_tree=False):
# if isinstance(asp_rules, str):
# asp_rules = asp_rules.splitlines()
# md_comments = preprocess(asp_rules)
# md_comments = "\n".join(md_comments)
# parsed_meta_data = parse_meta_data_from_string(md_comments, silent, print_parse_tree)
# return parsed_meta_data
. Output only the next line. | for md_type, md in f_meta_data.items(): |
Based on the snippet: <|code_start|> self.handlers[path] = handler
def url(self, path):
"""
Get the full URL for a specific path.
:param path: Path to be accessed.
:return: A full URL, including the port number.
"""
path = ensure_slash(path)
return 'http://127.0.0.1:%d%s' % (self.server.server_port, path)
@pytest.fixture
def http_server():
"""
A fixture wrapping the HTTP server, takes care of starting and stopping it.
:return:
"""
with contextlib.closing(HTTPServer()) as server:
server.start()
yield server
# Lisp code used to run an HTTP server.
# Note that it is a .format() string and expects a security key
# to be passed in the {key} keyword argument.
server_code = """
(use-package :net.aserve)
<|code_end|>
, predict the immediate next line with the help of imports:
import random
import uuid
import pytest
import requests
import contextlib, os, threading
import six
from collections import MutableMapping
from franz.openrdf.model import URI
from franz.openrdf.repository import Repository
from franz.openrdf.repository.attributes import AttributeDefinition
from franz.openrdf.sail import AllegroGraphServer
from .tests import AG_HOST, AG_PORT, AG_PROXY, STORE, CATALOG, USER, PASSWORD
from six.moves import BaseHTTPServer
and context (classes, functions, sometimes code) from other files:
# Path: src/franz/openrdf/tests/tests.py
# AG_HOST = os.environ.get('AGRAPH_HOST', LOCALHOST)
#
# AG_PORT = int(os.environ.get('AGRAPH_PORT', '10035'))
#
# AG_PROXY = os.environ.get('AGRAPH_PROXY')
#
# STORE = 'agraph_test'
#
# CATALOG = os.environ.get('AGRAPH_CATALOG', 'tests')
#
# USER = os.environ.get('AGRAPH_USER', 'test')
#
# PASSWORD = os.environ.get('AGRAPH_PASSWORD', 'xyzzy')
. Output only the next line. | (defun fixed-handler (body) |
Given the following code snippet before the placeholder: <|code_start|> self.key = uuid.uuid4()
self.port = 0 # Will be set later
def send_request(self, path, body=None, params=None):
"""
Execute a HTTP request *from the AG server*.
This will be a GET request, unless the `body` parameter is used,
in which case a POST request will be sent.
:param path: Document path (as given to `publish()`.
:param body: Request body - if specified this will be a POST request.
:param params: Request parameters, passed in the URI.
:return: Response body.
"""
alist = None
if params:
pairs = ' '.join('(%s . %s)' % (lisp_string(k), lisp_string(v))
for k, v in six.iteritems(params))
alist = "'(%s)" % pairs
uri = self.uri(path)
return self.conn.evalInServer('''
(prog1 (net.aserve.client:do-http-request
{uri}
:method {method}
:query {query}
:headers '((:authorization . "test {key}"))
:content-type "text/plain"
<|code_end|>
, predict the next line using imports from the current file:
import random
import uuid
import pytest
import requests
import contextlib, os, threading
import six
from collections import MutableMapping
from franz.openrdf.model import URI
from franz.openrdf.repository import Repository
from franz.openrdf.repository.attributes import AttributeDefinition
from franz.openrdf.sail import AllegroGraphServer
from .tests import AG_HOST, AG_PORT, AG_PROXY, STORE, CATALOG, USER, PASSWORD
from six.moves import BaseHTTPServer
and context including class names, function names, and sometimes code from other files:
# Path: src/franz/openrdf/tests/tests.py
# AG_HOST = os.environ.get('AGRAPH_HOST', LOCALHOST)
#
# AG_PORT = int(os.environ.get('AGRAPH_PORT', '10035'))
#
# AG_PROXY = os.environ.get('AGRAPH_PROXY')
#
# STORE = 'agraph_test'
#
# CATALOG = os.environ.get('AGRAPH_CATALOG', 'tests')
#
# USER = os.environ.get('AGRAPH_USER', 'test')
#
# PASSWORD = os.environ.get('AGRAPH_PASSWORD', 'xyzzy')
. Output only the next line. | :content {body})) |
Predict the next line for this snippet: <|code_start|># Lisp code used to run an HTTP server.
# Note that it is a .format() string and expects a security key
# to be passed in the {key} keyword argument.
server_code = """
(use-package :net.aserve)
(defun fixed-handler (body)
(lambda (req ent)
(with-http-response (req ent)
(with-http-body (req ent)
(write-string body (request-reply-stream req))))))
(defun pub (req ent)
(when (string= (header-slot-value req :authorization) "test {key}")
(with-http-response (req ent)
(with-http-body (req ent)
(let ((body (get-request-body req))
(path (request-query-value "path" req))
(type (or (request-query-value "type" req) "text/plain")))
(publish :path path
:content-type type
:function (fixed-handler body)
:server (request-wserver req)))))))
(defun stop (req ent)
(with-http-response (req ent)
(with-http-body (req ent)))
(when (string= (header-slot-value req :authorization) "test {key}")
(shutdown :server (request-wserver req))))
<|code_end|>
with the help of current file imports:
import random
import uuid
import pytest
import requests
import contextlib, os, threading
import six
from collections import MutableMapping
from franz.openrdf.model import URI
from franz.openrdf.repository import Repository
from franz.openrdf.repository.attributes import AttributeDefinition
from franz.openrdf.sail import AllegroGraphServer
from .tests import AG_HOST, AG_PORT, AG_PROXY, STORE, CATALOG, USER, PASSWORD
from six.moves import BaseHTTPServer
and context from other files:
# Path: src/franz/openrdf/tests/tests.py
# AG_HOST = os.environ.get('AGRAPH_HOST', LOCALHOST)
#
# AG_PORT = int(os.environ.get('AGRAPH_PORT', '10035'))
#
# AG_PROXY = os.environ.get('AGRAPH_PROXY')
#
# STORE = 'agraph_test'
#
# CATALOG = os.environ.get('AGRAPH_CATALOG', 'tests')
#
# USER = os.environ.get('AGRAPH_USER', 'test')
#
# PASSWORD = os.environ.get('AGRAPH_PASSWORD', 'xyzzy')
, which may contain function names, class names, or code. Output only the next line. | (let ((server (start :port 0 :host "127.0.0.1" :server :new))) |
Next line prediction: <|code_start|>
@pytest.fixture
def http_server():
"""
A fixture wrapping the HTTP server, takes care of starting and stopping it.
:return:
"""
with contextlib.closing(HTTPServer()) as server:
server.start()
yield server
# Lisp code used to run an HTTP server.
# Note that it is a .format() string and expects a security key
# to be passed in the {key} keyword argument.
server_code = """
(use-package :net.aserve)
(defun fixed-handler (body)
(lambda (req ent)
(with-http-response (req ent)
(with-http-body (req ent)
(write-string body (request-reply-stream req))))))
(defun pub (req ent)
(when (string= (header-slot-value req :authorization) "test {key}")
(with-http-response (req ent)
(with-http-body (req ent)
(let ((body (get-request-body req))
(path (request-query-value "path" req))
<|code_end|>
. Use current file imports:
(import random
import uuid
import pytest
import requests
import contextlib, os, threading
import six
from collections import MutableMapping
from franz.openrdf.model import URI
from franz.openrdf.repository import Repository
from franz.openrdf.repository.attributes import AttributeDefinition
from franz.openrdf.sail import AllegroGraphServer
from .tests import AG_HOST, AG_PORT, AG_PROXY, STORE, CATALOG, USER, PASSWORD
from six.moves import BaseHTTPServer)
and context including class names, function names, or small code snippets from other files:
# Path: src/franz/openrdf/tests/tests.py
# AG_HOST = os.environ.get('AGRAPH_HOST', LOCALHOST)
#
# AG_PORT = int(os.environ.get('AGRAPH_PORT', '10035'))
#
# AG_PROXY = os.environ.get('AGRAPH_PROXY')
#
# STORE = 'agraph_test'
#
# CATALOG = os.environ.get('AGRAPH_CATALOG', 'tests')
#
# USER = os.environ.get('AGRAPH_USER', 'test')
#
# PASSWORD = os.environ.get('AGRAPH_PASSWORD', 'xyzzy')
. Output only the next line. | (type (or (request-query-value "type" req) "text/plain"))) |
Given snippet: <|code_start|> """
with contextlib.closing(HTTPServer()) as server:
server.start()
yield server
# Lisp code used to run an HTTP server.
# Note that it is a .format() string and expects a security key
# to be passed in the {key} keyword argument.
server_code = """
(use-package :net.aserve)
(defun fixed-handler (body)
(lambda (req ent)
(with-http-response (req ent)
(with-http-body (req ent)
(write-string body (request-reply-stream req))))))
(defun pub (req ent)
(when (string= (header-slot-value req :authorization) "test {key}")
(with-http-response (req ent)
(with-http-body (req ent)
(let ((body (get-request-body req))
(path (request-query-value "path" req))
(type (or (request-query-value "type" req) "text/plain")))
(publish :path path
:content-type type
:function (fixed-handler body)
:server (request-wserver req)))))))
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import random
import uuid
import pytest
import requests
import contextlib, os, threading
import six
from collections import MutableMapping
from franz.openrdf.model import URI
from franz.openrdf.repository import Repository
from franz.openrdf.repository.attributes import AttributeDefinition
from franz.openrdf.sail import AllegroGraphServer
from .tests import AG_HOST, AG_PORT, AG_PROXY, STORE, CATALOG, USER, PASSWORD
from six.moves import BaseHTTPServer
and context:
# Path: src/franz/openrdf/tests/tests.py
# AG_HOST = os.environ.get('AGRAPH_HOST', LOCALHOST)
#
# AG_PORT = int(os.environ.get('AGRAPH_PORT', '10035'))
#
# AG_PROXY = os.environ.get('AGRAPH_PROXY')
#
# STORE = 'agraph_test'
#
# CATALOG = os.environ.get('AGRAPH_CATALOG', 'tests')
#
# USER = os.environ.get('AGRAPH_USER', 'test')
#
# PASSWORD = os.environ.get('AGRAPH_PASSWORD', 'xyzzy')
which might include code, classes, or functions. Output only the next line. | (defun stop (req ent) |
Given the code snippet: <|code_start|> A fixture wrapping the HTTP server, takes care of starting and stopping it.
:return:
"""
with contextlib.closing(HTTPServer()) as server:
server.start()
yield server
# Lisp code used to run an HTTP server.
# Note that it is a .format() string and expects a security key
# to be passed in the {key} keyword argument.
server_code = """
(use-package :net.aserve)
(defun fixed-handler (body)
(lambda (req ent)
(with-http-response (req ent)
(with-http-body (req ent)
(write-string body (request-reply-stream req))))))
(defun pub (req ent)
(when (string= (header-slot-value req :authorization) "test {key}")
(with-http-response (req ent)
(with-http-body (req ent)
(let ((body (get-request-body req))
(path (request-query-value "path" req))
(type (or (request-query-value "type" req) "text/plain")))
(publish :path path
:content-type type
:function (fixed-handler body)
<|code_end|>
, generate the next line using the imports in this file:
import random
import uuid
import pytest
import requests
import contextlib, os, threading
import six
from collections import MutableMapping
from franz.openrdf.model import URI
from franz.openrdf.repository import Repository
from franz.openrdf.repository.attributes import AttributeDefinition
from franz.openrdf.sail import AllegroGraphServer
from .tests import AG_HOST, AG_PORT, AG_PROXY, STORE, CATALOG, USER, PASSWORD
from six.moves import BaseHTTPServer
and context (functions, classes, or occasionally code) from other files:
# Path: src/franz/openrdf/tests/tests.py
# AG_HOST = os.environ.get('AGRAPH_HOST', LOCALHOST)
#
# AG_PORT = int(os.environ.get('AGRAPH_PORT', '10035'))
#
# AG_PROXY = os.environ.get('AGRAPH_PROXY')
#
# STORE = 'agraph_test'
#
# CATALOG = os.environ.get('AGRAPH_CATALOG', 'tests')
#
# USER = os.environ.get('AGRAPH_USER', 'test')
#
# PASSWORD = os.environ.get('AGRAPH_PASSWORD', 'xyzzy')
. Output only the next line. | :server (request-wserver req))))))) |
Predict the next line after this snippet: <|code_start|> :param path: Path to be accessed.
:return: A full URL, including the port number.
"""
path = ensure_slash(path)
return 'http://127.0.0.1:%d%s' % (self.server.server_port, path)
@pytest.fixture
def http_server():
"""
A fixture wrapping the HTTP server, takes care of starting and stopping it.
:return:
"""
with contextlib.closing(HTTPServer()) as server:
server.start()
yield server
# Lisp code used to run an HTTP server.
# Note that it is a .format() string and expects a security key
# to be passed in the {key} keyword argument.
server_code = """
(use-package :net.aserve)
(defun fixed-handler (body)
(lambda (req ent)
(with-http-response (req ent)
(with-http-body (req ent)
(write-string body (request-reply-stream req))))))
<|code_end|>
using the current file's imports:
import random
import uuid
import pytest
import requests
import contextlib, os, threading
import six
from collections import MutableMapping
from franz.openrdf.model import URI
from franz.openrdf.repository import Repository
from franz.openrdf.repository.attributes import AttributeDefinition
from franz.openrdf.sail import AllegroGraphServer
from .tests import AG_HOST, AG_PORT, AG_PROXY, STORE, CATALOG, USER, PASSWORD
from six.moves import BaseHTTPServer
and any relevant context from other files:
# Path: src/franz/openrdf/tests/tests.py
# AG_HOST = os.environ.get('AGRAPH_HOST', LOCALHOST)
#
# AG_PORT = int(os.environ.get('AGRAPH_PORT', '10035'))
#
# AG_PROXY = os.environ.get('AGRAPH_PROXY')
#
# STORE = 'agraph_test'
#
# CATALOG = os.environ.get('AGRAPH_CATALOG', 'tests')
#
# USER = os.environ.get('AGRAPH_USER', 'test')
#
# PASSWORD = os.environ.get('AGRAPH_PASSWORD', 'xyzzy')
. Output only the next line. | (defun pub (req ent) |
Based on the snippet: <|code_start|>#!/usr/bin/env python
# -*- coding: utf-8 -*-
# pylint: disable-msg=C0103
################################################################################
# Copyright (c) 2006-2017 Franz Inc.
# All rights reserved. This program and the accompanying materials are
# made available under the terms of the MIT License which accompanies
# this distribution, and is available at http://opensource.org/licenses/MIT
################################################################################
from __future__ import absolute_import
from __future__ import unicode_literals
class RDFWriter(object):
<|code_end|>
, predict the immediate next line with the help of imports:
from builtins import object
from .rdfformat import RDFFormat
and context (classes, functions, sometimes code) from other files:
# Path: src/franz/openrdf/rio/rdfformat.py
# class RDFFormat(Format):
# """
# Represents the concept of an RDF data serialization format. RDF formats are
# identified by a name and can have one or more associated
# MIME types, zero or more associated file extensions and can specify a
# default character encoding. Some formats are able to encode context
# information while others are not; this is indicated by the value of
# supports_contexts field. Similaraly, formats for which the
# supports_attributes flag is `True` are capable of encoding triple
# attributes.
# """
# # A global dictionary mapping extensions to formats
# # Used by Format.format_for_file_name
# _ext_map = {}
#
# def __init__(self, name, mime_types=None, charset="UTF-8",
# file_extensions=None, supports_namespaces=False,
# supports_contexts=False, supports_attributes=False,
# register=True):
# """
# Initialize a new RDF format object.
#
# :param name: Human-readable name of the format.
# :param mime_types: A list of MIME types used for this format.
# The first element of this list will be used
# as the content-type header during uploads.
# :param charset: Character set used by the format.
# :param file_extensions: List of file extensions for this format.
# :param supports_namespaces: If true, the format supports namespaces
# and qualified names. This has no impact
# on the Python API.
# :param supports_contexts: If True the format can store quads
# (and not just triples).
# :param supports_attributes: If True the format can represent triple
# attributes.
# :param register: If True file extensions will be added to the map
# used by :meth:`Format.format_for_file_name`.
# """
# Format.__init__(self, name, mime_types, charset, file_extensions, register)
# self.supports_namespaces = supports_namespaces
# self.supports_contexts = supports_contexts
# self.supports_attributes = supports_attributes
#
# # These will be automatically converted to RDFFormat instances
#
# RDFXML = dict(
# name="RDF/XML",
# mime_types=["application/rdf+xml", "application/xml"],
# file_extensions=["rdf", "rdfs", "owl", "xml"],
# supports_namespaces=True, supports_contexts=False)
#
# NTRIPLES = dict(
# name="N-Triples",
# mime_types=["application/n-triples", "text/plain"],
# file_extensions=["nt", "ntriples"],
# supports_namespaces=False, supports_contexts=False)
#
# NQUADS = dict(
# name="N-Quads",
# mime_types=["application/n-quads"],
# file_extensions=["nq", "nquads"],
# supports_namespaces=False, supports_contexts=True)
#
# NQX = dict(
# name="Extended N-Quads (with attributes)",
# mime_types=["application/x-extended-nquads"],
# file_extensions=["nqx"],
# supports_namespaces=False, supports_contexts=True,
# supports_attributes=True)
#
# TURTLE = dict(
# name="Turtle",
# mime_types=["text/turtle"],
# file_extensions=["ttl", "turtle"],
# supports_namespaces=True,
# supports_contexts=False)
#
# TRIG = dict(
# name="TriG",
# mime_types=["application/trig"],
# file_extensions=["trig"],
# supports_namespaces=True,
# supports_contexts=True)
#
# TRIX = dict(
# name="TriX",
# mime_types=["application/trix"],
# file_extensions=["trix"],
# supports_namespaces=True,
# supports_contexts=True)
#
# TABLE = dict(
# name="Table",
# mime_types=["text/table"],
# file_extensions=[],
# supports_namespaces=False,
# supports_contexts=True)
#
# JSONLD = dict(
# name="JSON-LD",
# mime_types=["application/ld+json"],
# file_extensions=["json", "jsonld"],
# supports_namespaces=True,
# supports_contexts=True)
. Output only the next line. | def __init__(self, rdfFormat, filePath=None): |
Given snippet: <|code_start|>#!/usr/bin/env python
# -*- coding: utf-8 -*-
# pylint: disable-msg=C0103
################################################################################
# Copyright (c) 2006-2017 Franz Inc.
# All rights reserved. This program and the accompanying materials are
# made available under the terms of the MIT License which accompanies
# this distribution, and is available at http://opensource.org/licenses/MIT
################################################################################
from __future__ import absolute_import
from __future__ import unicode_literals
NS = "http://www.w3.org/2002/07/owl#"
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from future.builtins import object
from past.builtins import unicode
from future.utils import iteritems
from ..model.value import URI
and context:
# Path: src/franz/openrdf/model/value.py
# class URI(Resource):
# """
# Lightweight implementation of the class 'URI'.
# """
# __slots__ = ('_uri', '_is_canonical')
#
# _instances = weakref.WeakValueDictionary()
#
# def __new__(cls, uri=None, namespace=None, localname=None, canonical=True):
# if isinstance(uri, URI):
# if not canonical or uri._is_canonical:
# return uri
# uri = uri.uri
# elif uri is None and namespace is not None:
# uri = namespace + (localname or '')
#
# if uri is None:
# raise ValueError('Either URI or namespace is required.')
#
# if canonical:
# result = URI._instances.get(uri)
# if result is not None:
# return result
#
# result = super(URI, cls).__new__(cls)
# if canonical:
# URI._instances[uri] = result
# return result
#
# def __init__(self, uri=None, namespace=None, localname=None, canonical=False):
# if isinstance(uri, URI):
# uri = uri.uri
#
# if uri is None and namespace is not None:
# uri = namespace + (localname or '')
#
# if uri and uri[0] == '<' and uri[len(uri) - 1] == '>':
# # be kind and trim the uri:
# uri = uri[1:-1]
# self._uri = uri
# self._is_canonical = canonical
#
# def get_cmp_key(self):
# return URI_CMP_KEY, self.uri
#
# def getURI(self):
# """
# Return the URI (string) for 'self'. This method is typically
# overloaded by subclasses, which may use lazy evaluation to
# retrieve the string.
# """
# return self._uri
#
# uri = property(getURI)
#
# def getValue(self):
# return self.getURI()
#
# value = property(getValue)
#
# def getLocalName(self):
# pos = uris.getLocalNameIndex(self.getURI())
# return self.uri[pos:]
#
# localname = property(getLocalName)
#
# def getNamespace(self):
# pos = uris.getLocalNameIndex(self.getURI())
# return self.uri[:pos]
#
# def split(self):
# """
# Split into a namespace + local name pair.
# """
# pos = uris.getLocalNameIndex(self.uri)
# return self.uri[:pos], self.uri[pos:]
#
# namespace = property(getNamespace)
#
# def toNTriples(self):
# """
# Return an NTriples representation of a resource, in this case, wrap
# it in angle brackets.
# """
# return strings.encode_ntriple_uri(self.uri)
#
# def to_json_ld_key(self):
# """ Converts to a string to be used as a JSON-LD key. """
# return self.uri
#
# def to_json_ld(self):
# """ Converts to an object to be used as a JSON-LD value. """
# return {"@id": self.uri}
which might include code, classes, or functions. Output only the next line. | class OWL(object): |
Continue the code snippet: <|code_start|>#!/usr/bin/env python
# -*- coding: utf-8 -*-
# pylint: disable-msg=C0103
################################################################################
# Copyright (c) 2006-2017 Franz Inc.
# All rights reserved. This program and the accompanying materials are
# made available under the terms of the MIT License which accompanies
# this distribution, and is available at http://opensource.org/licenses/MIT
################################################################################
from __future__ import absolute_import
from __future__ import unicode_literals
NS = "http://www.w3.org/2001/XMLSchema#"
<|code_end|>
. Use current file imports:
from future.builtins import object
from past.builtins import unicode
from future.utils import iteritems
from ..model.value import URI
and context (classes, functions, or code) from other files:
# Path: src/franz/openrdf/model/value.py
# class URI(Resource):
# """
# Lightweight implementation of the class 'URI'.
# """
# __slots__ = ('_uri', '_is_canonical')
#
# _instances = weakref.WeakValueDictionary()
#
# def __new__(cls, uri=None, namespace=None, localname=None, canonical=True):
# if isinstance(uri, URI):
# if not canonical or uri._is_canonical:
# return uri
# uri = uri.uri
# elif uri is None and namespace is not None:
# uri = namespace + (localname or '')
#
# if uri is None:
# raise ValueError('Either URI or namespace is required.')
#
# if canonical:
# result = URI._instances.get(uri)
# if result is not None:
# return result
#
# result = super(URI, cls).__new__(cls)
# if canonical:
# URI._instances[uri] = result
# return result
#
# def __init__(self, uri=None, namespace=None, localname=None, canonical=False):
# if isinstance(uri, URI):
# uri = uri.uri
#
# if uri is None and namespace is not None:
# uri = namespace + (localname or '')
#
# if uri and uri[0] == '<' and uri[len(uri) - 1] == '>':
# # be kind and trim the uri:
# uri = uri[1:-1]
# self._uri = uri
# self._is_canonical = canonical
#
# def get_cmp_key(self):
# return URI_CMP_KEY, self.uri
#
# def getURI(self):
# """
# Return the URI (string) for 'self'. This method is typically
# overloaded by subclasses, which may use lazy evaluation to
# retrieve the string.
# """
# return self._uri
#
# uri = property(getURI)
#
# def getValue(self):
# return self.getURI()
#
# value = property(getValue)
#
# def getLocalName(self):
# pos = uris.getLocalNameIndex(self.getURI())
# return self.uri[pos:]
#
# localname = property(getLocalName)
#
# def getNamespace(self):
# pos = uris.getLocalNameIndex(self.getURI())
# return self.uri[:pos]
#
# def split(self):
# """
# Split into a namespace + local name pair.
# """
# pos = uris.getLocalNameIndex(self.uri)
# return self.uri[:pos], self.uri[pos:]
#
# namespace = property(getNamespace)
#
# def toNTriples(self):
# """
# Return an NTriples representation of a resource, in this case, wrap
# it in angle brackets.
# """
# return strings.encode_ntriple_uri(self.uri)
#
# def to_json_ld_key(self):
# """ Converts to a string to be used as a JSON-LD key. """
# return self.uri
#
# def to_json_ld(self):
# """ Converts to an object to be used as a JSON-LD value. """
# return {"@id": self.uri}
. Output only the next line. | class XMLSchema(object): |
Using the snippet: <|code_start|>#!/usr/bin/env python
# -*- coding: utf-8 -*-
# pylint: disable-msg=C0103
################################################################################
# Copyright (c) 2006-2017 Franz Inc.
# All rights reserved. This program and the accompanying materials are
# made available under the terms of the MIT License which accompanies
# this distribution, and is available at http://opensource.org/licenses/MIT
################################################################################
from __future__ import absolute_import
from __future__ import unicode_literals
# Keys used to establish ordering between different types of terms
LITERAL_CMP_KEY = 1
URI_CMP_KEY = 2
BNODE_CMP_KEY = 3
<|code_end|>
, determine the next line of code. You have imports:
import sys
import builtins
import weakref
import six
from six import python_2_unicode_compatible
from ..util import uris, strings
and context (class names, function names, or code) available:
# Path: src/franz/openrdf/util/uris.py
# def getLocalNameIndex(uri):
# def asURIString(value):
#
# Path: src/franz/openrdf/util/strings.py
# def encode_ntriple_string(string):
# def uri_escape_match(match):
# def encode_ntriple_uri(uri):
# def ntriples_unescape(text):
# def uriref(string):
# def nodeid(string):
# def literal(string):
# def to_bytes(text):
# def to_native_string(text):
# def to_native_string(text):
# ESCAPES = [
# # Replacements will be performed sequentially, so backslash
# # must be the first character on the list
# (chr(0x5C), r'\\'),
# (chr(0x0A), r'\n'),
# (chr(0x0D), r'\r'),
# (chr(0x22), r'\"'),
# ]
. Output only the next line. | @python_2_unicode_compatible |
Based on the snippet: <|code_start|>#!/usr/bin/env python
# -*- coding: utf-8 -*-
# pylint: disable-msg=C0103
################################################################################
# Copyright (c) 2006-2017 Franz Inc.
# All rights reserved. This program and the accompanying materials are
# made available under the terms of the MIT License which accompanies
# this distribution, and is available at http://opensource.org/licenses/MIT
################################################################################
from __future__ import absolute_import
from __future__ import unicode_literals
@python_2_unicode_compatible
class QueryLanguage(object):
registered_languages = []
<|code_end|>
, predict the immediate next line with the help of imports:
from future.builtins import object
from past.builtins import basestring
from future.utils import iteritems, python_2_unicode_compatible
from franz.openrdf.rio.rdfformat import RDFFormat
from franz.openrdf.rio.tupleformat import TupleFormat
from franz.openrdf.util.contexts import output_to
from ..exceptions import IllegalOptionException, QueryMissingFeatureException
from .dataset import ALL_CONTEXTS, Dataset
from .queryresult import GraphQueryResult, TupleQueryResult
and context (classes, functions, sometimes code) from other files:
# Path: src/franz/openrdf/exceptions.py
# class IllegalOptionException(Exception):
# pass
#
# class QueryMissingFeatureException(Exception):
# """
# Source language evokes a feature not supported by the execution language
# """
#
# Path: src/franz/openrdf/query/dataset.py
# ALL_CONTEXTS = 'ALL_CONTEXTS'
#
# class Dataset(object):
# """
# Records a set of default and named graphs that can restrict
# the scope of a query.
# """
# def __init__(self, contexts=None):
# self.defaultGraphs = set([])
# self.namedGraphs = set([])
# if contexts:
# self.namedGraphs = set([cxt for cxt in contexts])
#
# def getDefaultGraphs(self):
# if not self.defaultGraphs: return ALL_CONTEXTS
# else: return [g for g in self.defaultGraphs]
#
# def addDefaultGraph(self, uri): self.defaultGraphs.add(uri)
#
# def removeDefaultGraph(self, uri): self.defaultGraphs.remove(uri)
#
# def getNamedGraphs(self):
# if not self.namedGraphs: return ALL_CONTEXTS
# else: return [g for g in self.namedGraphs]
#
# def addNamedGraph(self, uri): self.namedGraphs.add(uri)
#
# def removeNamedGraph(self, uri): self.namedGraphs.remove(uri)
#
# def clear(self):
# self.defaultGraphs = set([])
# self.namedGraphs = set([])
#
# def asQuery(self, excludeNullContext):
# if not self.defaultGraphs and not self.namedGraphs:
# if excludeNullContext: return ''
# else: return "## empty dataset ##"
# sb = []
# for uri in self.defaultGraphs:
# if uri is None and excludeNullContext: continue
# sb.append("FROM ")
# self._append_uri(sb, uri)
# sb.append(" ")
# for uri in self.namedGraphs:
# if uri is None and excludeNullContext: continue ## null context should not appear here
# sb.append("FROM NAMED ")
# self._append_uri(sb, uri)
# sb.append(" ")
# return ''.join(sb)
#
# def __str__(self):
# self.asQuery(False)
#
# def _append_uri(self, sb, uri):
# try:
# uriString = uri.uri
# except AttributeError:
# uriString = unicode(uri)
#
# if len(uriString) > 50:
# sb.append("<" + uriString[:19] + "..")
# sb.append(uriString[len(uriString) - 29:] + ">/n")
# else:
# sb.append("<")
# sb.append(uriString)
# sb.append(">")
#
# Path: src/franz/openrdf/query/queryresult.py
# class GraphQueryResult(RepositoryResult, QueryResult):
# """
# A graph query result is an iterator over the Statements.
# """
# def __init__(self, string_tuples):
# QueryResult.__init__(self)
# RepositoryResult.__init__(self, string_tuples)
#
# class TupleQueryResult(QueryResult):
# """
# A representation of a variable-binding query result as a sequence of
# BindingSet objects. Each query result consists of zero or more
# solutions, each of which represents a single query solution as a set of
# bindings. Note: take care to always close a TupleQueryResult after use to
# free any resources it keeps hold of.
# """
# def __init__(self, variable_names, string_tuples, metadata=None):
# QueryResult.__init__(self)
# if not isinstance(variable_names, list):
# variable_names = [variable_names]
# string_tuples = [string_tuples]
# self.variable_names = variable_names
# self.string_tuples = string_tuples
# self.cursor = 0
# self.tuple_count = len(string_tuples)
# self.binding_set = ListBindingSet(self.variable_names)
# self.metadata = metadata
#
# def __iter__(self):
# return self
#
# def __next__(self):
# """
# Return the next result tuple if there is one.
#
# :return: The next tuple.
# :rtype: ListBindingSet
# :raises StopIteration: If there are no more items to return.
# """
# if self.cursor >= self.tuple_count:
# raise StopIteration()
#
# bset = self.binding_set
# bset._reset(self.string_tuples[self.cursor])
# self.cursor += 1
# return bset
#
# def close(self):
# pass
#
# def getBindingNames(self):
# """
# Get the names of the bindings, in order of projection.
#
# :return: A list of names.
# :rtype: list[string]
# """
# return self.variable_names
#
# def getMetadata(self):
# """
# Get a nested dictionary containing query result metadata.
#
# :return: A dictionary
# :rtype: dict
# """
# return self.metadata
#
# def __len__(self):
# return self.tuple_count
#
# def rowCount(self):
# return len(self)
#
# def toPandas(self):
# if not has_pandas:
# raise Exception('Pandas not installed.')
# return pandas.rows_to_pandas(self, self.variable_names)
. Output only the next line. | SPARQL = None |
Predict the next line after this snippet: <|code_start|>## <li>If this fails, find the <em>last</em> occurrence of the ':'
## character.
## <li>Add <tt>1<tt> to the found index and return this value.
## </ul>
## Note that the third step should never fail as every legal (non-relative)
## URI contains at least one ':' character to seperate the scheme from the
## rest of the URI. If this fails anyway, the method will throw an
## {@link IllegalArgumentException}.
##
## @param uri
## A URI string.
## @return The index of the first local name character in the URI string. Note that
## this index does not reference an actual character if the algorithm determines
## that there is not local name. In that case, the return index is equal to the
## length of the URI string.
## @throws IllegalArgumentException
## If the supplied URI string doesn't contain any of the separator
## characters. Every legal (non-relative) URI contains at least one
## ':' character to separate the scheme from the rest of the URI.
def getLocalNameIndex(uri):
idx = uri.rfind('#')
if (idx < 0):
idx = uri.rfind('/')
if (idx < 0):
idx = uri.rfind(':')
if (idx < 0):
raise IllegalArgumentException("No separator character found in URI: " + uri)
return idx + 1
def asURIString(value):
<|code_end|>
using the current file's imports:
from past.builtins import unicode
from ..exceptions import IllegalArgumentException
and any relevant context from other files:
# Path: src/franz/openrdf/exceptions.py
# class IllegalArgumentException (Exception):
# pass
. Output only the next line. | value = unicode(value) |
Based on the snippet: <|code_start|>
@declared_attr
def __tablename__(cls):
return cls.__name__.lower()
def __repr__(self):
return '<%s>' % self.__class__.__name__
def validate(self):
pass
def save(self, validate=True):
try:
adapter.add(self)
adapter.commit()
except:
adapter.rollback()
raise
def delete(self):
try:
adapter.delete(self)
adapter.commit()
except:
adapter.rollback()
raise
@classmethod
def all(cls, order=None, commit=True):
res = adapter.session.query(cls).order_by(order).all()
<|code_end|>
, predict the immediate next line with the help of imports:
from sqlalchemy import Column, Integer, String, DateTime, Boolean, Text, func
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declared_attr
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import scoped_session, sessionmaker
from kokemomo.plugins.engine.model.km_storage.km_adapter import BaseAdapter
from kokemomo.settings.common import DATA_BASE, DATA_BASE_OPTIONS
and context (classes, functions, sometimes code) from other files:
# Path: kokemomo/plugins/engine/model/km_storage/km_adapter.py
# class BaseAdapter(object):
# __metaclass__ = ABCMeta
#
# #@abstractproperty
# #def Model(self):
# # pass
#
# @abstractmethod
# def init(self, *args, **kwargs):
# pass
#
# #@abstractmethod
# #def set(self, *args, **kwargs):
# # pass
#
# #@abstractmethod
# #def get(self, *args, **kwargs):
# # pass
#
# Path: kokemomo/settings/common.py
# DATA_BASE = 'sqlite:///data.db'
#
# DATA_BASE_OPTIONS = {}
. Output only the next line. | if commit: |
Given the following code snippet before the placeholder: <|code_start|> return '<%s>' % self.__class__.__name__
def validate(self):
pass
def save(self, validate=True):
try:
adapter.add(self)
adapter.commit()
except:
adapter.rollback()
raise
def delete(self):
try:
adapter.delete(self)
adapter.commit()
except:
adapter.rollback()
raise
@classmethod
def all(cls, order=None, commit=True):
res = adapter.session.query(cls).order_by(order).all()
if commit:
adapter.session.commit()
return res
@classmethod
def get(cls, id, commit=True):
<|code_end|>
, predict the next line using imports from the current file:
from sqlalchemy import Column, Integer, String, DateTime, Boolean, Text, func
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declared_attr
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import scoped_session, sessionmaker
from kokemomo.plugins.engine.model.km_storage.km_adapter import BaseAdapter
from kokemomo.settings.common import DATA_BASE, DATA_BASE_OPTIONS
and context including class names, function names, and sometimes code from other files:
# Path: kokemomo/plugins/engine/model/km_storage/km_adapter.py
# class BaseAdapter(object):
# __metaclass__ = ABCMeta
#
# #@abstractproperty
# #def Model(self):
# # pass
#
# @abstractmethod
# def init(self, *args, **kwargs):
# pass
#
# #@abstractmethod
# #def set(self, *args, **kwargs):
# # pass
#
# #@abstractmethod
# #def get(self, *args, **kwargs):
# # pass
#
# Path: kokemomo/settings/common.py
# DATA_BASE = 'sqlite:///data.db'
#
# DATA_BASE_OPTIONS = {}
. Output only the next line. | res = adapter.session.query(cls).filter(cls.id == id).first() |
Using the snippet: <|code_start|>#!/usr/bin/env python
# -*- coding:utf-8 -*-
class KMUserAdmin:
@classmethod
def save_user(cls, data):
id = data.get_request_parameter("id")
delete = data.get_request_parameter("delete", default=None)
if delete is None:
user = KMUser.get(id)
user.set_data(data)
user.save()
else:
KMUser.delete_by_id(id)
@classmethod
def save_group(cls, data):
id = data.get_request_parameter("id")
delete = data.get_request_parameter("delete", default=None)
if delete is None:
group = KMGroup.get(id)
group.set_data(data)
group.save()
else:
KMGroup.delete_by_id(id)
@classmethod
def save_role(cls, data):
id = data.get_request_parameter("id")
<|code_end|>
, determine the next line of code. You have imports:
from kokemomo.plugins.engine.model.km_user_table import KMUser
from kokemomo.plugins.engine.model.km_group_table import KMGroup
from kokemomo.plugins.engine.model.km_role_table import KMRole
and context (class names, function names, or code) available:
# Path: kokemomo/plugins/engine/model/km_user_table.py
# class KMUser(adapter.Model):
# __tablename__ = 'km_user'
# id = adapter.Column(adapter.Integer, autoincrement=True, primary_key=True)
# user_id = adapter.Column(adapter.String(50))
# name = adapter.Column(adapter.String(254))
# password = adapter.Column(adapter.String(254))
# mail_address = adapter.Column(adapter.String(254))
# group_id = adapter.Column(adapter.Integer)
# role_id = adapter.Column(adapter.Integer)
#
# def __init__(self, data=None):
# if data is None:
# self.user_id= ''
# self.name = ''
# self.password = ''
# self.mail_address = ''
# else:
# self.set_data(data)
#
# def __repr__(self):
# return create_repr_str(self)
#
# def get_json(self):
# return create_json(self)
#
# def set_data(self, data):
# self.error = None
# self.user_id = data.get_request_parameter('user_id', default='')
# self.name = data.get_request_parameter('name', default='')
# self.password = data.get_request_parameter('password', default='')
# self.mail_address = data.get_request_parameter('mail_address', default='')
# self.group_id = data.get_request_parameter('group_id', default=None)
# self.role_id = data.get_request_parameter('role_id', default=None)
#
# def save(self, validate=True):
# self.password = bcrypt.hashpw(self.password.encode(SETTINGS.CHARACTER_SET), bcrypt.gensalt())
# super(KMUser, self).save()
#
# @classmethod
# def get(cls, id):
# if id is None:
# user = KMUser()
# else:
# user = super(KMUser, cls).get(id=id)
# return user
#
# Path: kokemomo/plugins/engine/model/km_group_table.py
# class KMGroup(adapter.Model):
# __tablename__ = 'km_group'
# id = adapter.Column(adapter.Integer, autoincrement=True, primary_key=True)
# name = adapter.Column(adapter.String(254))
# parent_id = adapter.Column(adapter.Integer)
#
#
# def __init__(self, data=None):
# if data is None:
# self.name = ''
# self.parent_id = -1
# else:
# self.set_data(data)
#
#
# def __repr__(self):
# return create_repr_str(self)
#
#
# def get_json(self):
# return create_json(self)
#
#
# def set_data(self, data):
# self.error = None
# self.name = data.get_request_parameter('name', default='')
# self.parent_id = data.get_request_parameter('parent_id', default=-1)
#
#
# @classmethod
# def get(cls, id):
# if id is None:
# group = KMGroup()
# else:
# group = super(KMGroup, cls).get(id=id)
# return group
#
# Path: kokemomo/plugins/engine/model/km_role_table.py
# class KMRole(adapter.Model):
# __tablename__ = 'km_role'
# id = adapter.Column(adapter.Integer, autoincrement=True, primary_key=True)
# name = adapter.Column(adapter.String(254))
# target = adapter.Column(adapter.String(254))
# is_allow = adapter.Column(adapter.Boolean)
#
#
# def __init__(self, data=None):
# if data is None:
# self.name = ''
# self.target = ''
# self.is_allow = False
# else:
# self.set_data(data)
#
#
# def __repr__(self):
# return create_repr_str(self)
#
#
# def get_json(self):
# return create_json(self)
#
#
# def set_data(self, data):
# self.error = None
# self.name = data.get_request_parameter('name', default='')
# self.target = data.get_request_parameter('target', default='')
# self.is_allow = data.get_request_parameter('is_allow', default=False)
#
#
# @classmethod
# def get(cls, id):
# if id is None:
# role = KMRole()
# else:
# role = super(KMRole, cls).get(id=id)
# return role
. Output only the next line. | delete = data.get_request_parameter("delete", default=None) |
Using the snippet: <|code_start|>#!/usr/bin/env python
# -*- coding:utf-8 -*-
class KMUserAdmin:
@classmethod
def save_user(cls, data):
id = data.get_request_parameter("id")
delete = data.get_request_parameter("delete", default=None)
if delete is None:
user = KMUser.get(id)
user.set_data(data)
user.save()
else:
KMUser.delete_by_id(id)
@classmethod
<|code_end|>
, determine the next line of code. You have imports:
from kokemomo.plugins.engine.model.km_user_table import KMUser
from kokemomo.plugins.engine.model.km_group_table import KMGroup
from kokemomo.plugins.engine.model.km_role_table import KMRole
and context (class names, function names, or code) available:
# Path: kokemomo/plugins/engine/model/km_user_table.py
# class KMUser(adapter.Model):
# __tablename__ = 'km_user'
# id = adapter.Column(adapter.Integer, autoincrement=True, primary_key=True)
# user_id = adapter.Column(adapter.String(50))
# name = adapter.Column(adapter.String(254))
# password = adapter.Column(adapter.String(254))
# mail_address = adapter.Column(adapter.String(254))
# group_id = adapter.Column(adapter.Integer)
# role_id = adapter.Column(adapter.Integer)
#
# def __init__(self, data=None):
# if data is None:
# self.user_id= ''
# self.name = ''
# self.password = ''
# self.mail_address = ''
# else:
# self.set_data(data)
#
# def __repr__(self):
# return create_repr_str(self)
#
# def get_json(self):
# return create_json(self)
#
# def set_data(self, data):
# self.error = None
# self.user_id = data.get_request_parameter('user_id', default='')
# self.name = data.get_request_parameter('name', default='')
# self.password = data.get_request_parameter('password', default='')
# self.mail_address = data.get_request_parameter('mail_address', default='')
# self.group_id = data.get_request_parameter('group_id', default=None)
# self.role_id = data.get_request_parameter('role_id', default=None)
#
# def save(self, validate=True):
# self.password = bcrypt.hashpw(self.password.encode(SETTINGS.CHARACTER_SET), bcrypt.gensalt())
# super(KMUser, self).save()
#
# @classmethod
# def get(cls, id):
# if id is None:
# user = KMUser()
# else:
# user = super(KMUser, cls).get(id=id)
# return user
#
# Path: kokemomo/plugins/engine/model/km_group_table.py
# class KMGroup(adapter.Model):
# __tablename__ = 'km_group'
# id = adapter.Column(adapter.Integer, autoincrement=True, primary_key=True)
# name = adapter.Column(adapter.String(254))
# parent_id = adapter.Column(adapter.Integer)
#
#
# def __init__(self, data=None):
# if data is None:
# self.name = ''
# self.parent_id = -1
# else:
# self.set_data(data)
#
#
# def __repr__(self):
# return create_repr_str(self)
#
#
# def get_json(self):
# return create_json(self)
#
#
# def set_data(self, data):
# self.error = None
# self.name = data.get_request_parameter('name', default='')
# self.parent_id = data.get_request_parameter('parent_id', default=-1)
#
#
# @classmethod
# def get(cls, id):
# if id is None:
# group = KMGroup()
# else:
# group = super(KMGroup, cls).get(id=id)
# return group
#
# Path: kokemomo/plugins/engine/model/km_role_table.py
# class KMRole(adapter.Model):
# __tablename__ = 'km_role'
# id = adapter.Column(adapter.Integer, autoincrement=True, primary_key=True)
# name = adapter.Column(adapter.String(254))
# target = adapter.Column(adapter.String(254))
# is_allow = adapter.Column(adapter.Boolean)
#
#
# def __init__(self, data=None):
# if data is None:
# self.name = ''
# self.target = ''
# self.is_allow = False
# else:
# self.set_data(data)
#
#
# def __repr__(self):
# return create_repr_str(self)
#
#
# def get_json(self):
# return create_json(self)
#
#
# def set_data(self, data):
# self.error = None
# self.name = data.get_request_parameter('name', default='')
# self.target = data.get_request_parameter('target', default='')
# self.is_allow = data.get_request_parameter('is_allow', default=False)
#
#
# @classmethod
# def get(cls, id):
# if id is None:
# role = KMRole()
# else:
# role = super(KMRole, cls).get(id=id)
# return role
. Output only the next line. | def save_group(cls, data): |
Predict the next line for this snippet: <|code_start|>#!/usr/bin/env python
# -*- coding:utf-8 -*-
class KMUserAdmin:
@classmethod
def save_user(cls, data):
id = data.get_request_parameter("id")
delete = data.get_request_parameter("delete", default=None)
if delete is None:
user = KMUser.get(id)
user.set_data(data)
user.save()
else:
KMUser.delete_by_id(id)
@classmethod
def save_group(cls, data):
id = data.get_request_parameter("id")
delete = data.get_request_parameter("delete", default=None)
if delete is None:
group = KMGroup.get(id)
group.set_data(data)
<|code_end|>
with the help of current file imports:
from kokemomo.plugins.engine.model.km_user_table import KMUser
from kokemomo.plugins.engine.model.km_group_table import KMGroup
from kokemomo.plugins.engine.model.km_role_table import KMRole
and context from other files:
# Path: kokemomo/plugins/engine/model/km_user_table.py
# class KMUser(adapter.Model):
# __tablename__ = 'km_user'
# id = adapter.Column(adapter.Integer, autoincrement=True, primary_key=True)
# user_id = adapter.Column(adapter.String(50))
# name = adapter.Column(adapter.String(254))
# password = adapter.Column(adapter.String(254))
# mail_address = adapter.Column(adapter.String(254))
# group_id = adapter.Column(adapter.Integer)
# role_id = adapter.Column(adapter.Integer)
#
# def __init__(self, data=None):
# if data is None:
# self.user_id= ''
# self.name = ''
# self.password = ''
# self.mail_address = ''
# else:
# self.set_data(data)
#
# def __repr__(self):
# return create_repr_str(self)
#
# def get_json(self):
# return create_json(self)
#
# def set_data(self, data):
# self.error = None
# self.user_id = data.get_request_parameter('user_id', default='')
# self.name = data.get_request_parameter('name', default='')
# self.password = data.get_request_parameter('password', default='')
# self.mail_address = data.get_request_parameter('mail_address', default='')
# self.group_id = data.get_request_parameter('group_id', default=None)
# self.role_id = data.get_request_parameter('role_id', default=None)
#
# def save(self, validate=True):
# self.password = bcrypt.hashpw(self.password.encode(SETTINGS.CHARACTER_SET), bcrypt.gensalt())
# super(KMUser, self).save()
#
# @classmethod
# def get(cls, id):
# if id is None:
# user = KMUser()
# else:
# user = super(KMUser, cls).get(id=id)
# return user
#
# Path: kokemomo/plugins/engine/model/km_group_table.py
# class KMGroup(adapter.Model):
# __tablename__ = 'km_group'
# id = adapter.Column(adapter.Integer, autoincrement=True, primary_key=True)
# name = adapter.Column(adapter.String(254))
# parent_id = adapter.Column(adapter.Integer)
#
#
# def __init__(self, data=None):
# if data is None:
# self.name = ''
# self.parent_id = -1
# else:
# self.set_data(data)
#
#
# def __repr__(self):
# return create_repr_str(self)
#
#
# def get_json(self):
# return create_json(self)
#
#
# def set_data(self, data):
# self.error = None
# self.name = data.get_request_parameter('name', default='')
# self.parent_id = data.get_request_parameter('parent_id', default=-1)
#
#
# @classmethod
# def get(cls, id):
# if id is None:
# group = KMGroup()
# else:
# group = super(KMGroup, cls).get(id=id)
# return group
#
# Path: kokemomo/plugins/engine/model/km_role_table.py
# class KMRole(adapter.Model):
# __tablename__ = 'km_role'
# id = adapter.Column(adapter.Integer, autoincrement=True, primary_key=True)
# name = adapter.Column(adapter.String(254))
# target = adapter.Column(adapter.String(254))
# is_allow = adapter.Column(adapter.Boolean)
#
#
# def __init__(self, data=None):
# if data is None:
# self.name = ''
# self.target = ''
# self.is_allow = False
# else:
# self.set_data(data)
#
#
# def __repr__(self):
# return create_repr_str(self)
#
#
# def get_json(self):
# return create_json(self)
#
#
# def set_data(self, data):
# self.error = None
# self.name = data.get_request_parameter('name', default='')
# self.target = data.get_request_parameter('target', default='')
# self.is_allow = data.get_request_parameter('is_allow', default=False)
#
#
# @classmethod
# def get(cls, id):
# if id is None:
# role = KMRole()
# else:
# role = super(KMRole, cls).get(id=id)
# return role
, which may contain function names, class names, or code. Output only the next line. | group.save() |
Predict the next line for this snippet: <|code_start|>#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'hiroki'
class KMEngine(KMBaseController):
def get_name(self):
return 'engine'
def get_route_list(self):
list = (
{'rule': '/engine-js/<filename>', 'method': 'GET', 'target': self.engine_js_static, 'name': 'engine_static_js'},
{'rule': '/engine-css/<filename>', 'method': 'GET', 'target': self.engine_css_static, 'name': 'engine_static_css'},
{'rule': '/engine-img/<filename>', 'method': 'GET', 'target': self.engine_img_static, 'name': 'engine_static_img'},
<|code_end|>
with the help of current file imports:
import os
from .km_backend.km_plugin_manager import KMBaseController
from .km_exception import log
and context from other files:
# Path: kokemomo/plugins/engine/controller/km_backend/km_plugin_manager.py
# class KMBaseController(object):
# __metaclass__ = ABCMeta
#
# def __init__(self):
# self.name = self.get_name()
# self.logger = KMLogger(self.get_name())
# self.data = KMData(self)
# self.result = {}
# self.plugin = KMPluginManager.get_instance().create_base_plugin(self.name)
# for route in self.get_route_list():
# if 'name' in route:
# self.add_route(route['rule'], route['method'], route['target'], route['name'])
# else:
# self.add_route(route['rule'], route['method'], route['target'])
#
# @staticmethod
# def action(template=None):
# '''
#
# :param template:
# :return:
# '''
# def _action(callback):
# @wraps(callback)
# def wrapper(*args, **kwargs):
# res = callback(*args, **kwargs)
# if template is None:
# return res
# else:
# # args[0]はself
# args[0].result['url'] = args[0].get_url # Method for calling from template.
# args[0].result['user_id'] = args[0].data.get_user_id()
# return args[0].render(template, result=args[0].result)
# return wrapper
# return _action
#
# def check_login():
# """
# """
# def _check_login(callback):
# @wraps(callback)
# def wrapper(*args, **kwargs):
# user_id = KMLogin.get_session(args[0].data.get_request())
# if user_id is not None:
# return callback(*args, **kwargs)
# return args[0].redirect('/engine/auth_error')
# return wrapper
# return _check_login
#
#
# @abstractmethod
# def get_name(self):
# pass
#
# @abstractmethod
# def get_route_list(self):
# pass
#
# def get_url(self, routename, filename):
# return urljoin('/' + self.name + '/',
# self.plugin.app.get_url(routename, filename=filename))
#
# def add_route(self, rule, method, target, name=None):
# self.plugin.add_route(
# {'rule': rule, 'method': method, 'target': target, 'name': name}
# )
#
# def render(self, template_path, **params):
# return self.plugin.render(template_path, params)
#
# def load_static_file(self, filename, root):
# # TODO 他のプラグインからの読み込みに対応する必要がある
# return self.plugin.load_static_file(filename, root)
#
# def redirect(self, url, code=None):
# self.plugin.redirect(url, code)
#
# Path: kokemomo/plugins/engine/controller/km_exception.py
# def log(callback):
# def wrapper(*args, **kwargs):
# try:
# return callback(*args, **kwargs)
# except KMException as kme:
# error("An error has occurred in the kokemomo.")
# error(format_exc())
# error(kme.msg)
# raise kme
# except BaseException as e:
# error("An error has occurred in the application.")
# error(format_exc())
# raise e
# return wrapper
, which may contain function names, class names, or code. Output only the next line. | {'rule': '/error', 'method': 'GET', 'target': self.engine_error}, |
Given snippet: <|code_start|>#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'hiroki'
class KMEngine(KMBaseController):
def get_name(self):
return 'engine'
def get_route_list(self):
list = (
{'rule': '/engine-js/<filename>', 'method': 'GET', 'target': self.engine_js_static, 'name': 'engine_static_js'},
{'rule': '/engine-css/<filename>', 'method': 'GET', 'target': self.engine_css_static, 'name': 'engine_static_css'},
{'rule': '/engine-img/<filename>', 'method': 'GET', 'target': self.engine_img_static, 'name': 'engine_static_img'},
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
from .km_backend.km_plugin_manager import KMBaseController
from .km_exception import log
and context:
# Path: kokemomo/plugins/engine/controller/km_backend/km_plugin_manager.py
# class KMBaseController(object):
# __metaclass__ = ABCMeta
#
# def __init__(self):
# self.name = self.get_name()
# self.logger = KMLogger(self.get_name())
# self.data = KMData(self)
# self.result = {}
# self.plugin = KMPluginManager.get_instance().create_base_plugin(self.name)
# for route in self.get_route_list():
# if 'name' in route:
# self.add_route(route['rule'], route['method'], route['target'], route['name'])
# else:
# self.add_route(route['rule'], route['method'], route['target'])
#
# @staticmethod
# def action(template=None):
# '''
#
# :param template:
# :return:
# '''
# def _action(callback):
# @wraps(callback)
# def wrapper(*args, **kwargs):
# res = callback(*args, **kwargs)
# if template is None:
# return res
# else:
# # args[0]はself
# args[0].result['url'] = args[0].get_url # Method for calling from template.
# args[0].result['user_id'] = args[0].data.get_user_id()
# return args[0].render(template, result=args[0].result)
# return wrapper
# return _action
#
# def check_login():
# """
# """
# def _check_login(callback):
# @wraps(callback)
# def wrapper(*args, **kwargs):
# user_id = KMLogin.get_session(args[0].data.get_request())
# if user_id is not None:
# return callback(*args, **kwargs)
# return args[0].redirect('/engine/auth_error')
# return wrapper
# return _check_login
#
#
# @abstractmethod
# def get_name(self):
# pass
#
# @abstractmethod
# def get_route_list(self):
# pass
#
# def get_url(self, routename, filename):
# return urljoin('/' + self.name + '/',
# self.plugin.app.get_url(routename, filename=filename))
#
# def add_route(self, rule, method, target, name=None):
# self.plugin.add_route(
# {'rule': rule, 'method': method, 'target': target, 'name': name}
# )
#
# def render(self, template_path, **params):
# return self.plugin.render(template_path, params)
#
# def load_static_file(self, filename, root):
# # TODO 他のプラグインからの読み込みに対応する必要がある
# return self.plugin.load_static_file(filename, root)
#
# def redirect(self, url, code=None):
# self.plugin.redirect(url, code)
#
# Path: kokemomo/plugins/engine/controller/km_exception.py
# def log(callback):
# def wrapper(*args, **kwargs):
# try:
# return callback(*args, **kwargs)
# except KMException as kme:
# error("An error has occurred in the kokemomo.")
# error(format_exc())
# error(kme.msg)
# raise kme
# except BaseException as e:
# error("An error has occurred in the application.")
# error(format_exc())
# raise e
# return wrapper
which might include code, classes, or functions. Output only the next line. | {'rule': '/error', 'method': 'GET', 'target': self.engine_error}, |
Given the code snippet: <|code_start|>
class Roles(Base):
endpoint = "/roles"
def get_role_by_id(self, role_id):
return self.client.get(self.endpoint + "/" + role_id)
def get_role_by_name(self, role_name):
return self.client.get(self.endpoint + "/name/" + role_name)
<|code_end|>
, generate the next line using the imports in this file:
from .base import Base
and context (functions, classes, or occasionally code) from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | def patch_role(self, role_id, options=None): |
Based on the snippet: <|code_start|>
class LDAP(Base):
endpoint = "/ldap"
def sync_ldap(self):
return self.client.post(self.endpoint + "/sync")
<|code_end|>
, predict the immediate next line with the help of imports:
from .base import Base
and context (classes, functions, sometimes code) from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | def test_ldap_config(self): |
Predict the next line for this snippet: <|code_start|>
class Webhooks(Base):
endpoint = "/hooks"
def create_incoming_hook(self, options):
return self.client.post(self.endpoint + "/incoming", options=options)
def list_incoming_hooks(self, params):
return self.client.get(self.endpoint + "/incoming", params=params)
def get_incoming_hook(self, hook_id):
<|code_end|>
with the help of current file imports:
from .base import Base
and context from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
, which may contain function names, class names, or code. Output only the next line. | return self.client.get(self.endpoint + "/incoming/" + hook_id) |
Using the snippet: <|code_start|>
def update_user_mfa(self, user_id, options=None):
return self.client.put(self.endpoint + "/" + user_id + "/mfa", options)
def generate_mfa(self, user_id):
return self.client.post(self.endpoint + "/" + user_id + "/mfa/generate")
def check_mfa(self, options=None):
return self.client.post(self.endpoint + "/mfa", options)
def update_user_password(self, user_id, options=None):
return self.client.put(self.endpoint + "/" + user_id + "/password", options)
def send_password_reset_mail(self, options=None):
return self.client.post(self.endpoint + "/password/reset/send", options)
def get_user_by_email(self, email):
return self.client.get(self.endpoint + "/email/" + email)
def get_user_sessions(self, user_id):
return self.client.get(self.endpoint + "/" + user_id + "/sessions")
def revoke_user_session(self, user_id, options=None):
return self.client.post(self.endpoint + "/" + user_id + "/sessions/revoke", options)
def revoke_all_user_sessions(self, user_id):
return self.client.post(
self.endpoint + "/" + user_id + "/sessions/revoke/all",
)
<|code_end|>
, determine the next line of code. You have imports:
from .base import Base
and context (class names, function names, or code) available:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | def attach_mobile_device(self, options=None): |
Based on the snippet: <|code_start|>
class Bots(Base):
endpoint = "/bots"
def create_bot(self, options):
return self.client.post(self.endpoint, options=options)
def get_bots(self, params=None):
return self.client.get(self.endpoint, params=params)
def patch_bot(self, bot_id, options):
return self.client.put(self.endpoint + "/" + bot_id, options=options)
def get_bot(self, bot_id, params=None):
return self.client.get(self.endpoint + "/" + bot_id, params=params)
def disable_bot(self, bot_id):
return self.client.post(self.endpoint + "/" + bot_id + "/disable")
def enable_bot(self, bot_id):
return self.client.post(self.endpoint + "/" + bot_id + "/enable")
def assign_bot_to_user(self, bot_id, user_id):
return self.client.post(self.endpoint + "/" + bot_id + "/assign/" + user_id)
def get_bot_lhs_icon(self, bot_id):
return self.client.get(self.endpoint + "/" + bot_id + "/icon")
def set_bot_lhs_icon(self, bot_id, files):
<|code_end|>
, predict the immediate next line with the help of imports:
from .base import Base
and context (classes, functions, sometimes code) from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | return self.client.post(self.endpoint + "/" + bot_id + "/icon", files=files) |
Given snippet: <|code_start|>
class Scheme(Base):
endpoint = "/schemes"
def get_schemes(self, params=None):
return self.client.get(self.endpoint, params=params)
def create_scheme(self, options=None):
return self.client.post(self.endpoint, options=options)
def get_scheme(self, scheme_id):
return self.client.get(self.endpoint + "/" + scheme_id)
def delete_scheme(self, scheme_id):
return self.client.delete(self.endpoint + "/" + scheme_id)
def patch_scheme(self, scheme_id, options=None):
return self.client.put(self.endpoint + "/" + scheme_id + "/patch", options=options)
def get_page_of_teams_using_scheme(self, scheme_id, params=None):
return self.client.get(self.endpoint + "/" + scheme_id + "/teams", params=params)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import Base
and context:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
which might include code, classes, or functions. Output only the next line. | def get_page_of_channels_using_scheme(self, scheme_id, params=None): |
Given snippet: <|code_start|>
class Compliance(Base):
endpoint = "/compliance"
def create_report(self, params):
return self.client.post(self.endpoint + "/reports", params=params)
def get_reports(self, params=None):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .base import Base
and context:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
which might include code, classes, or functions. Output only the next line. | return self.client.get(self.endpoint + "/reports", params=params) |
Predict the next line for this snippet: <|code_start|>
class DataRetention(Base):
endpoint = "/data_retention"
def get_data_retention_policy(self):
<|code_end|>
with the help of current file imports:
from .base import Base
and context from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
, which may contain function names, class names, or code. Output only the next line. | return self.client.get(self.endpoint + "/policy") |
Continue the code snippet: <|code_start|>
class IntegrationActions(Base):
endpoint = "/actions"
def open_dialog(self, options):
return self.client.post(self.endpoint + "/dialogs/open", options=options)
def submit_dialog(self, options):
<|code_end|>
. Use current file imports:
from .base import Base
and context (classes, functions, or code) from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | return self.client.post(self.endpoint + "/dialogs/submit", options=options) |
Predict the next line for this snippet: <|code_start|>
class Files(Base):
endpoint = "/files"
def upload_file(self, channel_id, files):
return self.client.post(self.endpoint, data={"channel_id": channel_id}, files=files)
def get_file(self, file_id):
return self.client.get(
self.endpoint + "/" + file_id,
)
<|code_end|>
with the help of current file imports:
from .base import Base
and context from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
, which may contain function names, class names, or code. Output only the next line. | def get_file_thumbnail(self, file_id): |
Given the code snippet: <|code_start|>
class Emoji(Base):
endpoint = "/emoji"
def create_custom_emoji(self, emoji_name, files):
emoji = {"name": emoji_name, "creator_id": self.client.userid}
return self.client.post(self.endpoint, data={"emoji": json.dumps(emoji)}, files=files)
def get_emoji_list(self, params=None):
return self.client.get(self.endpoint, params=params)
def get_custom_emoji(self, emoji_id):
return self.client.get(self.endpoint + "/" + emoji_id)
def delete_custom_emoji(self, emoji_id):
return self.client.delete(self.endpoint + "/" + emoji_id)
def get_custom_emoji_by_name(self, name):
return self.client.get(self.endpoint + "/name/" + name)
def get_custom_emoji_image(self, emoji_id):
return self.client.get(self.endpoint + "/" + emoji_id + "/image")
def search_custom_emoji(self, options=None):
return self.client.post(self.endpoint + "/search", options=options)
def autocomplete_custom_emoji(self, params=None):
<|code_end|>
, generate the next line using the imports in this file:
import json
from .base import Base
and context (functions, classes, or occasionally code) from other files:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | return self.client.get(self.endpoint + "/autocomplete", params=params) |
Using the snippet: <|code_start|>
class Status(Base):
def get_user_status(self, user_id):
return self.client.get("/users/" + user_id + "/status")
def update_user_status(self, user_id, options=None):
return self.client.put("/users/" + user_id + "/status", options=options)
<|code_end|>
, determine the next line of code. You have imports:
from .base import Base
and context (class names, function names, or code) available:
# Path: src/mattermostdriver/endpoints/base.py
# class Base:
# def __init__(self, client):
# self.client = client
. Output only the next line. | def get_user_statuses_by_id(self, options=None): |
Based on the snippet: <|code_start|>
class DriftDetectOptions(namedtuple('DriftDetectOptions',
['no_wait', ])):
pass
waiter_model = botocore.waiter.WaiterModel({
"version": 2,
"waiters": {
"DriftDetectionComplete": {
"delay": 15,
"operation": "DescribeStackDriftDetectionStatus",
"maxAttempts": 20,
<|code_end|>
, predict the immediate next line with the help of imports:
from collections import namedtuple
from .command import Command
import botocore.waiter
and context (classes, functions, sometimes code) from other files:
# Path: awscfncli2/runner/commands/command.py
# class Command(object):
# SKIP_UPDATE_REFERENCES = False
#
# def __init__(self, pretty_printer, options):
# assert isinstance(pretty_printer, StackPrettyPrinter)
# self.ppt = pretty_printer
# self.options = options
#
# def run(self, stack_context):
# raise NotImplementedError
. Output only the next line. | "acceptors": [ |
Using the snippet: <|code_start|>
def package_template(ppt, session, template_path, bucket_region,
bucket_name=None, prefix=None, kms_key_id=None):
# validate template path
if not os.path.isfile(template_path):
raise ConfigError('Invalid Template Path "%s"' % template_path)
# if bucket name is not provided, create a default bucket with name
# awscfncli-{AWS::AccountId}-{AWS::Region}
if bucket_name is None:
sts = session.client('sts')
account_id = sts.get_caller_identity()["Account"]
bucket_name = 'awscfncli-%s-%s' % (account_id, bucket_region)
ppt.secho('Using default artifact bucket s3://{}'.format(bucket_name))
else:
ppt.secho('Using specified artifact bucket s3://{}'.format(bucket_name))
s3_client = session.client('s3')
# create bucket if not exists
try:
s3_client.head_bucket(Bucket=bucket_name)
except ClientError as e:
if e.response['Error']['Code'] == '404':
if bucket_region != 'us-east-1':
s3_client.create_bucket(
Bucket=bucket_name,
CreateBucketConfiguration={
'LocationConstraint': bucket_region
}
<|code_end|>
, determine the next line of code. You have imports:
import logging
import os
import tempfile
from awscli.customizations.cloudformation import exceptions
from awscli.customizations.cloudformation.artifact_exporter import Template, \
Resource, make_abs_path
from awscli.customizations.s3uploader import S3Uploader
from awscli.customizations.cloudformation.yamlhelper import yaml_dump
from botocore.exceptions import ClientError
from awscli.customizations.cloudformation.artifact_exporter import \
RESOURCES_EXPORT_LIST as EXPORTS
from awscli.customizations.cloudformation.artifact_exporter import \
EXPORT_LIST as EXPORTS
from awscli.customizations.cloudformation.artifact_exporter import \
EXPORT_DICT as EXPORTS
from ...config import ConfigError
and context (class names, function names, or code) available:
# Path: awscfncli2/config/config.py
# class ConfigError(Exception):
# pass
. Output only the next line. | ) |
Given the following code snippet before the placeholder: <|code_start|># -*- encoding: utf-8 -*-
@click.command()
@click.option('--quiet', '-q', is_flag=True, default=False,
help='Suppress warning if more than one stack is being deleted.')
@click.option('--no-wait', '-w', is_flag=True, default=False,
help='Exit immediately after delete is started.')
@click.option('--ignore-missing', '-i', is_flag=True, default=False,
<|code_end|>
, predict the next line using imports from the current file:
import click
from awscfncli2.cli.context import Context
from awscfncli2.cli.utils.deco import command_exception_handler
from awscfncli2.runner.commands.stack_delete_command import StackDeleteOptions, \
StackDeleteCommand
and context including class names, function names, and sometimes code from other files:
# Path: awscfncli2/cli/context.py
# class Context:
# """Click context object
#
#
# # Manage config parsing, transforming deployment process.
# """
#
# def __init__(self,
# config_filename: str,
# artifact_store: str,
# pretty_printer: StackPrettyPrinter,
# stack_selector: StackSelector,
# boto3_profile: Boto3Profile,
# builder,
# ):
# # simple
# self._config_filename: str = config_filename
# self._artifact_store: str = artifact_store
# # complex
# self._pretty_printer: StackPrettyPrinter = pretty_printer
# self._stack_selector = stack_selector
# self._boto3_profile = boto3_profile
# # lazy-loaded
# self._deployments = None
# self._command_runner = None
#
# # internals
# self.__builder = builder
# self.__lock = threading.RLock()
#
# @property
# def config_filename(self):
# """Config file name"""
# return self._config_filename
#
# @property
# def stack_selector(self):
# """Stack selector"""
# return self._stack_selector
#
# @property
# def boto3_profile(self):
# """Boto3 session profiles"""
# return self._boto3_profile
#
# @property
# def verbosity(self):
# """Verbosity level"""
# return self._pretty_printer.verbosity
#
# @property
# def ppt(self):
# """CLI pretty printer"""
# return self._pretty_printer
#
# @property
# def deployments(self):
# """Stack deployment spec."""
# # XXX: Lazy-loading so we don't get error if user is just looking at help
# with self.__lock:
# if self._deployments is None:
# self._deployments = self.__builder.parse_config(self.config_filename)
# return self._deployments
#
# @property
# def runner(self):
# """Command runner."""
# with self.__lock:
# if self._command_runner is None:
# self._command_runner = self.__builder.build_runner(
# self.boto3_profile,
# self._artifact_store,
# self.deployments,
# self.stack_selector,
# self.ppt
# )
# return self._command_runner
#
# Path: awscfncli2/cli/utils/deco.py
# def command_exception_handler(f):
# """Capture and pretty print exceptions."""
#
# @wraps(f)
# def wrapper(ctx, *args, **kwargs):
# try:
# return f(ctx, *args, **kwargs)
# except (botocore.exceptions.ClientError,
# botocore.exceptions.BotoCoreError,
# ) as e:
# if ctx.obj.verbosity > 0:
# click.secho(traceback.format_exc(), fg='red')
# else:
# click.secho(str(e), fg='red')
# raise click.Abort
# except ConfigError as e:
# click.secho(str(e), fg='red')
# if ctx.obj.verbosity > 0:
# traceback.print_exc()
# raise click.Abort
#
# return wrapper
#
# Path: awscfncli2/runner/commands/stack_delete_command.py
# class StackDeleteOptions(namedtuple('StackDeleteOptions',
# ['no_wait',
# 'ignore_missing'])):
# pass
#
# class StackDeleteCommand(Command):
# SKIP_UPDATE_REFERENCES = True
#
# def run(self, stack_context):
# # stack contexts
# session = stack_context.session
# parameters = stack_context.parameters
# metadata = stack_context.metadata
#
# self.ppt.pprint_stack_name(stack_context.stack_key,
# parameters['StackName'],
# 'Deleting stack ')
#
# # create boto3 cfn resource
# cfn = session.resource('cloudformation')
# self.ppt.pprint_session(session)
# self.ppt.pprint_parameters(parameters)
#
# # call boto3
# stack = cfn.Stack(parameters['StackName'])
# try:
# update_termination_protection(
# session,
# parameters.pop('EnableTerminationProtection', None),
# parameters['StackName'],
# self.ppt)
# self.ppt.pprint_stack(stack)
# stack.delete()
# except Exception as ex:
# if self.options.ignore_missing and \
# is_stack_does_not_exist_exception(ex):
# self.ppt.secho(str(ex), fg='red')
# return
# else:
# raise
#
# # wait until delete complete
# if self.options.no_wait:
# self.ppt.secho('Stack is being deleted.')
# else:
# self.ppt.wait_until_delete_complete(session, stack)
# self.ppt.secho('Stack delete complete.', fg='green')
. Output only the next line. | help='Don\'t exit with error if the stack is missing.') |
Given snippet: <|code_start|># -*- encoding: utf-8 -*-
@click.command()
@click.option('--quiet', '-q', is_flag=True, default=False,
help='Suppress warning if more than one stack is being deleted.')
@click.option('--no-wait', '-w', is_flag=True, default=False,
help='Exit immediately after delete is started.')
@click.option('--ignore-missing', '-i', is_flag=True, default=False,
help='Don\'t exit with error if the stack is missing.')
@click.pass_context
@command_exception_handler
def delete(ctx, quiet, no_wait, ignore_missing):
"""Delete stacks.
By default this command will abort if the stack being deleted does not exist,
ignore this using --ignore-missing option."""
assert isinstance(ctx.obj, Context)
# prompt user if more than one stack is being deleted
if len(ctx.obj.runner.contexts) > 1:
if not quiet:
click.confirm('Do you want to delete more than one stacks? '
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import click
from awscfncli2.cli.context import Context
from awscfncli2.cli.utils.deco import command_exception_handler
from awscfncli2.runner.commands.stack_delete_command import StackDeleteOptions, \
StackDeleteCommand
and context:
# Path: awscfncli2/cli/context.py
# class Context:
# """Click context object
#
#
# # Manage config parsing, transforming deployment process.
# """
#
# def __init__(self,
# config_filename: str,
# artifact_store: str,
# pretty_printer: StackPrettyPrinter,
# stack_selector: StackSelector,
# boto3_profile: Boto3Profile,
# builder,
# ):
# # simple
# self._config_filename: str = config_filename
# self._artifact_store: str = artifact_store
# # complex
# self._pretty_printer: StackPrettyPrinter = pretty_printer
# self._stack_selector = stack_selector
# self._boto3_profile = boto3_profile
# # lazy-loaded
# self._deployments = None
# self._command_runner = None
#
# # internals
# self.__builder = builder
# self.__lock = threading.RLock()
#
# @property
# def config_filename(self):
# """Config file name"""
# return self._config_filename
#
# @property
# def stack_selector(self):
# """Stack selector"""
# return self._stack_selector
#
# @property
# def boto3_profile(self):
# """Boto3 session profiles"""
# return self._boto3_profile
#
# @property
# def verbosity(self):
# """Verbosity level"""
# return self._pretty_printer.verbosity
#
# @property
# def ppt(self):
# """CLI pretty printer"""
# return self._pretty_printer
#
# @property
# def deployments(self):
# """Stack deployment spec."""
# # XXX: Lazy-loading so we don't get error if user is just looking at help
# with self.__lock:
# if self._deployments is None:
# self._deployments = self.__builder.parse_config(self.config_filename)
# return self._deployments
#
# @property
# def runner(self):
# """Command runner."""
# with self.__lock:
# if self._command_runner is None:
# self._command_runner = self.__builder.build_runner(
# self.boto3_profile,
# self._artifact_store,
# self.deployments,
# self.stack_selector,
# self.ppt
# )
# return self._command_runner
#
# Path: awscfncli2/cli/utils/deco.py
# def command_exception_handler(f):
# """Capture and pretty print exceptions."""
#
# @wraps(f)
# def wrapper(ctx, *args, **kwargs):
# try:
# return f(ctx, *args, **kwargs)
# except (botocore.exceptions.ClientError,
# botocore.exceptions.BotoCoreError,
# ) as e:
# if ctx.obj.verbosity > 0:
# click.secho(traceback.format_exc(), fg='red')
# else:
# click.secho(str(e), fg='red')
# raise click.Abort
# except ConfigError as e:
# click.secho(str(e), fg='red')
# if ctx.obj.verbosity > 0:
# traceback.print_exc()
# raise click.Abort
#
# return wrapper
#
# Path: awscfncli2/runner/commands/stack_delete_command.py
# class StackDeleteOptions(namedtuple('StackDeleteOptions',
# ['no_wait',
# 'ignore_missing'])):
# pass
#
# class StackDeleteCommand(Command):
# SKIP_UPDATE_REFERENCES = True
#
# def run(self, stack_context):
# # stack contexts
# session = stack_context.session
# parameters = stack_context.parameters
# metadata = stack_context.metadata
#
# self.ppt.pprint_stack_name(stack_context.stack_key,
# parameters['StackName'],
# 'Deleting stack ')
#
# # create boto3 cfn resource
# cfn = session.resource('cloudformation')
# self.ppt.pprint_session(session)
# self.ppt.pprint_parameters(parameters)
#
# # call boto3
# stack = cfn.Stack(parameters['StackName'])
# try:
# update_termination_protection(
# session,
# parameters.pop('EnableTerminationProtection', None),
# parameters['StackName'],
# self.ppt)
# self.ppt.pprint_stack(stack)
# stack.delete()
# except Exception as ex:
# if self.options.ignore_missing and \
# is_stack_does_not_exist_exception(ex):
# self.ppt.secho(str(ex), fg='red')
# return
# else:
# raise
#
# # wait until delete complete
# if self.options.no_wait:
# self.ppt.secho('Stack is being deleted.')
# else:
# self.ppt.wait_until_delete_complete(session, stack)
# self.ppt.secho('Stack delete complete.', fg='green')
which might include code, classes, or functions. Output only the next line. | 'Be more specific using --stack option.', abort=True) |
Predict the next line after this snippet: <|code_start|>
@click.command()
@click.option('--quiet', '-q', is_flag=True, default=False,
help='Suppress warning if more than one stack is being deleted.')
@click.option('--no-wait', '-w', is_flag=True, default=False,
help='Exit immediately after delete is started.')
@click.option('--ignore-missing', '-i', is_flag=True, default=False,
help='Don\'t exit with error if the stack is missing.')
@click.pass_context
@command_exception_handler
def delete(ctx, quiet, no_wait, ignore_missing):
"""Delete stacks.
By default this command will abort if the stack being deleted does not exist,
ignore this using --ignore-missing option."""
assert isinstance(ctx.obj, Context)
# prompt user if more than one stack is being deleted
if len(ctx.obj.runner.contexts) > 1:
if not quiet:
click.confirm('Do you want to delete more than one stacks? '
'Be more specific using --stack option.', abort=True)
options = StackDeleteOptions(
no_wait=no_wait,
ignore_missing=ignore_missing
)
command = StackDeleteCommand(
pretty_printer=ctx.obj.ppt,
<|code_end|>
using the current file's imports:
import click
from awscfncli2.cli.context import Context
from awscfncli2.cli.utils.deco import command_exception_handler
from awscfncli2.runner.commands.stack_delete_command import StackDeleteOptions, \
StackDeleteCommand
and any relevant context from other files:
# Path: awscfncli2/cli/context.py
# class Context:
# """Click context object
#
#
# # Manage config parsing, transforming deployment process.
# """
#
# def __init__(self,
# config_filename: str,
# artifact_store: str,
# pretty_printer: StackPrettyPrinter,
# stack_selector: StackSelector,
# boto3_profile: Boto3Profile,
# builder,
# ):
# # simple
# self._config_filename: str = config_filename
# self._artifact_store: str = artifact_store
# # complex
# self._pretty_printer: StackPrettyPrinter = pretty_printer
# self._stack_selector = stack_selector
# self._boto3_profile = boto3_profile
# # lazy-loaded
# self._deployments = None
# self._command_runner = None
#
# # internals
# self.__builder = builder
# self.__lock = threading.RLock()
#
# @property
# def config_filename(self):
# """Config file name"""
# return self._config_filename
#
# @property
# def stack_selector(self):
# """Stack selector"""
# return self._stack_selector
#
# @property
# def boto3_profile(self):
# """Boto3 session profiles"""
# return self._boto3_profile
#
# @property
# def verbosity(self):
# """Verbosity level"""
# return self._pretty_printer.verbosity
#
# @property
# def ppt(self):
# """CLI pretty printer"""
# return self._pretty_printer
#
# @property
# def deployments(self):
# """Stack deployment spec."""
# # XXX: Lazy-loading so we don't get error if user is just looking at help
# with self.__lock:
# if self._deployments is None:
# self._deployments = self.__builder.parse_config(self.config_filename)
# return self._deployments
#
# @property
# def runner(self):
# """Command runner."""
# with self.__lock:
# if self._command_runner is None:
# self._command_runner = self.__builder.build_runner(
# self.boto3_profile,
# self._artifact_store,
# self.deployments,
# self.stack_selector,
# self.ppt
# )
# return self._command_runner
#
# Path: awscfncli2/cli/utils/deco.py
# def command_exception_handler(f):
# """Capture and pretty print exceptions."""
#
# @wraps(f)
# def wrapper(ctx, *args, **kwargs):
# try:
# return f(ctx, *args, **kwargs)
# except (botocore.exceptions.ClientError,
# botocore.exceptions.BotoCoreError,
# ) as e:
# if ctx.obj.verbosity > 0:
# click.secho(traceback.format_exc(), fg='red')
# else:
# click.secho(str(e), fg='red')
# raise click.Abort
# except ConfigError as e:
# click.secho(str(e), fg='red')
# if ctx.obj.verbosity > 0:
# traceback.print_exc()
# raise click.Abort
#
# return wrapper
#
# Path: awscfncli2/runner/commands/stack_delete_command.py
# class StackDeleteOptions(namedtuple('StackDeleteOptions',
# ['no_wait',
# 'ignore_missing'])):
# pass
#
# class StackDeleteCommand(Command):
# SKIP_UPDATE_REFERENCES = True
#
# def run(self, stack_context):
# # stack contexts
# session = stack_context.session
# parameters = stack_context.parameters
# metadata = stack_context.metadata
#
# self.ppt.pprint_stack_name(stack_context.stack_key,
# parameters['StackName'],
# 'Deleting stack ')
#
# # create boto3 cfn resource
# cfn = session.resource('cloudformation')
# self.ppt.pprint_session(session)
# self.ppt.pprint_parameters(parameters)
#
# # call boto3
# stack = cfn.Stack(parameters['StackName'])
# try:
# update_termination_protection(
# session,
# parameters.pop('EnableTerminationProtection', None),
# parameters['StackName'],
# self.ppt)
# self.ppt.pprint_stack(stack)
# stack.delete()
# except Exception as ex:
# if self.options.ignore_missing and \
# is_stack_does_not_exist_exception(ex):
# self.ppt.secho(str(ex), fg='red')
# return
# else:
# raise
#
# # wait until delete complete
# if self.options.no_wait:
# self.ppt.secho('Stack is being deleted.')
# else:
# self.ppt.wait_until_delete_complete(session, stack)
# self.ppt.secho('Stack delete complete.', fg='green')
. Output only the next line. | options=options |
Given the following code snippet before the placeholder: <|code_start|># -*- encoding: utf-8 -*-
@click.command()
@click.option('--quiet', '-q', is_flag=True, default=False,
help='Suppress warning if more than one stack is being deleted.')
@click.option('--no-wait', '-w', is_flag=True, default=False,
help='Exit immediately after delete is started.')
@click.option('--ignore-missing', '-i', is_flag=True, default=False,
help='Don\'t exit with error if the stack is missing.')
@click.pass_context
@command_exception_handler
<|code_end|>
, predict the next line using imports from the current file:
import click
from awscfncli2.cli.context import Context
from awscfncli2.cli.utils.deco import command_exception_handler
from awscfncli2.runner.commands.stack_delete_command import StackDeleteOptions, \
StackDeleteCommand
and context including class names, function names, and sometimes code from other files:
# Path: awscfncli2/cli/context.py
# class Context:
# """Click context object
#
#
# # Manage config parsing, transforming deployment process.
# """
#
# def __init__(self,
# config_filename: str,
# artifact_store: str,
# pretty_printer: StackPrettyPrinter,
# stack_selector: StackSelector,
# boto3_profile: Boto3Profile,
# builder,
# ):
# # simple
# self._config_filename: str = config_filename
# self._artifact_store: str = artifact_store
# # complex
# self._pretty_printer: StackPrettyPrinter = pretty_printer
# self._stack_selector = stack_selector
# self._boto3_profile = boto3_profile
# # lazy-loaded
# self._deployments = None
# self._command_runner = None
#
# # internals
# self.__builder = builder
# self.__lock = threading.RLock()
#
# @property
# def config_filename(self):
# """Config file name"""
# return self._config_filename
#
# @property
# def stack_selector(self):
# """Stack selector"""
# return self._stack_selector
#
# @property
# def boto3_profile(self):
# """Boto3 session profiles"""
# return self._boto3_profile
#
# @property
# def verbosity(self):
# """Verbosity level"""
# return self._pretty_printer.verbosity
#
# @property
# def ppt(self):
# """CLI pretty printer"""
# return self._pretty_printer
#
# @property
# def deployments(self):
# """Stack deployment spec."""
# # XXX: Lazy-loading so we don't get error if user is just looking at help
# with self.__lock:
# if self._deployments is None:
# self._deployments = self.__builder.parse_config(self.config_filename)
# return self._deployments
#
# @property
# def runner(self):
# """Command runner."""
# with self.__lock:
# if self._command_runner is None:
# self._command_runner = self.__builder.build_runner(
# self.boto3_profile,
# self._artifact_store,
# self.deployments,
# self.stack_selector,
# self.ppt
# )
# return self._command_runner
#
# Path: awscfncli2/cli/utils/deco.py
# def command_exception_handler(f):
# """Capture and pretty print exceptions."""
#
# @wraps(f)
# def wrapper(ctx, *args, **kwargs):
# try:
# return f(ctx, *args, **kwargs)
# except (botocore.exceptions.ClientError,
# botocore.exceptions.BotoCoreError,
# ) as e:
# if ctx.obj.verbosity > 0:
# click.secho(traceback.format_exc(), fg='red')
# else:
# click.secho(str(e), fg='red')
# raise click.Abort
# except ConfigError as e:
# click.secho(str(e), fg='red')
# if ctx.obj.verbosity > 0:
# traceback.print_exc()
# raise click.Abort
#
# return wrapper
#
# Path: awscfncli2/runner/commands/stack_delete_command.py
# class StackDeleteOptions(namedtuple('StackDeleteOptions',
# ['no_wait',
# 'ignore_missing'])):
# pass
#
# class StackDeleteCommand(Command):
# SKIP_UPDATE_REFERENCES = True
#
# def run(self, stack_context):
# # stack contexts
# session = stack_context.session
# parameters = stack_context.parameters
# metadata = stack_context.metadata
#
# self.ppt.pprint_stack_name(stack_context.stack_key,
# parameters['StackName'],
# 'Deleting stack ')
#
# # create boto3 cfn resource
# cfn = session.resource('cloudformation')
# self.ppt.pprint_session(session)
# self.ppt.pprint_parameters(parameters)
#
# # call boto3
# stack = cfn.Stack(parameters['StackName'])
# try:
# update_termination_protection(
# session,
# parameters.pop('EnableTerminationProtection', None),
# parameters['StackName'],
# self.ppt)
# self.ppt.pprint_stack(stack)
# stack.delete()
# except Exception as ex:
# if self.options.ignore_missing and \
# is_stack_does_not_exist_exception(ex):
# self.ppt.secho(str(ex), fg='red')
# return
# else:
# raise
#
# # wait until delete complete
# if self.options.no_wait:
# self.ppt.secho('Stack is being deleted.')
# else:
# self.ppt.wait_until_delete_complete(session, stack)
# self.ppt.secho('Stack delete complete.', fg='green')
. Output only the next line. | def delete(ctx, quiet, no_wait, ignore_missing): |
Given the code snippet: <|code_start|> for k, v in
six.iteritems(OrderedDict(
sorted(six.iteritems(Parameters)))
)
)
# Normalize tag config
Tags = parameters['Tags']
normalized_tags = None
if Tags and isinstance(Tags, dict):
normalized_tags = list(
{'Key': k, 'Value': v}
for k, v in
six.iteritems(OrderedDict(
sorted(six.iteritems(Tags)))
)
)
normalized_config = dict(
StackName=StackName,
TemplateURL=TemplateURL,
TemplateBody=TemplateBody,
DisableRollback=parameters['DisableRollback'],
RollbackConfiguration=parameters['RollbackConfiguration'],
TimeoutInMinutes=parameters['TimeoutInMinutes'],
NotificationARNs=parameters['NotificationARNs'],
Capabilities=parameters['Capabilities'],
ResourceTypes=parameters['ResourceTypes'],
RoleARN=parameters['RoleARN'],
OnFailure=parameters['OnFailure'],
<|code_end|>
, generate the next line using the imports in this file:
import os
import six
from collections import OrderedDict
from awscfncli2.config import CANNED_STACK_POLICIES, ConfigError
and context (functions, classes, or occasionally code) from other files:
# Path: awscfncli2/config/config.py
# class ConfigError(Exception):
# pass
#
# Path: awscfncli2/config/formats.py
# CANNED_STACK_POLICIES = {
# 'ALLOW_ALL': '{"Statement":[{"Effect":"Allow","Action":"Update:*","Principal":"*","Resource":"*"}]}',
# 'ALLOW_MODIFY': '{"Statement":[{"Effect":"Allow","Action":["Update:Modify"],"Principal":"*","Resource":"*"}]}',
# 'DENY_DELETE': '{"Statement":[{"Effect":"Allow","NotAction":"Update:Delete","Principal":"*","Resource":"*"}]}',
# 'DENY_ALL': '{"Statement":[{"Effect":"Deny","Action":"Update:*","Principal":"*","Resource":"*"}]}',
# }
. Output only the next line. | StackPolicyBody=StackPolicyBody, |
Continue the code snippet: <|code_start|>
def normalize_value(v):
if isinstance(v, bool):
return 'true' if v else 'false'
elif isinstance(v, int):
return str(v)
else:
return v
def make_boto3_parameters(parameters, is_packaging):
# inject parameters
<|code_end|>
. Use current file imports:
import os
import six
from collections import OrderedDict
from awscfncli2.config import CANNED_STACK_POLICIES, ConfigError
and context (classes, functions, or code) from other files:
# Path: awscfncli2/config/config.py
# class ConfigError(Exception):
# pass
#
# Path: awscfncli2/config/formats.py
# CANNED_STACK_POLICIES = {
# 'ALLOW_ALL': '{"Statement":[{"Effect":"Allow","Action":"Update:*","Principal":"*","Resource":"*"}]}',
# 'ALLOW_MODIFY': '{"Statement":[{"Effect":"Allow","Action":["Update:Modify"],"Principal":"*","Resource":"*"}]}',
# 'DENY_DELETE': '{"Statement":[{"Effect":"Allow","NotAction":"Update:Delete","Principal":"*","Resource":"*"}]}',
# 'DENY_ALL': '{"Statement":[{"Effect":"Deny","Action":"Update:*","Principal":"*","Resource":"*"}]}',
# }
. Output only the next line. | StackName = parameters['StackName'] |
Here is a snippet: <|code_start|>
class StackStatusOptions(namedtuple('StackStatusOptions',
['dry_run', 'stack_resources',
'stack_exports'])):
pass
dummy_stack = namedtuple('dummy_stack', ['stack_name', 'stack_status'])
class StackStatusCommand(Command):
SKIP_UPDATE_REFERENCES = True
def run(self, stack_context):
# stack contexts
session = stack_context.session
parameters = stack_context.parameters
metadata = stack_context.metadata
self.ppt.pprint_stack_name(stack_context.stack_key,
parameters['StackName'])
# shortcut since dry run is already handled in cli package
if self.options.dry_run:
<|code_end|>
. Write the next line using the current file imports:
from collections import namedtuple
from .command import Command
from .utils import is_stack_does_not_exist_exception
import botocore.exceptions
and context from other files:
# Path: awscfncli2/runner/commands/command.py
# class Command(object):
# SKIP_UPDATE_REFERENCES = False
#
# def __init__(self, pretty_printer, options):
# assert isinstance(pretty_printer, StackPrettyPrinter)
# self.ppt = pretty_printer
# self.options = options
#
# def run(self, stack_context):
# raise NotImplementedError
#
# Path: awscfncli2/runner/commands/utils.py
# def is_stack_does_not_exist_exception(ex):
# """Check whether given exception is "stack does not exist",
# botocore doesn't throw a distinct exception class in this case.
# """
# if isinstance(ex, botocore.exceptions.ClientError):
# error = ex.response.get('Error', {})
# error_message = error.get('Message', 'Unknown')
# return error_message.endswith('does not exist')
# else:
# return False
, which may include functions, classes, or code. Output only the next line. | return |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.