Search is not available for this dataset
text stringlengths 75 104k |
|---|
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) |
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 contained by the '%s' trait" % ct)
if hasattr(new, ct):
elements = getattr(new, ct)
logger.debug("%d element(s) found" % len(elements))
for element in elements:
pydot_node = Node(str(id(element)))
dot_attrs = node_mapping.dot_node
if dot_attrs is not None:
self._style_node(pydot_node, dot_attrs)
dot.add_node(pydot_node)
new.on_trait_change(self.map_element, ct+"_items")
logger.debug("Retrieving xdot data and forming pydot graph!")
xdot = graph_from_dot_data(dot.create(self.program, "xdot"))
parser = XDotParser()
for node in xdot.get_node_list():
diagram_node = parser.parse_node(node)
logger.debug(
"Parsed node [%s] and received diagram node [%s]" %
(node, diagram_node)
)
if diagram_node is not None:
for node_mapping in self.nodes: # FIXME: slow
ct = node_mapping.containment_trait
for element in getattr(new, ct):
if str(id(element)) == diagram_node.dot_node.get_name():
logger.debug(
"Referencing element [%s] from diagram node [%s]" %
(element, diagram_node)
)
diagram_node.element = element
break
# Tools
if isinstance(diagram_node.element, node_mapping.element):
for tool in node_mapping.tools:
logger.debug(
"Adding tool [%s] to diagram node [%s]" %
(tool, diagram_node)
)
diagram_node.tools.append(tool(diagram_node))
else:
if diagram_node.element is None:
logger.warning("Diagram node not referenced to element")
self.diagram.diagram_canvas.add(diagram_node)
del parser |
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:
old.on_trait_change(
self.map_element, ct+"_items", remove=True
) |
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_mapping in self.nodes:
ct = name[:-6] #strip '_items'
if node_mapping.containment_trait == ct:
dot_attrs = node_mapping.dot_node
dot = Dot()
graph_node = Node(str(id(element)))
self._style_node(graph_node, dot_attrs)
dot.add_node(graph_node)
xdot = graph_from_dot_data(dot.create(self.program,"xdot"))
diagram_nodes = parser.parse_nodes(xdot)#.get_node_list())
for dn in diagram_nodes:
if dn is not None:
dn.element = element
# Tools
for tool in node_mapping.tools:
dn.tools.append(tool(dn))
canvas.add(dn)
canvas.request_redraw()
for element in event.removed:
logger.debug("Unmapping element [%s] from diagram" % element)
for component in canvas.components:
if element == component.element:
canvas.remove(component)
canvas.request_redraw()
break |
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(rgba2hex(dot_attrs.color_))
pydot_node.set_fillcolor(
rgba2hex(dot_attrs.fill_color_)
)
for sty in dot_attrs.style:
logger.debug("Setting node style: %s" % sty)
pydot_node.set_style(sty)
return pydot_node |
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 [] |
def define_parser(self):
""" Defines xdot grammar.
@see: http://graphviz.org/doc/info/output.html#d:xdot """
# Common constructs.
point = Group(integer.setResultsName("x") +
integer.setResultsName("y"))
n_points = (integer.setResultsName("n") +
OneOrMore(point).setResultsName("points"))
n_bytes = Suppress(integer) + Suppress(minus) + \
Word(printables).setResultsName("b")
justify = ToInteger(
Literal("-1") | Literal("0") | Literal("1")
).setResultsName("j")
# Attributes ----------------------------------------------------------
# Set fill color. The color value consists of the n bytes following
# the '-'.
fill = (Literal("C").suppress() + Suppress(integer) + Suppress(minus) +
colour.setResultsName("color")).setResultsName("fill")
# Set pen color. The color value consists of the n bytes following '-'.
stroke = (Literal("c").suppress() + Suppress(integer) +
Suppress(minus) + colour.setResultsName("color")
).setResultsName("stroke")
# Set font. The font size is s points. The font name consists of the
# n bytes following '-'.
font = (Literal("F").suppress() + real.setResultsName("s") +
n_bytes).setResultsName("font")
# Set style attribute. The style value consists of the n bytes
# following '-'. The syntax of the value is the same as specified for
# a styleItem in style.
style = (Literal("S").suppress() + n_bytes).setResultsName("style")
# Shapes --------------------------------------------------------------
# Filled ellipse ((x-x0)/w)^2 + ((y-y0)/h)^2 = 1
filled_ellipse = (Literal("E").suppress() +
integer.setResultsName("x0") + integer.setResultsName("y0") +
integer.setResultsName("w") + integer.setResultsName("h")
).setResultsName("filled_ellipse")
# Unfilled ellipse ((x-x0)/w)^2 + ((y-y0)/h)^2 = 1
ellipse = (Literal("e").suppress() +
integer.setResultsName("x0") + integer.setResultsName("y0") +
integer.setResultsName("w") + integer.setResultsName("h")
).setResultsName("ellipse")
# Filled polygon using the given n points.
filled_polygon = (Literal("P").suppress() +
n_points).setResultsName("filled_polygon")
# Unfilled polygon using the given n points.
polygon = (Literal("p").suppress() +
n_points).setResultsName("polygon")
# Polyline using the given n points.
polyline = (Literal("L").suppress() +
n_points).setResultsName("polyline")
# B-spline using the given n control points.
bspline = (Literal("B").suppress() +
n_points).setResultsName("bspline")
# Filled B-spline using the given n control points.
filled_bspline = (Literal("b").suppress() +
n_points).setResultsName("filled_bspline")
# Text drawn using the baseline point (x,y). The text consists of the
# n bytes following '-'. The text should be left-aligned (centered,
# right-aligned) on the point if j is -1 (0, 1), respectively. The
# value w gives the width of the text as computed by the library.
text = (Literal("T").suppress() + integer.setResultsName("x") +
integer.setResultsName("y") + justify +
integer.setResultsName("w") + n_bytes).setResultsName("text")
# Externally-specified image drawn in the box with lower left corner
# (x,y) and upper right corner (x+w,y+h). The name of the image
# consists of the n bytes following '-'. This is usually a bitmap
# image. Note that the image size, even when converted from pixels to
# points, might be different from the required size (w,h). It is
# assumed the renderer will perform the necessary scaling.
image = (Literal("I").suppress() + integer.setResultsName("x") +
integer.setResultsName("y") + integer.setResultsName("w") +
integer.setResultsName("h") + n_bytes).setResultsName("image")
# The value of the drawing attributes consists of the concatenation of
# some (multi-)set of the 13 rendering or attribute operations.
value = (Optional(quote).suppress() + OneOrMore(filled_ellipse |
ellipse | filled_polygon | polygon | polyline | bspline |
filled_bspline | text | fill | stroke | font | style | image) +
Optional(quote).suppress()).setResultsName("value")
# Drawing operation.
# draw_ = Literal("_draw_") + Suppress(equals) + value
# # Label drawing.
# ldraw_ = Literal("_ldraw_") + Suppress(equals) + value
# # Edge head arrowhead drawing.
# hdraw_ = Literal("_hdraw_") + Suppress(equals) + value
# # Edge tail arrowhead drawing.
# tdraw_ = Literal("_tdraw_") + Suppress(equals) + value
# # Edge head label drawing.
# hldraw_ = Literal("_hldraw_") + Suppress(equals) + value
# # Edge tail label drawing.
# tldraw_ = Literal("_tldraw_") + Suppress(equals) + value
# Parse actions.
# n_points.setParseAction(self.proc_points)
# Attribute parse actions.
fill.setParseAction(self.proc_fill_color)
stroke.setParseAction(self.proc_stroke_color)
font.setParseAction(self.proc_font)
style.setParseAction(self.proc_style)
# Shape parse actions.
filled_ellipse.setParseAction(self.proc_filled_ellipse)
ellipse.setParseAction(self.proc_unfilled_ellipse)
filled_polygon.setParseAction(self.proc_filled_polygon)
polygon.setParseAction(self.proc_unfilled_polygon)
polyline.setParseAction(self.proc_polyline)
bspline.setParseAction(self.proc_unfilled_bspline)
filled_bspline.setParseAction(self.proc_filled_bspline)
text.setParseAction(self.proc_text)
image.setParseAction(self.proc_image)
return value |
def _proc_color(self, tokens):
""" The color traits of a Pen instance must be a string of the form
(r,g,b) or (r,g,b,a) where r, g, b, and a are integers from 0 to 255,
a wx.Colour instance, an integer which in hex is of the form 0xRRGGBB,
where RR is red, GG is green, and BB is blue or a valid color name. """
keys = tokens.keys()
if "red" in keys: # RGB(A)
rr, gg, bb = tokens["red"], tokens["green"], tokens["blue"]
hex2int = lambda h: int(h, 16)
if "alpha" in keys:
a = tokens["alpha"]
c = str((hex2int(rr), hex2int(gg), hex2int(bb), hex2int(a)))
else:
c = str((hex2int(rr), hex2int(gg), hex2int(bb)))
elif "hue" in keys: # HSV
r, g, b = hsv_to_rgb(tokens["hue"],
tokens["saturation"],
tokens["value"])
c = str((int(r*255), int(g*255), int(b*255)))
else:
c = tokens["color"]
return c |
def proc_font(self, tokens):
""" Sets the font. """
size = int(tokens["s"])
self.pen.font = "%s %d" % (tokens["b"], size)
return [] |
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_height=tokens["h"],
filled=filled)
return component |
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 |
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 |
def _proc_bspline(self, tokens, filled):
""" Returns the components of a B-spline (Bezier curve). """
pts = [(p["x"], p["y"]) for p in tokens["points"]]
component = BSpline(pen=self.pen, points=pts, filled=filled)
return component |
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=tokens["b"])
return component |
def proc_image(self, tokens):
""" Returns the components of an image. """
print "IMAGE:", tokens, tokens.asList(), tokens.keys()
raise NotImplementedError |
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 information in development, omitting from production due to sec.
response.headers['Grid-ID'] = str(f._id) # The GridFS file ID.
log.debug("Serving GridFS file.", extra=dict(
identifier = str(f._id),
filename = f.filename,
length = f.length,
mimetype = f.content_type
))
response.conditional_response = True
response.accept_ranges = 'bytes' # We allow returns of partial content, if requested.
response.content_type = f.content_type # Direct transfer of GridFS-stored MIME type.
response.content_length = f.length # The length was pre-computed when the file was uploaded.
response.content_md5 = response.etag = f.md5 # As was the MD5, used for simple integrity testing.
response.last_modified = f.metadata.get('modified', None) # Optional additional metadata.
response.content_disposition = 'attachment; filename=' + f.name # Preserve the filename through to the client.
# Being asked for a range or not determines the streaming style used.
if context.request.if_range.match_response(response):
response.body_file = f # Support seek + limited read.
else:
response.app_iter = iter(f) # Assign the body as a streaming, chunked iterator.
return True |
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)
return |
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 |
def _draw_mainlayer(self, gc, view_bounds=None, mode="default"):
""" Draws the component """
x_origin = self.x_origin
y_origin = self.y_origin
gc.save_state()
try:
# self._draw_bounds(gc)
gc.begin_path()
gc.translate_ctm(x_origin, y_origin)
gc.scale_ctm(self.e_width, self.e_height)
gc.arc(0.0, 0.0, 1.0, 0, 2.0*pi)
gc.close_path()
# Draw stroke at same scale as graphics context
# ctm = gc.get_ctm()
# if hasattr(ctm, "__len__") and len(ctm) == 6:
# scale = sqrt( (ctm[0]+ctm[1]) * (ctm[0]+ctm[1]) / 2.0 + \
# (ctm[2]+ctm[3]) * (ctm[2]+ctm[3]) / 2.0 )
# elif hasattr(gc, "get_ctm_scale"):
# scale = gc.get_ctm_scale()
# else:
# raise RuntimeError("Unable to get scale from GC.")
gc.set_line_width(self.pen.line_width)
gc.set_stroke_color(self.pen.color_)
if self.filled:
gc.set_fill_color(self.pen.fill_color_)
gc.draw_path(FILL_STROKE)
else:
gc.stroke_path()
finally:
gc.restore_state() |
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 |
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() |
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 |
def polar(x, y, deg=0): # radian if deg=0; degree if deg=1
""" Convert from rectangular (x,y) to polar (r,w)
r = sqrt(x^2 + y^2)
w = arctan(y/x) = [-\pi,\pi] = [-180,180]
"""
if deg:
return hypot(x, y), 180.0 * atan2(y, x) / pi
else:
return hypot(x, y), atan2(y, x) |
def quadratic(a, b, c=None):
""" x^2 + ax + b = 0 (or ax^2 + bx + c = 0)
By substituting x = y-t and t = a/2, the equation reduces to
y^2 + (b-t^2) = 0
which has easy solution
y = +/- sqrt(t^2-b)
"""
if c: # (ax^2 + bx + c = 0)
a, b = b / float(a), c / float(a)
t = a / 2.0
r = t**2 - b
if r >= 0: # real roots
y1 = sqrt(r)
else: # complex roots
y1 = cmath.sqrt(r)
y2 = -y1
return y1 - t, y2 - t |
def cubic(a, b, c, d=None):
""" x^3 + ax^2 + bx + c = 0 (or ax^3 + bx^2 + cx + d = 0)
With substitution x = y-t and t = a/3, the cubic equation reduces to
y^3 + py + q = 0,
where p = b-3t^2 and q = c-bt+2t^3. Then, one real root y1 = u+v can
be determined by solving
w^2 + qw - (p/3)^3 = 0
where w = u^3, v^3. From Vieta's theorem,
y1 + y2 + y3 = 0
y1 y2 + y1 y3 + y2 y3 = p
y1 y2 y3 = -q,
the other two (real or complex) roots can be obtained by solving
y^2 + (y1)y + (p+y1^2) = 0
"""
if d: # (ax^3 + bx^2 + cx + d = 0)
a, b, c = b / float(a), c / float(a), d / float(a)
t = a / 3.0
p, q = b - 3 * t**2, c - b * t + 2 * t**3
u, v = quadratic(q, -(p/3.0)**3)
if type(u) == type(0j): # complex cubic root
r, w = polar(u.real, u.imag)
y1 = 2 * cbrt(r) * cos(w / 3.0)
else: # real root
y1 = cbrt(u) + cbrt(v)
y2, y3 = quadratic(y1, p + y1**2)
return y1 - t, y2 - t, y3 - t |
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 = create_engine(self.uri, **self.config)
# Construct the session factory.
self.Session = scoped_session(sessionmaker(bind=engine))
# Test the connection.
engine.connect().close()
# Assign the engine to our database alias.
context.db[self.alias] = engine |
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 |
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)
if retval == YES:
self.model = Graph() |
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)|"
"*.dot;*.xdot;*.txt|Dot Files (*.dot)|*.dot|"
"All Files (*.*)|*.*|")
if dlg.open() == OK:
parser = GodotDataParser()
model = parser.parse_dot_file(dlg.path)
if model is not None:
self.model = model
else:
print "error parsing: %s" % dlg.path
self.save_file = dlg.path
del dlg |
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 = str(self.model)
fd.write(dot_code)
finally:
if fd is not None:
fd.close() |
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, *.xdot, *.txt)|" \
"*.dot;*.xdot;*.txt|Dot Files (*.dot)|*.dot|" \
"All Files (*.*)|*.*|")
if dlg.open() == OK:
fd = None
try:
fd = open(dlg.path, "wb")
dot_code = str(self.model)
fd.write(dot_code)
self.save_file = dlg.path
except:
error(parent=info.ui.control, title="Save Error",
message="An error was encountered when saving\nto %s"
% self.file)
finally:
if fd is not None:
fd.close()
del dlg |
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) |
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) |
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) |
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) |
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("node", IDs))
graph.nodes.append(node)
retval = node.edit_traits(parent=info.ui.control, kind="livemodal")
if not retval.result:
graph.nodes.remove(node) |
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]
if n_nodes == 0:
tail_node = Node(ID=make_unique_name("node", IDs))
head_name = make_unique_name("node", IDs + [tail_node.ID])
head_node = Node(ID=head_name)
elif n_nodes == 1:
tail_node = graph.nodes[0]
head_node = Node(ID=make_unique_name("node", IDs))
else:
tail_node = graph.nodes[0]
head_node = graph.nodes[1]
edge = Edge(tail_node, head_node, _nodes=graph.nodes)
retval = edge.edit_traits(parent=info.ui.control, kind="livemodal")
if retval.result:
graph.edges.append(edge) |
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 = subgraph.edit_traits(parent = info.ui.control,
kind = "livemodal")
if retval.result:
graph.subgraphs.append(subgraph) |
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_traits(parent = info.ui.control,
kind = "livemodal")
if retval.result:
graph.clusters.append(cluster) |
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,
view = "all_graphs_view")
if not retval.result:
return None
if self.selected_graph is not None:
return self.selected_graph
else:
return self.model |
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" ) |
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",
view = "dot_code_view" ) |
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",
default = YES)
if retval == YES:
self._on_close( info )
else:
self._on_close( info ) |
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 = component.e_width
component.y_origin = component.e_height
elif isinstance(component, (Polygon, BSpline)):
min_x = min( [t[0] for t in component.points] )
min_y = min( [t[1] for t in component.points] )
component.points = [
( p[0]-min_x, p[1]-min_y ) for p in component.points
]
elif isinstance(component, Text):
font = str_to_font( str(component.pen.font) )
component.text_x = 0#-( component.text_w / 2 )
component.text_y = 0 |
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("Unknown format '%s'." % format)
save(flo, **kwargs) |
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("Unknown format '%s'." % format)
return load(flo) |
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.save_to_file_like(fp, format, **kwargs) |
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(filename)
with file(filename,'rbU') as fp:
obj = cls.load_from_file_like(fp, format)
obj.filename = filename
return obj |
def _draw_mainlayer(self, gc, view_bounds=None, mode="default"):
""" Draws the component """
gc.save_state()
try:
# Specify the font
font = str_to_font(str(self.pen.font))
gc.set_font(font)
gc.set_fill_color(self.pen.color_)
x = self.text_x - ( self.text_w / 2 )
y = self.text_y - ( font.size / 2 )
# Show text at the same scale as the graphics context
ctm = gc.get_ctm()
if hasattr(ctm, "__len__") and len(ctm) == 6:
scale = sqrt( (ctm[0] + ctm[1]) * (ctm[0] + ctm[1]) / 2.0 + \
(ctm[2] + ctm[3]) * (ctm[2] + ctm[3]) / 2.0 )
elif hasattr(gc, "get_ctm_scale"):
scale = gc.get_ctm_scale()
else:
raise RuntimeError("Unable to get scale from GC.")
x *= scale
y *= scale
gc.show_text_at_point(self.text, x, y)
finally:
gc.restore_state() |
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),
lambda obj, val: setattr(obj, name, val),
**metadata) |
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:
for word in line.split():
yield word |
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[0][-1] not in ['.', '?', '!'],
self.content.keys()
))
return self._start_words |
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 ValueError("Chain with this name already exists") |
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") |
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
"""
for group in WalkByGroup(source, chain.order+1):
pre = group[:-1]
res = group[-1]
if pre not in chain.content:
chain.content[pre] = {res: 1}
else:
if res not in chain.content[pre]:
chain.content[pre][res] = 1
else:
chain.content[pre][res] += 1
chain.decache() |
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(choices):
total_weight = sum(weight for val, weight in choices)
rand = random.uniform(0, total_weight)
upto = 0
for val, weight in choices:
if upto + weight >= rand:
return val
upto += weight
sentence = list(random.choice(chain.startwords))
while not sentence[-1][-1] in ['.', '?', '!']:
sentence.append(
weighted_choice(
chain.content[tuple(sentence[-2:])].items()
)
)
return ' '.join(sentence) |
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 'prog' (which defaults to 'dot'), reading
the output and returning it as a string if the operation is
successful. On failure None is returned.
"""
prog = self.program if prog is None else prog
format = self.format if format is None else format
# Make a temporary file ...
tmp_fd, tmp_name = tempfile.mkstemp()
os.close( tmp_fd )
# ... and save the graph to it.
dot_fd = file( tmp_name, "w+b" )
self.save_dot( dot_fd )
dot_fd.close()
# Get the temporary file directory name.
tmp_dir = os.path.dirname( tmp_name )
# TODO: Shape image files (See PyDot). Important.
# Process the file using the layout program, specifying the format.
p = subprocess.Popen(
( self.programs[ prog ], '-T'+format, tmp_name ),
cwd=tmp_dir,
stderr=subprocess.PIPE, stdout=subprocess.PIPE)
stderr = p.stderr
stdout = p.stdout
# Make sense of the standard output form the process.
stdout_output = list()
while True:
data = stdout.read()
if not data:
break
stdout_output.append(data)
stdout.close()
if stdout_output:
stdout_output = ''.join(stdout_output)
# Similarly so for any standard error.
if not stderr.closed:
stderr_output = list()
while True:
data = stderr.read()
if not data:
break
stderr_output.append(data)
stderr.close()
if stderr_output:
stderr_output = ''.join(stderr_output)
#pid, status = os.waitpid(p.pid, 0)
status = p.wait()
if status != 0 :
logger.error("Program terminated with status: %d. stderr " \
"follows: %s" % ( status, stderr_output ) )
elif stderr_output:
logger.error( "%s", stderr_output )
# TODO: Remove shape image files from the temporary directory.
# Remove the temporary file.
os.unlink(tmp_name)
return stdout_output |
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.default_node is not None:
node = self.default_node.clone_traits(copy="deep")
node.ID = nodeID
else:
node = Node(nodeID)
self.nodes.append( node )
else:
node = node_or_ID
if node in self.nodes:
node = self.nodes[ self.nodes.index(node_or_ID) ]
else:
self.nodes.append( node )
node.set( **kwds )
return node |
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:
raise ValueError("Node %s does not exists" % node_or_ID)
# try:
# del self.nodes[name]
# except:
# raise ValueError("Node %s does not exists" % name)
# self.nodes = [n for n in self.nodes if n.ID != name]
# idx = self.nodes.index(name)
# return self.nodes.pop(idx)
self.nodes.remove(node) |
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 |
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 isinstance(head_node_or_ID, Node):
head_node = head_node_or_ID
else:
head_node = self.get_node(head_node_or_ID)
if (tail_node is None) or (head_node is None):
return None
for i, edge in enumerate(self.edges):
if (edge.tail_node == tail_node) and (edge.head_node == head_node):
edge = self.edges.pop(i)
return edge
return None |
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():
directed = self.directed
else:
directed = False
if self.default_edge is not None:
edge = self.default_edge.clone_traits(copy="deep")
edge.tail_node = tail_node
edge.head_node = head_node
edge.conn = "->" if directed else "--"
edge.set( **kwds )
else:
edge = Edge(tail_node, head_node, directed, **kwds)
if "strict" in self.trait_names():
if not self.strict:
self.edges.append(edge)
else:
self.edges.append(edge)
# FIXME: Implement strict graphs.
# raise NotImplementedError
else:
self.edges.append(edge) |
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("cluster"):
subgraph = godot.cluster.Cluster(ID=subgraphID)
else:
subgraph = godot.subgraph.Subgraph(ID=subgraphID)
else:
subgraph = subgraph_or_ID
subgraph.default_node = self.default_node
subgraph.default_edge = self.default_edge
# subgraph.level = self.level + 1
# subgraph.padding += self.padding
if isinstance(subgraph, godot.subgraph.Subgraph):
self.subgraphs.append(subgraph)
elif isinstance(subgraph, godot.cluster.Cluster):
self.clusters.append(subgraph)
else:
raise
return subgraph |
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 \
os.path.isfile( progs[prog] ):
logger.warning( "GraphViz's executable '%s' is not a "
"file or doesn't exist" % progs[prog] ) |
def _set_node_lists(self, new):
""" Maintains each edge's list of available nodes.
"""
for edge in self.edges:
edge._nodes = self.nodes |
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 |
def _proc_node_stmt(self, toks):
""" Return (ADD_NODE, node_name, options)
"""
opts = toks[1]
dummy_node = Node("dummy")
# Coerce attribute types.
for key, value in opts.iteritems():
trait = dummy_node.trait(key)
if trait is not None:
if trait.is_trait_type( Float ):
opts[key] = float( value )
elif trait.is_trait_type( Tuple ):
opts[key] = tuple( [float(c) for c in value.split(",")] )
return super(GodotDataParser, self)._proc_node_stmt(toks) |
def _proc_edge_stmt(self, toks):
""" Returns a tuple of the form (ADD_EDGE, src, dest, options).
"""
opts = toks[3]
dummy_edge = Edge("dummy1", "dummy2")
# Coerce attribute types.
for key, value in opts.iteritems():
trait = dummy_edge.trait(key)
if trait is not None:
# FIXME: Implement Graphviz spline types.
if trait.is_trait_type( List ):
p = [] # List of float doublets.
for t in value.split( " " ):
l = t.split( "," )
if len(l) == 3: # pos="e,39,61 39,97 39,89 39,80 39,71"
l.pop(0)
f = [ float(a) for a in l ]
p.append( tuple(f) )
opts[key] = p
elif trait.is_trait_type( Float ):
opts[key] = float( value )
elif trait.is_trait_type( Tuple ):
opts[key] = tuple( [float(c) for c in value.split(",")] )
return super(GodotDataParser, self)._proc_edge_stmt(toks) |
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:
print "Could not open %s." % file_or_filename
return None
finally:
if file is not None:
file.close()
else:
file = file_or_filename
data = file.read()
return self.parse_dot_data(data) |
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
graph = Graph(ID=graphname, strict=strict, directed=directed)
self.graph = self.build_graph(graph, tokens[3]) |
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 == ADD_EDGE:
cmd, src, dest, opts = element
srcport = destport = ""
if isinstance(src,tuple):
srcport = src[1]
src = src[0]
if isinstance(dest,tuple):
destport = dest[1]
dest = dest[0]
graph.add_edge(src, dest, tailport=srcport, headport=destport,
**opts)
elif cmd in [ADD_GRAPH_TO_NODE_EDGE,
ADD_GRAPH_TO_GRAPH_EDGE,
ADD_NODE_TO_GRAPH_EDGE]:
cmd, src, dest, opts = element
srcport = destport = ""
if isinstance(src,tuple):
srcport = src[1]
if isinstance(dest,tuple):
destport = dest[1]
if not (cmd == ADD_NODE_TO_GRAPH_EDGE):
if cmd == ADD_GRAPH_TO_NODE_EDGE:
src = subgraph
else:
src = prev_subgraph
dest = subgraph
else:
dest = subgraph
src_is_graph = isinstance(src, (Subgraph, Cluster))
dst_is_graph = isinstance(dst, (Subgraph, Cluster))
if src_is_graph:
src_nodes = src.nodes
else:
src_nodes = [src]
if dst_is_graph:
dst_nodes = dst.nodes
else:
dst_nodes = [dst]
for src_node in src_nodes:
for dst_node in dst_nodes:
graph.add_edge(from_node=src_node, to_node=dst_node,
tailport=srcport, headport=destport,
**kwds)
elif cmd == SET_GRAPH_ATTR:
graph.set( **element[1] )
elif cmd == SET_DEF_NODE_ATTR:
graph.default_node.set( **element[1] )
elif cmd == SET_DEF_EDGE_ATTR:
graph.default_edge.set( **element[1] )
elif cmd == SET_DEF_GRAPH_ATTR:
graph.default_graph.set( **element[1] )
elif cmd == ADD_SUBGRAPH:
cmd, name, elements = element
if subgraph:
prev_subgraph = subgraph
if name.startswith("cluster"):
cluster = Cluster(ID=name)
cluster = self.build_graph(cluster, elements)
graph.add_cluster(cluster)
else:
subgraph = Subgraph(ID=name)
subgraph = self.build_graph(subgraph, elements)
graph.add_subgraph(subgraph)
return graph |
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
return units, multiplier |
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) |
def _name_default(self):
""" Trait initialiser.
"""
# 'obj' is a io.File
self.obj.on_trait_change(self.on_path, "path")
return basename(self.obj.path) |
def on_path(self, new):
""" Handle the file path changing.
"""
self.name = basename(new)
self.graph = self.editor_input.load() |
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_editor,
show_label=False),
id="godot.graph_editor", kind="live", resizable=True)
ui = self.edit_traits(view=view, parent=parent, kind="subpanel")
return ui |
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("aabbcc",n=3)
[("a", "a", "b"), ("b", "c", "c")]
# Note that cc is discarded
>>> nsplit("aabbcc",n=4)
[("a", "a", "b", "b")]
"""
return [xy for xy in itertools.izip(*[iter(seq)]*n)] |
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 same given length,
over s' items, with successive windows overlapping by a specified amount.
"""
it = iter(iterable)
results = list(itertools.islice(it, length))
while len(results) == length:
yield results
results = results[length-overlap:]
results.extend(itertools.islice(it, length-overlap))
if padding and results:
results.extend(itertools.repeat(None, length-len(results)))
yield results |
def main():
""" Runs Godot.
"""
application = GodotApplication( id="godot",
plugins=[CorePlugin(),
PuddlePlugin(),
WorkbenchPlugin(),
ResourcePlugin(),
GodotPlugin()] )
application.run() |
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 |
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 ):
object.nodes.append( child )
elif isinstance( child, Edge ):
object.edges.append( child )
else:
pass |
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 isinstance( child, Node ):
object.nodes.insert( index, child )
elif isinstance( child, Edge ):
object.edges.insert( index, child )
else:
pass |
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 isinstance( child, Node ):
object.nodes.pop( index )
elif isinstance( child, Edge ):
object.edges.pop( index )
else:
pass |
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" )
object.on_trait_change( listener, "clusters", remove = remove,
dispatch = "fast_ui" )
object.on_trait_change( listener, "nodes", remove = remove,
dispatch = "fast_ui" )
object.on_trait_change( listener, "edges", remove = remove,
dispatch = "fast_ui" ) |
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" )
object.on_trait_change( listener, "clusters_items",
remove = remove, dispatch = "fast_ui" )
object.on_trait_change( listener, "nodes_items",
remove = remove, dispatch = "fast_ui" )
object.on_trait_change( listener, "edges_items",
remove = remove, dispatch = "fast_ui" ) |
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.formatter( object, label ) |
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 ) |
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,
dispatch = 'ui' ) |
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 |
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:
node_children = getattr(object, nodes_name)
self._add_nodes(node_children)
for edges_name in canvas.edge_children:
edge_children = getattr(object, edges_name)
self._add_edges(edge_children)
# ...then listen for changes.
self._add_listeners() |
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)
object.on_trait_change(self._nodes_changed, name + "_items")
for name in canvas.edge_children:
object.on_trait_change(self._edges_replaced, name)
object.on_trait_change(self._edges_changed, name + "_items")
else:
raise ValueError("Graph canvas not set for graph editor.") |
def _nodes_replaced(self, object, name, old, new):
""" Handles a list of nodes being set.
"""
self._delete_nodes(old)
self._add_nodes(new) |
def _nodes_changed(self, object, name, undefined, event):
""" Handles addition and removal of nodes.
"""
self._delete_nodes(event.removed)
self._add_nodes(event.added) |
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:
if feature.__class__ in graph_node.node_for:
graph.add_node( id(feature), **graph_node.dot_attr )
break
graph.arrange_all() |
def _delete_nodes(self, features):
""" Removes the node corresponding to each item in 'features'.
"""
graph = self._graph
if graph is not None:
for feature in features:
graph.delete_node( id(feature) )
graph.arrange_all() |
def _edges_replaced(self, object, name, old, new):
""" Handles a list of edges being set.
"""
self._delete_edges(old)
self._add_edges(new) |
def _edges_changed(self, object, name, undefined, event):
""" Handles addition and removal of edges.
"""
self._delete_edges(event.removed)
self._add_edges(event.added) |
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:
if feature.__class__ in graph_edge.edge_for:
tail_feature = getattr(feature, graph_edge.tail_name)
head_feature = getattr(feature, graph_edge.head_name)
graph.add_edge( id(tail_feature), id(head_feature),
**graph_edge.dot_attr )
break
graph.arrange_all() |
def _delete_edges(self, features):
""" Removes the node corresponding to each item in 'features'.
"""
graph = self._graph
if graph is not None:
for feature in features:
for graph_edge in self.factory.edges:
if feature.__class__ in graph_edge.edge_for:
tail_feature = getattr(feature, graph_edge.tail_name)
head_feature = getattr(feature, graph_edge.head_name)
graph.delete_edge( id(tail_feature), id(head_feature) )
graph.arrange_all() |
def _get_name(self):
""" Property getter.
"""
if (self.tail_node is not None) and (self.head_node is not None):
return "%s %s %s" % (self.tail_node.ID, self.conn,
self.head_node.ID)
else:
return "Edge" |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.