def derive_key(self):
        """This method is called to derive the key.  If you're unhappy with
        the default key derivation choices you can override them here.
        Keep in mind that the key derivation in itsdangerous is not intended
        to be used as a security method to make a complex key out of a short
        password.  Instead you should use large random secret keys.
        """
        salt = want_bytes(self.salt)
        if self.key_derivation == 'concat':
            return self.digest_method(salt + self.secret_key).digest()
        elif self.key_derivation == 'django-concat':
            return self.digest_method(salt + b'signer' +
                self.secret_key).digest()
        elif self.key_derivation == 'hmac':
            mac = hmac.new(self.secret_key, digestmod=self.digest_method)
            mac.update(salt)
            return mac.digest()
        elif self.key_derivation == 'none':
            return self.secret_key
        else:
            raise TypeError('Unknown key derivation method')

def
derive_key
(
self
)
:
salt
=
want_bytes
(
self
.
salt
)
if
self
.
key_derivation
==
'concat'
:
return
self
.
digest_method
(
salt
+
self
.
secret_key
)
.
digest
(
)
elif
self
.
key_derivation
==
'django-concat'
:
return
self
.
digest_method
(
salt
+
b'signer'
+
self
.
secret_key
)
.
digest
(
)
elif
self
.
key_derivation
==
'hmac'
:
mac
=
hmac
.
new
(
self
.
secret_key
,
digestmod
=
self
.
digest_method
)
mac
.
update
(
salt
)
return
mac
.
digest
(
)
elif
self
.
key_derivation
==
'none'
:
return
self
.
secret_key
else
:
raise
TypeError
(
'Unknown key derivation method'
)

This method is called to derive the key . If you re unhappy with the default key derivation choices you can override them here . Keep in mind that the key derivation in itsdangerous is not intended to be used as a security method to make a complex key out of a short password . Instead you should use large random secret keys .


def get_signature(self, value):
        """Returns the signature for the given value"""
        value = want_bytes(value)
        key = self.derive_key()
        sig = self.algorithm.get_signature(key, value)
        return base64_encode(sig)

def get_signature ( self , value ) : value = want_bytes ( value ) key = self . derive_key ( ) sig = self . algorithm . get_signature ( key , value ) return base64_encode ( sig )


def sign(self, value):
        """Signs the given string."""
        return value + want_bytes(self.sep) + self.get_signature(value)

def sign ( self , value ) : return value + want_bytes ( self . sep ) + self . get_signature ( value )


def verify_signature(self, value, sig):
        """Verifies the signature for the given value."""
        key = self.derive_key()
        try:
            sig = base64_decode(sig)
        except Exception:
            return False
        return self.algorithm.verify_signature(key, value, sig)

def verify_signature ( self , value , sig ) : key = self . derive_key ( ) try : sig = base64_decode ( sig ) except Exception : return False return self . algorithm . verify_signature ( key , value , sig )

Verifies the signature for the given value .


def unsign(self, signed_value):
        """Unsigns the given string."""
        signed_value = want_bytes(signed_value)
        sep = want_bytes(self.sep)
        if sep not in signed_value:
            raise BadSignature('No %r found in value' % self.sep)
        value, sig = signed_value.rsplit(sep, 1)
        if self.verify_signature(value, sig):
            return value
        raise BadSignature('Signature %r does not match' % sig,
                           payload=value)

def
unsign
(
self
,
signed_value
)
:
signed_value
=
want_bytes
(
signed_value
)
sep
=
want_bytes
(
self
.
sep
)
if
sep
not
in
signed_value
:
raise
BadSignature
(
'No %r found in value'
%
self
.
sep
)
value
,
sig
=
signed_value
.
rsplit
(
sep
,
1
)
if
self
.
verify_signature
(
value
,
sig
)
:
return
value
raise
BadSignature
(
'Signature %r does not match'
%
sig
,
payload
=
value
)


def sign(self, value):
        """Signs the given string and also attaches a time information."""
        value = want_bytes(value)
        timestamp = base64_encode(int_to_bytes(self.get_timestamp()))
        sep = want_bytes(self.sep)
        value = value + sep + timestamp
        return value + sep + self.get_signature(value)

def sign ( self , value ) : value = want_bytes ( value ) timestamp = base64_encode ( int_to_bytes ( self . get_timestamp ( ) ) ) sep = want_bytes ( self . sep ) value = value + sep + timestamp return value + sep + self . get_signature ( value )

