_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q276700 | ElementTool.normal_left_dclick | test | def normal_left_dclick(self, event):
""" Handles the left mouse button being double-clicked when the tool
is in the 'normal' state.
If the event occurred on this tool's component (or any contained
component of that component), the method opens a Traits UI view on the
object refe... | python | {
"resource": ""
} |
q276701 | CanvasMapping._diagram_canvas_changed | test | def _diagram_canvas_changed(self, new):
""" Handles the diagram canvas being set """
logger.debug("Diagram canvas changed!")
canvas = self.diagram_canvas
for tool in self.tools:
if canvas is not None:
print "Adding tool: %s" % tool
canvas.too... | python | {
"resource": ""
} |
q276702 | CanvasMapping.clear_canvas | test | def clear_canvas(self):
""" Removes all components from the canvas """
logger.debug("Clearing the diagram canvas!")
old_canvas = self.diagram_canvas
# logger.debug("Canvas components: %s" % canvas.components)
# for component in canvas.components:
# canvas.remove(compon... | python | {
"resource": ""
} |
q276703 | Mapping._domain_model_changed_for_diagram | test | def _domain_model_changed_for_diagram(self, obj, name, old, new):
""" Handles the domain model changing """
if old is not None:
self.unmap_model(old)
if new is not None:
self.map_model(new) | python | {
"resource": ""
} |
q276704 | Mapping.map_model | test | def map_model(self, new):
""" Maps a domain model to the diagram """
logger.debug("Mapping the domain model!")
dot = Dot()
self.diagram.clear_canvas()
for node_mapping in self.nodes:
ct = node_mapping.containment_trait
logger.debug("Mapping elements con... | python | {
"resource": ""
} |
q276705 | Mapping.unmap_model | test | def unmap_model(self, old):
""" Removes listeners from a domain model """
for node_mapping in self.nodes:
ct = node_mapping.containment_trait
if hasattr(old, ct):
old_elements = getattr(old, ct)
for old_element in old_elements:
... | python | {
"resource": ""
} |
q276706 | Mapping.map_element | test | def map_element(self, obj, name, event):
""" Handles mapping elements to diagram components """
canvas = self.diagram.diagram_canvas
parser = XDotParser()
for element in event.added:
logger.debug("Mapping new element [%s] to diagram node" % element)
for node_map... | python | {
"resource": ""
} |
q276707 | Mapping._style_node | test | def _style_node(self, pydot_node, dot_attrs):
""" Styles a node """
pydot_node.set_shape(dot_attrs.shape)
pydot_node.set_fixedsize(str(dot_attrs.fixed_size))
pydot_node.set_width(str(dot_attrs.width))
pydot_node.set_height(str(dot_attrs.height))
pydot_node.set_color(rgba... | python | {
"resource": ""
} |
q276708 | XdotAttrParser.parse_xdot_data | test | def parse_xdot_data(self, data):
""" Parses xdot data and returns the associated components. """
parser = self.parser
# if pyparsing_version >= "1.2":
# parser.parseWithTabs()
if data:
return parser.parseString(data)
else:
return [] | python | {
"resource": ""
} |
q276709 | XdotAttrParser.proc_font | test | def proc_font(self, tokens):
""" Sets the font. """
size = int(tokens["s"])
self.pen.font = "%s %d" % (tokens["b"], size)
return [] | python | {
"resource": ""
} |
q276710 | XdotAttrParser._proc_ellipse | test | def _proc_ellipse(self, tokens, filled):
""" Returns the components of an ellipse. """
component = Ellipse(pen=self.pen,
x_origin=tokens["x0"],
y_origin=tokens["y0"],
e_width=tokens["w"],
e_h... | python | {
"resource": ""
} |
q276711 | XdotAttrParser._proc_polygon | test | def _proc_polygon(self, tokens, filled):
""" Returns the components of a polygon. """
pts = [(p["x"], p["y"]) for p in tokens["points"]]
component = Polygon(pen=self.pen, points=pts, filled=filled)
return component | python | {
"resource": ""
} |
q276712 | XdotAttrParser.proc_polyline | test | def proc_polyline(self, tokens):
""" Returns the components of a polyline. """
pts = [(p["x"], p["y"]) for p in tokens["points"]]
component = Polyline(pen=self.pen, points=pts)
return component | python | {
"resource": ""
} |
q276713 | XdotAttrParser.proc_text | test | def proc_text(self, tokens):
""" Returns text components. """
component = Text(pen=self.pen,
text_x=tokens["x"],
text_y=tokens["y"],
justify=tokens["j"],
text_w=tokens["w"],
text... | python | {
"resource": ""
} |
q276714 | XdotAttrParser.proc_image | test | def proc_image(self, tokens):
""" Returns the components of an image. """
print "IMAGE:", tokens, tokens.asList(), tokens.keys()
raise NotImplementedError | python | {
"resource": ""
} |
q276715 | render_grid_file | test | def render_grid_file(context, f):
"""Allow direct use of GridOut GridFS file wrappers as endpoint responses."""
f.seek(0) # Ensure we are reading from the beginning.
response = context.response # Frequently accessed, so made local. Useless optimization on Pypy.
if __debug__: # We add some useful diagnostic ... | python | {
"resource": ""
} |
q276716 | DotFileIResourceAdapter.save | test | def save(self, obj):
""" Save to file.
"""
fd = None
try:
fd = open(self.dot_file.absolute_path, "wb")
obj.save_dot(fd)
finally:
if fd is not None:
fd.close()
# self.m_time = getmtime(self.adaptee.absolute_path)
r... | python | {
"resource": ""
} |
q276717 | DotFileIResourceAdapter.load | test | def load(self):
""" Load the file.
"""
fd = None
try:
obj = parse_dot_file( self.dot_file.absolute_path )
finally:
if fd is not None:
fd.close()
return obj | python | {
"resource": ""
} |
q276718 | Ellipse.is_in | test | def is_in(self, point_x, point_y):
""" Test if the point is within this ellipse """
x = self.x_origin
y = self.y_origin
a = self.e_width#/2 # FIXME: Why divide by two
b = self.e_height#/2
return ((point_x-x)**2/(a**2)) + ((point_y-y)**2/(b**2)) < 1.0 | python | {
"resource": ""
} |
q276719 | Ellipse._draw_bounds | test | def _draw_bounds(self, gc):
""" Draws the component bounds for testing purposes """
dx, dy = self.bounds
x, y = self.position
gc.rect(x, y, dx, dy)
gc.stroke_path() | python | {
"resource": ""
} |
q276720 | NewDotGraphAction.perform | test | def perform(self, event):
""" Perform the action.
"""
wizard = NewDotGraphWizard(parent=self.window.control,
window=self.window, title="New Graph")
# Open the wizard
if wizard.open() == OK:
wizard.finished = True | python | {
"resource": ""
} |
q276721 | SQLAlchemyConnection.start | test | def start(self, context):
"""Construct the SQLAlchemy engine and session factory."""
if __debug__:
log.info("Connecting SQLAlchemy database layer.", extra=dict(
uri = redact_uri(self.uri),
config = self.config,
alias = self.alias,
))
# Construct the engine.
engine = self.engine = cre... | python | {
"resource": ""
} |
q276722 | GraphViewModel._parse_dot_code_fired | test | def _parse_dot_code_fired(self):
""" Parses the dot_code string and replaces the existing model.
"""
parser = GodotDataParser()
graph = parser.parse_dot_data(self.dot_code)
if graph is not None:
self.model = graph | python | {
"resource": ""
} |
q276723 | GraphViewModel.new_model | test | def new_model(self, info):
""" Handles the new Graph action. """
if info.initialized:
retval = confirm(parent = info.ui.control,
message = "Replace existing graph?",
title = "New Graph",
default = YES)... | python | {
"resource": ""
} |
q276724 | GraphViewModel.open_file | test | def open_file(self, info):
""" Handles the open action. """
if not info.initialized: return # Escape.
# retval = self.edit_traits(parent=info.ui.control, view="file_view")
dlg = FileDialog( action = "open",
wildcard = "Graphviz Files (*.dot, *.xdot, *.txt)|"
... | python | {
"resource": ""
} |
q276725 | GraphViewModel.save | test | def save(self, info):
""" Handles saving the current model to the last file.
"""
save_file = self.save_file
if not isfile(save_file):
self.save_as(info)
else:
fd = None
try:
fd = open(save_file, "wb")
dot_code =... | python | {
"resource": ""
} |
q276726 | GraphViewModel.save_as | test | def save_as(self, info):
""" Handles saving the current model to file.
"""
if not info.initialized:
return
# retval = self.edit_traits(parent=info.ui.control, view="file_view")
dlg = FileDialog( action = "save as",
wildcard = "Graphviz Files (*.dot, *.xdo... | python | {
"resource": ""
} |
q276727 | GraphViewModel.configure_graph | test | def configure_graph(self, info):
""" Handles display of the graph dot traits.
"""
if info.initialized:
self.model.edit_traits(parent=info.ui.control,
kind="live", view=attr_view) | python | {
"resource": ""
} |
q276728 | GraphViewModel.configure_nodes | test | def configure_nodes(self, info):
""" Handles display of the nodes editor.
"""
if info.initialized:
self.model.edit_traits(parent=info.ui.control,
kind="live", view=nodes_view) | python | {
"resource": ""
} |
q276729 | GraphViewModel.configure_edges | test | def configure_edges(self, info):
""" Handles display of the edges editor.
"""
if info.initialized:
self.model.edit_traits(parent=info.ui.control,
kind="live", view=edges_view) | python | {
"resource": ""
} |
q276730 | GraphViewModel.about_godot | test | def about_godot(self, info):
""" Handles displaying a view about Godot.
"""
if info.initialized:
self.edit_traits(parent=info.ui.control,
kind="livemodal", view=about_view) | python | {
"resource": ""
} |
q276731 | GraphViewModel.add_node | test | def add_node(self, info):
""" Handles adding a Node to the graph.
"""
if not info.initialized:
return
graph = self._request_graph(info.ui.control)
if graph is None:
return
IDs = [v.ID for v in graph.nodes]
node = Node(ID=make_unique_name... | python | {
"resource": ""
} |
q276732 | GraphViewModel.add_edge | test | def add_edge(self, info):
""" Handles adding an Edge to the graph.
"""
if not info.initialized:
return
graph = self._request_graph(info.ui.control)
if graph is None:
return
n_nodes = len(graph.nodes)
IDs = [v.ID for v in graph.nodes]
... | python | {
"resource": ""
} |
q276733 | GraphViewModel.add_subgraph | test | def add_subgraph(self, info):
""" Handles adding a Subgraph to the main graph.
"""
if not info.initialized:
return
graph = self._request_graph(info.ui.control)
if graph is not None:
subgraph = Subgraph()#root=graph, parent=graph)
retval = sub... | python | {
"resource": ""
} |
q276734 | GraphViewModel.add_cluster | test | def add_cluster(self, info):
""" Handles adding a Cluster to the main graph. """
if not info.initialized:
return
graph = self._request_graph(info.ui.control)
if graph is not None:
cluster = Cluster()#root=graph, parent=graph)
retval = cluster.edit_t... | python | {
"resource": ""
} |
q276735 | GraphViewModel._request_graph | test | def _request_graph(self, parent=None):
""" Displays a dialog for graph selection if more than one exists.
Returns None if the dialog is canceled.
"""
if (len(self.all_graphs) > 1) and (self.select_graph):
retval = self.edit_traits(parent = parent,
... | python | {
"resource": ""
} |
q276736 | GraphViewModel.godot_options | test | def godot_options(self, info):
""" Handles display of the options menu. """
if info.initialized:
self.edit_traits( parent = info.ui.control,
kind = "livemodal",
view = "options_view" ) | python | {
"resource": ""
} |
q276737 | GraphViewModel.configure_dot_code | test | def configure_dot_code(self, info):
""" Handles display of the dot code in a text editor.
"""
if not info.initialized:
return
self.dot_code = str(self.model)
retval = self.edit_traits( parent = info.ui.control,
kind = "livemodal",... | python | {
"resource": ""
} |
q276738 | GraphViewModel.on_exit | test | def on_exit(self, info):
""" Handles the user attempting to exit Godot.
"""
if self.prompt_on_exit:# and (not is_ok):
retval = confirm(parent = info.ui.control,
message = "Exit Godot?",
title = "Confirm exit",
... | python | {
"resource": ""
} |
q276739 | move_to_origin | test | def move_to_origin(components):
""" Components are positioned relative to their container. Use this
method to position the bottom-left corner of the components at
the origin.
"""
for component in components:
if isinstance(component, Ellipse):
component.x_origin = componen... | python | {
"resource": ""
} |
q276740 | Serializable.save_to_file_like | test | def save_to_file_like(self, flo, format=None, **kwargs):
""" Save the object to a given file like object in the given format.
"""
format = self.format if format is None else format
save = getattr(self, "save_%s" % format, None)
if save is None:
raise ValueError("Unkno... | python | {
"resource": ""
} |
q276741 | Serializable.load_from_file_like | test | def load_from_file_like(cls, flo, format=None):
""" Load the object to a given file like object with the given
protocol.
"""
format = self.format if format is None else format
load = getattr(cls, "load_%s" % format, None)
if load is None:
raise ValueError(... | python | {
"resource": ""
} |
q276742 | Serializable.save_to_file | test | def save_to_file(self, filename, format=None, **kwargs):
""" Save the object to file given by filename.
"""
if format is None:
# try to derive protocol from file extension
format = format_from_extension(filename)
with file(filename, 'wb') as fp:
self.s... | python | {
"resource": ""
} |
q276743 | Serializable.load_from_file | test | def load_from_file(cls, filename, format=None):
""" Return an instance of the class that is saved in the file with the
given filename in the specified format.
"""
if format is None:
# try to derive protocol from file extension
format = format_from_extension(fi... | python | {
"resource": ""
} |
q276744 | Alias | test | def Alias(name, **metadata):
""" Syntactically concise alias trait but creates a pair of lambda
functions for every alias you declare.
class MyClass(HasTraits):
line_width = Float(3.0)
thickness = Alias("line_width")
"""
return Property(lambda obj: getattr(obj, name),
... | python | {
"resource": ""
} |
q276745 | parse | test | def parse(filename, encoding=None):
"""
!DEMO!
Simple file parsing generator
Args:
filename: absolute or relative path to file on disk
encoding: encoding string that is passed to open function
"""
with open(filename, encoding=encoding) as source:
for line in source:
... | python | {
"resource": ""
} |
q276746 | MarkovChain.startwords | test | def startwords(self):
"""
!DEMO!
Cached list of keys that can be used to generate sentence.
"""
if self._start_words is not None:
return self._start_words
else:
self._start_words = list(filter(
lambda x: str.isupper(x[0][0]) and x[... | python | {
"resource": ""
} |
q276747 | MarkovGenerator.add_chain | test | def add_chain(self, name, order):
"""
Add chain to current shelve file
Args:
name: chain name
order: markov chain order
"""
if name not in self.chains:
setattr(self.chains, name, MarkovChain(order=order))
else:
raise Value... | python | {
"resource": ""
} |
q276748 | MarkovGenerator.remove_chain | test | def remove_chain(self, name):
"""
Remove chain from current shelve file
Args:
name: chain name
"""
if name in self.chains:
delattr(self.chains, name)
else:
raise ValueError("Chain with this name not found") | python | {
"resource": ""
} |
q276749 | MarkovGenerator.build_chain | test | def build_chain(self, source, chain):
"""
Build markov chain from source on top of existin chain
Args:
source: iterable which will be used to build chain
chain: MarkovChain in currently loaded shelve file that
will be extended by source
"""
... | python | {
"resource": ""
} |
q276750 | MarkovGenerator.generate_sentence | test | def generate_sentence(self, chain):
"""
!DEMO!
Demo function that shows how to generate a simple sentence starting with
uppercase letter without lenght limit.
Args:
chain: MarkovChain that will be used to generate sentence
"""
def weighted_choice(cho... | python | {
"resource": ""
} |
q276751 | BaseGraph.create | test | def create(self, prog=None, format=None):
""" Creates and returns a representation of the graph using the
Graphviz layout program given by 'prog', according to the given
format.
Writes the graph to a temporary dot file and processes it with
the program given by '... | python | {
"resource": ""
} |
q276752 | BaseGraph.add_node | test | def add_node(self, node_or_ID, **kwds):
""" Adds a node to the graph.
"""
if not isinstance(node_or_ID, Node):
nodeID = str( node_or_ID )
if nodeID in self.nodes:
node = self.nodes[ self.nodes.index(nodeID) ]
else:
if self.defau... | python | {
"resource": ""
} |
q276753 | BaseGraph.delete_node | test | def delete_node(self, node_or_ID):
""" Removes a node from the graph.
"""
if isinstance(node_or_ID, Node):
# name = node_or_ID.ID
node = node_or_ID
else:
# name = node_or_ID
node = self.get_node(node_or_ID)
if node is None:
... | python | {
"resource": ""
} |
q276754 | BaseGraph.get_node | test | def get_node(self, ID):
""" Returns the node with the given ID or None.
"""
for node in self.nodes:
if node.ID == str(ID):
return node
return None | python | {
"resource": ""
} |
q276755 | BaseGraph.delete_edge | test | def delete_edge(self, tail_node_or_ID, head_node_or_ID):
""" Removes an edge from the graph. Returns the deleted edge or None.
"""
if isinstance(tail_node_or_ID, Node):
tail_node = tail_node_or_ID
else:
tail_node = self.get_node(tail_node_or_ID)
if isinst... | python | {
"resource": ""
} |
q276756 | BaseGraph.add_edge | test | def add_edge(self, tail_node_or_ID, head_node_or_ID, **kwds):
""" Adds an edge to the graph.
"""
tail_node = self.add_node(tail_node_or_ID)
head_node = self.add_node(head_node_or_ID)
# Only top level graphs are directed and/or strict.
if "directed" in self.trait_names():... | python | {
"resource": ""
} |
q276757 | BaseGraph.add_subgraph | test | def add_subgraph(self, subgraph_or_ID):
""" Adds a subgraph to the graph.
"""
if not isinstance(subgraph_or_ID, (godot.subgraph.Subgraph,
godot.cluster.Cluster)):
subgraphID = str( subgraph_or_ID )
if subgraph_or_ID.startswith("c... | python | {
"resource": ""
} |
q276758 | BaseGraph._program_changed | test | def _program_changed(self, new):
""" Handles the Graphviz layout program selection changing.
"""
progs = self.progs
if not progs.has_key(prog):
logger.warning( 'GraphViz\'s executable "%s" not found' % prog )
if not os.path.exists( progs[prog] ) or not \
... | python | {
"resource": ""
} |
q276759 | BaseGraph._set_node_lists | test | def _set_node_lists(self, new):
""" Maintains each edge's list of available nodes.
"""
for edge in self.edges:
edge._nodes = self.nodes | python | {
"resource": ""
} |
q276760 | parse_dot_file | test | def parse_dot_file(filename):
""" Parses a DOT file and returns a Godot graph.
"""
parser = GodotDataParser()
graph = parser.parse_dot_file(filename)
del parser
return graph | python | {
"resource": ""
} |
q276761 | GodotDataParser.parse_dot_file | test | def parse_dot_file(self, file_or_filename):
""" Returns a graph given a file or a filename.
"""
if isinstance(file_or_filename, basestring):
file = None
try:
file = open(file_or_filename, "rb")
data = file.read()
except:
... | python | {
"resource": ""
} |
q276762 | GodotDataParser.build_top_graph | test | def build_top_graph(self,tokens):
""" Build a Godot graph instance from parsed data.
"""
# Get basic graph information.
strict = tokens[0] == 'strict'
graphtype = tokens[1]
directed = graphtype == 'digraph'
graphname = tokens[2]
# Build the graph
g... | python | {
"resource": ""
} |
q276763 | GodotDataParser.build_graph | test | def build_graph(self, graph, tokens):
""" Builds a Godot graph.
"""
subgraph = None
for element in tokens:
cmd = element[0]
if cmd == ADD_NODE:
cmd, nodename, opts = element
graph.add_node(nodename, **opts)
elif cmd ==... | python | {
"resource": ""
} |
q276764 | get_time_units_and_multiplier | test | def get_time_units_and_multiplier(seconds):
"""
Given a duration in seconds, determines the best units and multiplier to
use to display the time. Return value is a 2-tuple of units and multiplier.
"""
for cutoff, units, multiplier in units_table:
if seconds < cutoff:
break
re... | python | {
"resource": ""
} |
q276765 | format_duration | test | def format_duration(seconds):
"""Formats a number of seconds using the best units."""
units, divider = get_time_units_and_multiplier(seconds)
seconds *= divider
return "%.3f %s" % (seconds, units) | python | {
"resource": ""
} |
q276766 | TreeEditor.on_path | test | def on_path(self, new):
""" Handle the file path changing.
"""
self.name = basename(new)
self.graph = self.editor_input.load() | python | {
"resource": ""
} |
q276767 | TreeEditor.create_ui | test | def create_ui(self, parent):
""" Creates the toolkit-specific control that represents the
editor. 'parent' is the toolkit-specific control that is
the editor's parent.
"""
self.graph = self.editor_input.load()
view = View(Item(name="graph", editor=graph_tree_edit... | python | {
"resource": ""
} |
q276768 | nsplit | test | def nsplit(seq, n=2):
""" Split a sequence into pieces of length n
If the length of the sequence isn't a multiple of n, the rest is discarded.
Note that nsplit will split strings into individual characters.
Examples:
>>> nsplit("aabbcc")
[("a", "a"), ("b", "b"), ("c", "c")]
>>> nsplit("aab... | python | {
"resource": ""
} |
q276769 | windows | test | def windows(iterable, length=2, overlap=0, padding=True):
""" Code snippet from Python Cookbook, 2nd Edition by David Ascher,
Alex Martelli and Anna Ravenscroft; O'Reilly 2005
Problem: You have an iterable s and need to make another iterable whose
items are sublists (i.e., sliding windows), each of the... | python | {
"resource": ""
} |
q276770 | main | test | def main():
""" Runs Godot.
"""
application = GodotApplication( id="godot",
plugins=[CorePlugin(),
PuddlePlugin(),
WorkbenchPlugin(),
ResourcePlugin(),
GodotPlugin()] )
application.run() | python | {
"resource": ""
} |
q276771 | BaseGraphTreeNode.get_children | test | def get_children ( self, object ):
""" Gets the object's children.
"""
children = []
children.extend( object.subgraphs )
children.extend( object.clusters )
children.extend( object.nodes )
children.extend( object.edges )
return children | python | {
"resource": ""
} |
q276772 | BaseGraphTreeNode.append_child | test | def append_child ( self, object, child ):
""" Appends a child to the object's children.
"""
if isinstance( child, Subgraph ):
object.subgraphs.append( child )
elif isinstance( child, Cluster ):
object.clusters.append( child )
elif isinstance( child, Node... | python | {
"resource": ""
} |
q276773 | BaseGraphTreeNode.insert_child | test | def insert_child ( self, object, index, child ):
""" Inserts a child into the object's children.
"""
if isinstance( child, Subgraph ):
object.subgraphs.insert( index, child )
elif isinstance( child, Cluster ):
object.clusters.insert( index, child )
elif ... | python | {
"resource": ""
} |
q276774 | BaseGraphTreeNode.delete_child | test | def delete_child ( self, object, index ):
""" Deletes a child at a specified index from the object's children.
"""
if isinstance( child, Subgraph ):
object.subgraphs.pop(index)
elif isinstance( child, Cluster ):
object.clusters.pop( index )
elif isinstan... | python | {
"resource": ""
} |
q276775 | BaseGraphTreeNode.when_children_replaced | test | def when_children_replaced ( self, object, listener, remove ):
""" Sets up or removes a listener for children being replaced on a
specified object.
"""
object.on_trait_change( listener, "subgraphs", remove = remove,
dispatch = "fast_ui" )
objec... | python | {
"resource": ""
} |
q276776 | BaseGraphTreeNode.when_children_changed | test | def when_children_changed ( self, object, listener, remove ):
""" Sets up or removes a listener for children being changed on a
specified object.
"""
object.on_trait_change( listener, "subgraphs_items",
remove = remove, dispatch = "fast_ui" )
o... | python | {
"resource": ""
} |
q276777 | GraphNode.get_label | test | def get_label ( self, object ):
""" Gets the label to display for a specified object.
"""
label = self.label
if label[:1] == '=':
return label[1:]
label = xgetattr( object, label, '' )
if self.formatter is None:
return label
return self.... | python | {
"resource": ""
} |
q276778 | GraphNode.set_label | test | def set_label ( self, object, label ):
""" Sets the label for a specified object.
"""
label_name = self.label
if label_name[:1] != '=':
xsetattr( object, label_name, label ) | python | {
"resource": ""
} |
q276779 | GraphNode.when_label_changed | test | def when_label_changed ( self, object, listener, remove ):
""" Sets up or removes a listener for the label being changed on a
specified object.
"""
label = self.label
if label[:1] != '=':
object.on_trait_change( listener, label, remove = remove,
... | python | {
"resource": ""
} |
q276780 | SimpleGraphEditor.init | test | def init ( self, parent ):
""" Finishes initialising the editor by creating the underlying toolkit
widget.
"""
self._graph = graph = Graph()
ui = graph.edit_traits(parent=parent, kind="panel")
self.control = ui.control | python | {
"resource": ""
} |
q276781 | SimpleGraphEditor.update_editor | test | def update_editor ( self ):
""" Updates the editor when the object trait changes externally to the
editor.
"""
object = self.value
# Graph the new object...
canvas = self.factory.canvas
if canvas is not None:
for nodes_name in canvas.node_children:... | python | {
"resource": ""
} |
q276782 | SimpleGraphEditor._add_listeners | test | def _add_listeners ( self ):
""" Adds the event listeners for a specified object.
"""
object = self.value
canvas = self.factory.canvas
if canvas is not None:
for name in canvas.node_children:
object.on_trait_change(self._nodes_replaced, name)
... | python | {
"resource": ""
} |
q276783 | SimpleGraphEditor._nodes_replaced | test | def _nodes_replaced(self, object, name, old, new):
""" Handles a list of nodes being set.
"""
self._delete_nodes(old)
self._add_nodes(new) | python | {
"resource": ""
} |
q276784 | SimpleGraphEditor._nodes_changed | test | def _nodes_changed(self, object, name, undefined, event):
""" Handles addition and removal of nodes.
"""
self._delete_nodes(event.removed)
self._add_nodes(event.added) | python | {
"resource": ""
} |
q276785 | SimpleGraphEditor._add_nodes | test | def _add_nodes(self, features):
""" Adds a node to the graph for each item in 'features' using
the GraphNodes from the editor factory.
"""
graph = self._graph
if graph is not None:
for feature in features:
for graph_node in self.factory.nodes:
... | python | {
"resource": ""
} |
q276786 | SimpleGraphEditor._edges_replaced | test | def _edges_replaced(self, object, name, old, new):
""" Handles a list of edges being set.
"""
self._delete_edges(old)
self._add_edges(new) | python | {
"resource": ""
} |
q276787 | SimpleGraphEditor._edges_changed | test | def _edges_changed(self, object, name, undefined, event):
""" Handles addition and removal of edges.
"""
self._delete_edges(event.removed)
self._add_edges(event.added) | python | {
"resource": ""
} |
q276788 | SimpleGraphEditor._add_edges | test | def _add_edges(self, features):
""" Adds an edge to the graph for each item in 'features' using
the GraphEdges from the editor factory.
"""
graph = self._graph
if graph is not None:
for feature in features:
for graph_edge in self.factory.edges:
... | python | {
"resource": ""
} |
q276789 | Edge._parse_xdot_directive | test | def _parse_xdot_directive(self, name, new):
""" Handles parsing Xdot drawing directives.
"""
parser = XdotAttrParser()
components = parser.parse_xdot_data(new)
# The absolute coordinate of the drawing container wrt graph origin.
x1 = min( [c.x for c in components] )
... | python | {
"resource": ""
} |
q276790 | Edge._on_drawing | test | def _on_drawing(self, object, name, old, new):
""" Handles the containers of drawing components being set.
"""
attrs = [ "drawing", "arrowhead_drawing" ]
others = [getattr(self, a) for a in attrs \
if (a != name) and (getattr(self, a) is not None)]
x, y = self.compo... | python | {
"resource": ""
} |
q276791 | node_factory | test | def node_factory(**row_factory_kw):
""" Give new nodes a unique ID. """
if "__table_editor__" in row_factory_kw:
graph = row_factory_kw["__table_editor__"].object
ID = make_unique_name("n", [node.ID for node in graph.nodes])
del row_factory_kw["__table_editor__"]
return godot.no... | python | {
"resource": ""
} |
q276792 | edge_factory | test | def edge_factory(**row_factory_kw):
""" Give new edges a unique ID. """
if "__table_editor__" in row_factory_kw:
table_editor = row_factory_kw["__table_editor__"]
graph = table_editor.object
ID = make_unique_name("node", [node.ID for node in graph.nodes])
n_nodes = len(graph.no... | python | {
"resource": ""
} |
q276793 | MongoEngineConnection.prepare | test | def prepare(self, context):
"""Attach this connection's default database to the context using our alias."""
context.db[self.alias] = MongoEngineProxy(self.connection) | python | {
"resource": ""
} |
q276794 | Node.parse_xdot_drawing_directive | test | def parse_xdot_drawing_directive(self, new):
""" Parses the drawing directive, updating the node components.
"""
components = XdotAttrParser().parse_xdot_data(new)
max_x = max( [c.bounds[0] for c in components] + [1] )
max_y = max( [c.bounds[1] for c in components] + [1] )
... | python | {
"resource": ""
} |
q276795 | Node.parse_xdot_label_directive | test | def parse_xdot_label_directive(self, new):
""" Parses the label drawing directive, updating the label
components.
"""
components = XdotAttrParser().parse_xdot_data(new)
pos_x = min( [c.x for c in components] )
pos_y = min( [c.y for c in components] )
move_to... | python | {
"resource": ""
} |
q276796 | Node._drawing_changed | test | def _drawing_changed(self, old, new):
""" Handles the container of drawing components changing.
"""
if old is not None:
self.component.remove( old )
if new is not None:
# new.bgcolor="pink"
self.component.add( new )
w, h = self.component.bounds... | python | {
"resource": ""
} |
q276797 | Node._on_position_change | test | def _on_position_change(self, new):
""" Handles the poition of the component changing.
"""
w, h = self.component.bounds
self.pos = tuple([ new[0] + (w/2), new[1] + (h/2) ]) | python | {
"resource": ""
} |
q276798 | Node._pos_changed | test | def _pos_changed(self, new):
""" Handles the Graphviz position attribute changing.
"""
w, h = self.component.bounds
self.component.position = [ new[0] - (w/2), new[1] - (h/2) ]
# self.component.position = list( new )
self.component.request_redraw() | python | {
"resource": ""
} |
q276799 | ContextMenuTool.normal_right_down | test | def normal_right_down(self, event):
""" Handles the right mouse button being clicked when the tool is in
the 'normal' state.
If the event occurred on this tool's component (or any contained
component of that component), the method opens a context menu with
menu items from any to... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.