Signs the given string and also attaches a time information .


def validate(self, signed_value, max_age=None):
        """Just validates the given signed value.  Returns `True` if the
        signature exists and is valid, `False` otherwise."""
        try:
            self.unsign(signed_value, max_age=max_age)
            return True
        except BadSignature:
            return False

def validate ( self , signed_value , max_age = None ) : try : self . unsign ( signed_value , max_age = max_age ) return True except BadSignature : return False

Just validates the given signed value . Returns True if the signature exists and is valid False otherwise .


def dumps(self, obj, salt=None):
        """Returns a signed string serialized with the internal serializer.
        The return value can be either a byte or unicode string depending
        on the format of the internal serializer.
        """
        payload = want_bytes(self.dump_payload(obj))
        rv = self.make_signer(salt).sign(payload)
        if self.is_text_serializer:
            rv = rv.decode('utf-8')
        return rv

def dumps ( self , obj , salt = None ) : payload = want_bytes ( self . dump_payload ( obj ) ) rv = self . make_signer ( salt ) . sign ( payload ) if self . is_text_serializer : rv = rv . decode ( 'utf-8' ) return rv

Returns a signed string serialized with the internal serializer . The return value can be either a byte or unicode string depending on the format of the internal serializer .


def server_error(request_id, error):
    """JSON-RPC server error.

    :param request_id: JSON-RPC request id
    :type request_id: int or str or None
    :param error: server error
    :type error: Exception

    """

    response = {
        'jsonrpc': '2.0',
        'id': request_id,
        'error': {
            'code': -32000,
            'message': 'Server error',
            'data': repr(error),
        },
    }
    raise ServiceException(500, dumps(response))

def
server_error
(
request_id
,
error
)
:
response
=
{
'jsonrpc'
:
'2.0'
,
'id'
:
request_id
,
'error'
:
{
'code'
:
32000
,
'message'
:
'Server error'
,
'data'
:
repr
(
error
)
,
}
,
}
raise
ServiceException
(
500
,
dumps
(
response
)
)


def find(cls, where='.', exclude=(), include=('*',)):
        """Return a list all Python packages found within directory 'where'

        'where' should be supplied as a "cross-platform" (i.e. URL-style)
        path; it will be converted to the appropriate local path syntax.
        'exclude' is a sequence of package names to exclude; '*' can be used
        as a wildcard in the names, such that 'foo.*' will exclude all
        subpackages of 'foo' (but not 'foo' itself).

        'include' is a sequence of package names to include.  If it's
        specified, only the named packages will be included.  If it's not
        specified, all found packages will be included.  'include' can contain
        shell style wildcard patterns just like 'exclude'.

        The list of included packages is built up first and then any
        explicitly excluded packages are removed from it.
        """
        out = cls._find_packages_iter(convert_path(where))
        out = cls.require_parents(out)
        includes = cls._build_filter(*include)
        excludes = cls._build_filter('ez_setup', '*__pycache__', *exclude)
        out = filter(includes, out)
        out = filterfalse(excludes, out)
        return list(out)

def find ( cls , where = '.' , exclude = ( ) , include = ( '*' , ) ) : out = cls . _find_packages_iter ( convert_path ( where ) ) out = cls . require_parents ( out ) includes = cls . _build_filter ( * include ) excludes = cls . _build_filter ( 'ez_setup' , '*__pycache__' , * exclude ) out = filter ( includes , out ) out = filterfalse ( excludes , out ) return list ( out )

Return a list all Python packages found within directory where


def require_parents(packages):
        """
        Exclude any apparent package that apparently doesn't include its
        parent.

        For example, exclude 'foo.bar' if 'foo' is not present.
        """
        found = []
        for pkg in packages:
            base, sep, child = pkg.rpartition('.')
            if base and base not in found:
                continue
            found.append(pkg)
            yield pkg

def require_parents ( packages ) : found = [ ] for pkg in packages : base , sep , child = pkg . rpartition ( '.' ) if base and base not in found : continue found . append ( pkg ) yield pkg

Exclude any apparent package that apparently doesn t include its parent .


def _all_dirs(base_path):
        """
        Return all dirs in base_path, relative to base_path
        """
        for root, dirs, files in os.walk(base_path, followlinks=True):
            for dir in dirs:
                yield os.path.relpath(os.path.join(root, dir), base_path)

def _all_dirs ( base_path ) : for root , dirs , files in os . walk ( base_path , followlinks = True ) : for dir in dirs : yield os . path . relpath ( os . path . join ( root , dir ) , base_path )

Return all dirs in base_path relative to base_path


def prepare_response(self, request, cached):
        """Verify our vary headers match and construct a real urllib3
        HTTPResponse object.
        """
        # Special case the '*' Vary value as it means we cannot actually
        # determine if the cached response is suitable for this request.
        if "*" in cached.get("vary", {}):
            return

        # Ensure that the Vary headers for the cached response match our
        # request
        for header, value in cached.get("vary", {}).items():
            if request.headers.get(header, None) != value:
                return

        body_raw = cached["response"].pop("body")

        try:
            body = io.BytesIO(body_raw)
        except TypeError:
            # This can happen if cachecontrol serialized to v1 format (pickle)
            # using Python 2. A Python 2 str(byte string) will be unpickled as
            # a Python 3 str (unicode string), which will cause the above to
            # fail with:
            #
            #     TypeError: 'str' does not support the buffer interface
            body = io.BytesIO(body_raw.encode('utf8'))

        return HTTPResponse(
            body=body,
            preload_content=False,
            **cached["response"]
        )

Verify our vary headers match and construct a real urllib3 HTTPResponse object .


def unsign(wheelfile):
    """
    Remove RECORD.jws from a wheel by truncating the zip file.

    RECORD.jws must be at the end of the archive. The zip file must be an
    ordinary archive, with the compressed files and the directory in the same
    order, and without any non-zip content after the truncation point.
    """
    import wheel.install
    vzf = wheel.install.VerifyingZipFile(wheelfile, "a")
    info = vzf.infolist()
    if not (len(info) and info[-1].filename.endswith('/RECORD.jws')):
        raise WheelError("RECORD.jws not found at end of archive.")
    vzf.pop()
    vzf.close()

Remove RECORD . jws from a wheel by truncating the zip file . RECORD . jws must be at the end of the archive . The zip file must be an ordinary archive with the compressed files and the directory in the same order and without any non - zip content after the truncation point .


def unpack(wheelfile, dest='.'):
    """Unpack a wheel.

    Wheel content will be unpacked to {dest}/{name}-{ver}, where {name}
    is the package name and {ver} its version.

    :param wheelfile: The path to the wheel.
    :param dest: Destination directory (default to current directory).
    """
    wf = WheelFile(wheelfile)
    namever = wf.parsed_filename.group('namever')
    destination = os.path.join(dest, namever)
    sys.stderr.write("Unpacking to: %s\n" % (destination))
    wf.zipfile.extractall(destination)
    wf.zipfile.close()

def
unpack
(
wheelfile
,
dest
=
'.'
)
:
wf
=
WheelFile
(
wheelfile
)
namever
=
wf
.
parsed_filename
.
group
(
'namever'
)
destination
=
os
.
path
.
join
(
dest
,
namever
)
sys
.
stderr
.
write
(
"Unpacking to: %s\n"
%
(
destination
)
)
wf
.
zipfile
.
extractall
(
destination
)
wf
.
zipfile
.
close
(
)


def install_scripts(distributions):
    """
    Regenerate the entry_points console_scripts for the named distribution.
    """
    try:
        from setuptools.command import easy_install
        import pkg_resources
    except ImportError:
        raise RuntimeError("'wheel install_scripts' needs setuptools.")

    for dist in distributions:
        pkg_resources_dist = pkg_resources.get_distribution(dist)
        install = wheel.paths.get_install_command(dist)
        command = easy_install.easy_install(install.distribution)
        command.args = ['wheel'] # dummy argument
        command.finalize_options()
        command.install_egg_scripts(pkg_resources_dist)

Regenerate the entry_points console_scripts for the named distribution .


def arrange_all(self):
        """ Sets for the _draw_ and _ldraw_ attributes for each of the graph
            sub-elements by processing the xdot format of the graph.
        """
        import godot.dot_data_parser

        parser = godot.dot_data_parser.GodotDataParser()

        xdot_data = self.create( format = "xdot" )
#        print "GRAPH DOT:\n", str( self )
#        print "XDOT DATA:\n", xdot_data

        parser.dotparser.parseWithTabs()
        ndata = xdot_data.replace( "\\\n", "" )
        tokens = parser.dotparser.parseString( ndata )[0]
        parser.build_graph( graph=self, tokens=tokens[3] )

        self.redraw_canvas()

#        print "GRAPH DOT:\n", str( self )

#        print "XDOT DATA:\n", xdot_data

Sets for the _draw_ and _ldraw_ attributes for each of the graph sub - elements by processing the xdot format of the graph .


def redraw_canvas(self):
        """ Parses the Xdot attributes of all graph components and adds
            the components to a new canvas.
        """
        from xdot_parser import XdotAttrParser

        xdot_parser = XdotAttrParser()
        canvas = self._component_default()

        for node in self.nodes:
            components = xdot_parser.parse_xdot_data( node._draw_ )
            canvas.add( *components )

            components = xdot_parser.parse_xdot_data( node._ldraw_ )
            canvas.add( *components )

        for edge in self.edges:
            components = xdot_parser.parse_xdot_data( edge._draw_ )
            canvas.add( *components )
            components = xdot_parser.parse_xdot_data( edge._ldraw_ )
            canvas.add( *components )
            components = xdot_parser.parse_xdot_data( edge._hdraw_ )
            canvas.add( *components )
            components = xdot_parser.parse_xdot_data( edge._tdraw_ )
            canvas.add( *components )
            components = xdot_parser.parse_xdot_data( edge._hldraw_ )
            canvas.add( *components )
            components = xdot_parser.parse_xdot_data( edge._tldraw_ )
            canvas.add( *components )

        self.component = canvas
        self.vp.request_redraw()

def redraw_canvas ( self ) : from xdot_parser import XdotAttrParser xdot_parser = XdotAttrParser ( ) canvas = self . _component_default ( ) for node in self . nodes : components = xdot_parser . parse_xdot_data ( node . _draw_ ) canvas . add ( * components ) components = xdot_parser . parse_xdot_data ( node . _ldraw_ ) canvas . add ( * components ) for edge in self . edges : components = xdot_parser . parse_xdot_data ( edge . _draw_ ) canvas . add ( * components ) components = xdot_parser . parse_xdot_data ( edge . _ldraw_ ) canvas . add ( * components ) components = xdot_parser . parse_xdot_data ( edge . _hdraw_ ) canvas . add ( * components ) components = xdot_parser . parse_xdot_data ( edge . _tdraw_ ) canvas . add ( * components ) components = xdot_parser . parse_xdot_data ( edge . _hldraw_ ) canvas . add ( * components ) components = xdot_parser . parse_xdot_data ( edge . _tldraw_ ) canvas . add ( * components ) self . component = canvas self . vp . request_redraw ( )

Parses the Xdot attributes of all graph components and adds the components to a new canvas .


def get_node(self, ID):
        """ Returns a node given an ID or None if no such node exists.
        """
        node = super(Graph, self).get_node(ID)
        if node is not None:
            return node

        for graph in self.all_graphs:
            for each_node in graph.nodes:
                if each_node.ID == ID:
                    return each_node
        else:
            return None

def get_node ( self , ID ) : node = super ( Graph , self ) . get_node ( ID ) if node is not None : return node for graph in self . all_graphs : for each_node in graph . nodes : if each_node . ID == ID : return each_node else : return None

Returns a node given an ID or None if no such node exists .


def _directed_changed(self, new):
        """ Sets the connection string for all edges.
        """
        if new:
            conn = "->"
        else:
            conn = "--"

        for edge in [e for g in self.all_graphs for e in g.edges]:
            edge.conn = conn

def _directed_changed ( self , new ) : if new : conn = "->" else : conn = "--" for edge in [ e for g in self . all_graphs for e in g . edges ] : edge . conn = conn

Sets the connection string for all edges .


def _on_edges(self, object, name, old, new):
        """ Handles the list of edges for any graph changing.
        """
        if name == "edges_items":
            edges = new.added
        elif name == "edges":
            edges = new
        else:
            edges = []

        all_nodes = [n for g in self.all_graphs for n in g.nodes]

        for each_edge in edges:
            # Ensure the edge's nodes exist in the graph.
            if each_edge.tail_node not in all_nodes:
                object.nodes.append( each_edge.tail_node )

            if each_edge.head_node not in all_nodes:
                object.nodes.append( each_edge.head_node )

            # Initialise the edge's list of available nodes.
            each_edge._nodes = all_nodes

Handles the list of edges for any graph changing .


def _component_changed(self, old, new):
        """ Handles the component being changed.
        """
        canvas = self.canvas
        if old is not None:
            canvas.remove(old)
        if new is not None:
            canvas.add(new)

def _component_changed ( self , old , new ) : canvas = self . canvas if old is not None : canvas . remove ( old ) if new is not None : canvas . add ( new )


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 referenced by the 'element' trait of the component that was
        double-clicked, setting the tool as the active tool for the duration
        of the view.

        """
        x = event.x
        y = event.y

        # First determine what component or components we are going to hittest
        # on.  If our component is a container, then we add its non-container
        # components to the list of candidates.
#        candidates = []
        component = self.component
#        if isinstance(component, Container):
#            candidates = get_nested_components(self.component)
#        else:
#            # We don't support clicking on unrecognized components
#            return
#
#        # Hittest against all the candidate and take the first one
#        item = None
#        for candidate, offset in candidates:
#            if candidate.is_in(x-offset[0], y-offset[1]):
#                item = candidate
#                break

        if hasattr(component, "element"):
            if component.element is not None:
                component.active_tool = self
                component.element.edit_traits(kind="livemodal")
                event.handled = True
                component.active_tool = None
                component.request_redraw()
        return

#        if isinstance(component, Container):

#        for candidate, offset in candidates:

Handles the left mouse button being double - clicked when the tool is in the normal state .


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.tools.append(tool(canvas))

def
_diagram_canvas_changed
(
self
,
new
)
:
logger
.
debug
(
"Diagram canvas changed!"
)
canvas
=
self
.
diagram_canvas
for
tool
in
self
.
tools
:
if
canvas
is
not
:
print
"Adding tool: %s"
%
tool
canvas
.
tools
.
append
(
tool
(
canvas
)
)


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(component)
#        logger.debug("Canvas components: %s" % canvas.components)
#        for component in canvas.components:
#            canvas.remove(component)
#        logger.debug("Canvas components: %s" % canvas.components)
#        canvas.request_redraw()

        new_canvas = Canvas()
        new_canvas.copy_traits(old_canvas, ["bgcolor", "draw_axes"])
        self.diagram_canvas = new_canvas

        self.viewport.component=new_canvas
        self.viewport.request_redraw()

        return

#        for component in canvas.components:


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 _domain_model_changed_for_diagram ( self , obj , name , old , new ) : 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 unmap_model ( self , old ) : 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
_style_node
(
self
,
pydot_node
,
dot_attrs
)
:
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
parse_xdot_data
(
self
,
data
)
:
parser
=
self
.
parser
#        if pyparsing_version >= "1.2":
#            parser.parseWithTabs()
if
data
:
return
parser
.
parseString
(
data
)
else
:
return
[
]

Parses xdot data and returns the associated components .


def proc_font(self, tokens):
        """ Sets the font. """

        size = int(tokens["s"])
        self.pen.font = "%s %d" % (tokens["b"], size)
        return []

def
proc_font
(
self
,
tokens
)
:
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_ellipse ( self , tokens , filled ) : 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_polygon ( self , tokens , filled ) : 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_polyline ( self , tokens ) : pts = [ ( p [ "x" ] , p [ "y" ] ) for p in tokens [ "points" ] ] component = Polyline ( pen = self . pen , points = pts ) 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_text ( self , tokens ) : 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 proc_image ( self , tokens ) : 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

Allow direct use of GridOut GridFS file wrappers as endpoint responses .


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 load ( self ) : fd = None try : obj = parse_dot_file ( self . dot_file . absolute_path ) finally : if fd is not None : fd . close ( ) return obj


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
is_in
(
self
,
point_x
,
point_y
)
:
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 _draw_bounds ( self , gc ) : 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
perform
(
self
,
event
)
:
wizard
=
NewDotGraphWizard
(
parent
=
self
.
window
.
control
,
window
=
self
.
window
,
title
=
"New Graph"
)
# Open the wizard
if
wizard
.
open
(
)
==
OK
:
wizard
.
finished
=
True


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

Construct the SQLAlchemy engine and session factory .


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 _parse_dot_code_fired ( self ) : parser = GodotDataParser ( ) graph = parser . parse_dot_data ( self . dot_code ) if graph is not None : self . model = graph

Parses the dot_code string and replaces the existing model .


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
new_model
(
self
,
info
)
:
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 ( self , info ) : 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 ( )

Handles saving the current model to the last file .


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

Handles saving the current model to file .


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_graph ( self , info ) : if info . initialized : self . model . edit_traits ( parent = info . ui . control , kind = "live" , view = attr_view )

Handles display of the graph dot traits .


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_nodes ( self , info ) : 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 configure_edges ( self , info ) : 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 about_godot ( self , info ) : 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_node ( self , info ) : 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_edge ( self , info ) : 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_subgraph
(
self
,
info
)
:
if
not
info
.
initialized
:
return
graph
=
self
.
_request_graph
(
info
.
ui
.
control
)
if
graph
is
not
:
subgraph
=
Subgraph
(
)
#root=graph, parent=graph)
retval
=
subgraph
.
edit_traits
(
parent
=
info
.
ui
.
control
,
kind
=
"livemodal"
)
if
retval
.
result
:
graph
.
subgraphs
.
append
(
subgraph
)

Handles adding a Subgraph to the main graph .


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
add_cluster
(
self
,
info
)
:
if
not
info
.
initialized
:
return
graph
=
self
.
_request_graph
(
info
.
ui
.
control
)
if
graph
is
not
:
cluster
=
Cluster
(
)
#root=graph, parent=graph)
retval
=
cluster
.
edit_traits
(
parent
=
info
.
ui
.
control
,
kind
=
"livemodal"
)
if
retval
.
result
:
graph
.
clusters
.
append
(
cluster
)

Handles adding a Cluster to the main graph .


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 _request_graph ( self , parent = None ) : 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

Displays a dialog for graph selection if more than one exists . Returns None if the dialog is canceled .


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 godot_options ( self , info ) : 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 configure_dot_code ( self , info ) : 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" )

Handles display of the dot code in a text editor .


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
on_exit
(
self
,
info
)
:
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
)

Handles the user attempting to exit Godot .


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
move_to_origin
(
components
)
:
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

Components are positioned relative to their container . Use this method to position the bottom - left corner of the components at the origin .


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
save_to_file_like
(
self
,
flo
,
format
=
,
*
*
kwargs
)
:
format
=
self
.
format
if
format
is
else
format
save
=
getattr
(
self
,
"save_%s"
%
format
,
)
if
save
is
:
raise
ValueError
(
"Unknown format '%s'."
%
format
)
save
(
flo
,
*
*
kwargs
)

Save the object to a given file like object in the given format .


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
load_from_file_like
(
cls
,
flo
,
format
=
)
:
format
=
self
.
format
if
format
is
else
format
load
=
getattr
(
cls
,
"load_%s"
%
format
,
)
if
load
is
:
raise
ValueError
(
"Unknown format '%s'."
%
format
)
return
load
(
flo
)

Load the object to a given file like object with the given protocol .


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)

Save the object to file given by filename .


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

Return an instance of the class that is saved in the file with the given filename in the specified format .


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 Alias ( name , * * metadata ) : return Property ( lambda obj : getattr ( obj , name ) , lambda obj , val : setattr ( obj , name , val ) , * * metadata )

Syntactically concise alias trait but creates a pair of lambda functions for every alias you declare .


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 parse ( filename , encoding = None ) : 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 startwords ( self ) : 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

!DEMO! Cached list of keys that can be used to generate sentence .


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
add_chain
(
self
,
name
,
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
remove_chain
(
self
,
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 build_chain ( self , source , chain ) : 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
generate_sentence
(
self
,
chain
)
:
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
)

!DEMO! Demo function that shows how to generate a simple sentence starting with uppercase letter without lenght limit .


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

Creates and returns a representation of the graph using the Graphviz layout program given by prog according to the given format .


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 add_node ( self , node_or_ID , * * kwds ) : 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 get_node ( self , ID ) : for node in self . nodes : if node . ID == str ( ID ) : return node return None

Returns the node with the given ID or 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 delete_edge ( self , tail_node_or_ID , head_node_or_ID ) : 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

Removes an edge from the graph . Returns the deleted edge or 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)

#                raise NotImplementedError


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

#        subgraph.level = self.level + 1

#        subgraph.padding += self.padding


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
_program_changed
(
self
,
new
)
:
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
]
)

Handles the Graphviz layout program selection changing .


def _set_node_lists(self, new):
        """ Maintains each edge's list of available nodes.
        """
        for edge in self.edges:
            edge._nodes = self.nodes

def _set_node_lists ( self , new ) : for edge in self . edges : edge . _nodes = self . nodes

Maintains each edge s list of available 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 parse_dot_file ( filename ) : parser = GodotDataParser ( ) graph = parser . parse_dot_file ( filename ) del parser return graph

Parses a DOT file and returns a Godot graph .


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
parse_dot_file
(
self
,
file_or_filename
)
:
if
isinstance
(
file_or_filename
,
basestring
)
:
file
=
try
:
file
=
open
(
file_or_filename
,
"rb"
)
data
=
file
.
read
(
)
except
:
print
"Could not open %s."
%
file_or_filename
return
finally
:
if
file
is
not
:
file
.
close
(
)
else
:
file
=
file_or_filename
data
=
file
.
read
(
)
return
self
.
parse_dot_data
(
data
)

Returns a graph given a file or a filename .


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_top_graph
(
self
,
tokens
)
:
# 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
]
)

Build a Godot graph instance from parsed data .


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 build_graph ( self , graph , tokens ) : 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 get_time_units_and_multiplier ( seconds ) : for cutoff , units , multiplier in units_table : if seconds < cutoff : break return units , multiplier

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 .


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
format_duration
(
seconds
)
:
units
,
divider
=
get_time_units_and_multiplier
(
seconds
)
seconds
*=
divider
return
"%.3f %s"
%
(
seconds
,
units
)

Formats a number of seconds using the best units .


def on_path(self, new):
        """ Handle the file path changing.
        """
        self.name = basename(new)
        self.graph = self.editor_input.load()

def on_path ( self , new ) : 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 create_ui ( self , 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

Creates the toolkit - specific control that represents the editor . parent is the toolkit - specific control that is the editor s parent .


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 nsplit ( seq , n = 2 ) : 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 windows ( iterable , length = 2 , overlap = 0 , padding = True ) : 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

Code snippet from Python Cookbook 2nd Edition by David Ascher Alex Martelli and Anna Ravenscroft ; O Reilly 2005


def main():
    """ Runs Godot.
    """
    application = GodotApplication( id="godot",
        plugins=[CorePlugin(),
                 PuddlePlugin(),
                 WorkbenchPlugin(),
                 ResourcePlugin(),
                 GodotPlugin()] )

    application.run()

def main ( ) : 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 get_children ( self , object ) : 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 append_child ( self , object , child ) : 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

Appends a child to the object s children .


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 insert_child ( self , object , index , child ) : 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

Inserts a child into the object s children .


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 delete_child ( self , object , index ) : 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

Deletes a child at a specified index from the object s children .


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_replaced ( self , object , listener , remove ) : 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" )

Sets up or removes a listener for children being replaced on a specified object .


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 when_children_changed ( self , object , listener , remove ) : 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" )

Sets up or removes a listener for children being changed on a specified object .


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 get_label ( self , 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 )

Gets the label to display for a specified object .


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 set_label ( self , object , label ) : 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 when_label_changed ( self , object , listener , remove ) : label = self . label if label [ : 1 ] != '=' : object . on_trait_change ( listener , label , remove = remove , dispatch = 'ui' )

Sets up or removes a listener for the label being changed on a specified object .


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 init ( self , parent ) : self . _graph = graph = Graph ( ) ui = graph . edit_traits ( parent = parent , kind = "panel" ) self . control = ui . control

Finishes initialising the editor by creating the underlying toolkit widget .


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
update_editor
(
self
)
:
object
=
self
.
value
# Graph the new object...
canvas
=
self
.
factory
.
canvas
if
canvas
is
not
:
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
(
)

Updates the editor when the object trait changes externally to the editor .


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.")

Adds the event listeners for a specified object .


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_replaced ( self , object , name , old , new ) : 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 _nodes_changed ( self , object , name , undefined , event ) : 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 _add_nodes ( self , features ) : 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 ( )

Adds a node to the graph for each item in features using the GraphNodes from the editor factory .


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_replaced ( self , object , name , old , new ) : 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 _edges_changed ( self , object , name , undefined , event ) : 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 _add_edges ( self , 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 . add_edge ( id ( tail_feature ) , id ( head_feature ) , * * graph_edge . dot_attr ) break graph . arrange_all ( )

Adds an edge to the graph for each item in features using the GraphEdges from the editor factory .


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] )
        y1 = min( [c.y for c in components] )

        print "X1/Y1:", name, x1, y1

        # Components are positioned relative to their container. This
        # function positions the bottom-left corner of the components at
        # their origin rather than relative to the graph.
#        move_to_origin( components )

        for c in components:
            if isinstance(c, Ellipse):
                component.x_origin -= x1
                component.y_origin -= y1
#                c.position = [ c.x - x1, c.y - y1 ]

            elif isinstance(c, (Polygon, BSpline)):
                print "Points:", c.points
                c.points = [ (t[0] - x1, t[1] - y1) for t in c.points ]
                print "Points:", c.points

            elif isinstance(c, Text):
#                font = str_to_font( str(c.pen.font) )
                c.text_x, c.text_y = c.x - x1, c.y - y1

        container = Container(auto_size=True,
            position=[ x1, y1 ],
            bgcolor="yellow")

        container.add( *components )

        if name == "_draw_":
            self.drawing = container
        elif name == "_hdraw_":
            self.arrowhead_drawing = container
        else:
            raise

#                c.position = [ c.x - x1, c.y - y1 ]

#                font = str_to_font( str(c.pen.font) )

Handles parsing Xdot drawing directives .


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.component.position
        print "POS:", x, y, self.component.position

        abs_x = [d.x + x for d in others]
        abs_y = [d.y + y for d in others]

        print "ABS:", abs_x, abs_y

        # Assume that he new drawing is positioned relative to graph origin.
        x1 = min( abs_x + [new.x] )
        y1 = min( abs_y + [new.y] )

        print "DRAW:", new.position
        new.position = [ new.x - x1, new.y - y1 ]
        print "DRAW:", new.position

#        for i, b in enumerate( others ):
#            self.drawing.position = [100, 100]
#            self.drawing.request_redraw()
#            print "OTHER:", b.position, abs_x[i] - x1
#            b.position = [ abs_x[i] - x1, abs_y[i] - y1 ]
#            b.x = 50
#            b.y = 50
#            print "OTHER:", b.position, abs_x[i], x1

#        for attr in attrs:
#            if attr != name:
#                if getattr(self, attr) is not None:
#                    drawing = getattr(self, attr)
#                    drawing.position = [50, 50]

        if old is not None:
            self.component.remove( old )
        if new is not None:
            self.component.add( new )

        print "POS NEW:", self.component.position
        self.component.position = [ x1, y1 ]
        print "POS NEW:", self.component.position
        self.component.request_redraw()
        print "POS NEW:", self.component.position

#        for i, b in enumerate( others ):

#            self.drawing.position = [100, 100]

#            self.drawing.request_redraw()

#                if getattr(self, attr) is not None:

#                    drawing = getattr(self, attr)

#                    drawing.position = [50, 50]

Handles the containers of drawing components being set .


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.node.Node(ID)
    else:
        return godot.node.Node(uuid.uuid4().hex[:6])

def node_factory ( * * row_factory_kw ) : 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 . node . Node ( ID ) else : return godot . node . Node ( uuid . uuid4 ( ) . hex [ : 6 ] )


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.nodes)
        IDs = [v.ID for v in graph.nodes]

        if n_nodes == 0:
            tail_node = godot.Node(ID=make_unique_name("n", IDs))
            head_node = godot.Node(ID=make_unique_name("n", IDs))
        elif n_nodes == 1:
            tail_node = graph.nodes[0]
            head_node = godot.Node(ID=make_unique_name("n", IDs))
        else:
            tail_node = graph.nodes[0]
            head_node = graph.nodes[1]

        return godot.edge.Edge(tail_node, head_node, _nodes=graph.nodes)
    else:
        return None

def edge_factory ( * * row_factory_kw ) : 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 . nodes ) IDs = [ v . ID for v in graph . nodes ] if n_nodes == 0 : tail_node = godot . Node ( ID = make_unique_name ( "n" , IDs ) ) head_node = godot . Node ( ID = make_unique_name ( "n" , IDs ) ) elif n_nodes == 1 : tail_node = graph . nodes [ 0 ] head_node = godot . Node ( ID = make_unique_name ( "n" , IDs ) ) else : tail_node = graph . nodes [ 0 ] head_node = graph . nodes [ 1 ] return godot . edge . Edge ( tail_node , head_node , _nodes = graph . nodes ) else : return None