From 050e291cbf63fd190f1ec14d65d1154a23ce8756 Mon Sep 17 00:00:00 2001

From: Sandro Tosi <morph@debian.org>

Date: Sun, 10 Jan 2016 00:25:45 +0000

Subject: support python3

Origin: https://github.com/nlhepler/pydot/tree/adf18a858a63b321b7e4ffd964a24d73add1bf4f

Bug-Debian: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=739858

Reviewed-by: Sandro Tosi <morph@debian.org>

Last-Update: 2016-01-10

---

 dot_parser.py |  429 ++++++++--------

 pydot.py      | 1553 +++++++++++++++++++++++++++------------------------------

 setup.py      |    6 +-

 3 files changed, 954 insertions(+), 1034 deletions(-)

diff --git a/dot_parser.py b/dot_parser.py

index dedd61a..4cdd482 100644

--- a/dot_parser.py

+++ b/dot_parser.py

@@ -1,4 +1,3 @@

-# -*- coding: Latin-1 -*-

 """Graphviz's dot language parser.

 The dotparser parses graphviz files in dot and dot files and transforms them

@@ -10,236 +9,215 @@ Author: Michael Krause <michael@krause-software.de>

 Fixes by: Ero Carrera <ero@dkbza.org>

 """

+from __future__ import division, print_function

+

 __author__ = ['Michael Krause', 'Ero Carrera']

 __license__ = 'MIT'

-

 import sys

-import glob

 import pydot

-import re

 import codecs

 from pyparsing import __version__ as pyparsing_version

-from pyparsing import ( nestedExpr, Literal, CaselessLiteral, Word, Upcase, OneOrMore, ZeroOrMore,

-    Forward, NotAny, delimitedList, oneOf, Group, Optional, Combine, alphas, nums,

-    restOfLine, cStyleComment, nums, alphanums, printables, empty, quotedString,

-    ParseException, ParseResults, CharsNotIn, _noncomma, dblQuotedString, QuotedString, ParserElement )

+from pyparsing import (

+    nestedExpr, Literal, CaselessLiteral, Word, OneOrMore,

+    Forward, Group, Optional, Combine, nums, restOfLine,

+    cStyleComment, alphanums, printables, ParseException,

+    ParseResults, CharsNotIn, QuotedString

+    )

+

+

+PY3 = not sys.version_info < (3, 0, 0)

+

+if PY3:

+    basestring = str

 class P_AttrList:

     def __init__(self, toks):

-

         self.attrs = {}

         i = 0

-        

+

         while i < len(toks):

             attrname = toks[i]

-            if i+2 < len(toks) and toks[i+1] == '=':

-                attrvalue = toks[i+2]

+            if i + 2 < len(toks) and toks[i + 1] == '=':

+                attrvalue = toks[i + 2]

                 i += 3

             else:

                 attrvalue = None

                 i += 1

-                

+

             self.attrs[attrname] = attrvalue

-            

-            

-    def __repr__(self):

+    def __repr__(self):

         return "%s(%r)" % (self.__class__.__name__, self.attrs)

-

 class DefaultStatement(P_AttrList):

     def __init__(self, default_type, attrs):

-

         self.default_type = default_type

         self.attrs = attrs

     def __repr__(self):

-

-        return "%s(%s, %r)" % (self.__class__.__name__,

-            self.default_type, self.attrs)

+        return "%s(%s, %r)" % (

+            self.__class__.__name__,

+            self.default_type, self.attrs

+            )

 top_graphs = list()

-def push_top_graph_stmt(str, loc, toks):

+def push_top_graph_stmt(str, loc, toks):

     attrs = {}

     g = None

-    

+

     for element in toks:

-    

-        if( isinstance(element, (ParseResults, tuple, list)) and

-            len(element) == 1 and isinstance(element[0], basestring) ):

-            

+        if (isinstance(element, (ParseResults, tuple, list)) and

+                len(element) == 1 and isinstance(element[0], basestring)):

             element = element[0]

-            

+

         if element == 'strict':

             attrs['strict'] = True

-            

-        elif element in ['graph', 'digraph']:

+        elif element in ['graph', 'digraph']:

             attrs = {}

-            

+

             g = pydot.Dot(graph_type=element, **attrs)

             attrs['type'] = element

-            

-            top_graphs.append( g )

-            

-        elif isinstance( element, basestring):

-            g.set_name( element )

-            

+

+            top_graphs.append(g)

+

+        elif isinstance(element, basestring):

+            g.set_name(element)

+

         elif isinstance(element, pydot.Subgraph):

-        

-            g.obj_dict['attributes'].update( element.obj_dict['attributes'] )

-            g.obj_dict['edges'].update( element.obj_dict['edges'] )

-            g.obj_dict['nodes'].update( element.obj_dict['nodes'] )

-            g.obj_dict['subgraphs'].update( element.obj_dict['subgraphs'] )

-            

+            g.obj_dict['attributes'].update(element.obj_dict['attributes'])

+            g.obj_dict['edges'].update(element.obj_dict['edges'])

+            g.obj_dict['nodes'].update(element.obj_dict['nodes'])

+            g.obj_dict['subgraphs'].update(element.obj_dict['subgraphs'])

             g.set_parent_graph(g)

-            

+

         elif isinstance(element, P_AttrList):

             attrs.update(element.attrs)

         elif isinstance(element, (ParseResults, list)):

             add_elements(g, element)

-            

+

         else:

-            raise ValueError, "Unknown element statement: %r " % element

-    

-    

+            raise ValueError("Unknown element statement: %r " % element)

+

     for g in top_graphs:

         update_parent_graph_hierarchy(g)

-    

-    if len( top_graphs ) == 1:

+

+    if len(top_graphs) == 1:

         return top_graphs[0]

-        

+

     return top_graphs

 def update_parent_graph_hierarchy(g, parent_graph=None, level=0):

-

-

     if parent_graph is None:

         parent_graph = g

-        

-    for key_name in ('edges',):

+    for key_name in ('edges',):

         if isinstance(g, pydot.frozendict):

             item_dict = g

         else:

             item_dict = g.obj_dict

-            

-        if not item_dict.has_key( key_name ):

+

+        if key_name not in item_dict:

             continue

         for key, objs in item_dict[key_name].items():

             for obj in objs:

-                if 'parent_graph' in obj and obj['parent_graph'].get_parent_graph()==g:

+                if 'parent_graph' in obj and obj['parent_graph'].get_parent_graph() == g:

                     if obj['parent_graph'] is g:

                         pass

                     else:

                         obj['parent_graph'].set_parent_graph(parent_graph)

                 if key_name == 'edges' and len(key) == 2:

-                    for idx, vertex in enumerate( obj['points'] ):

-                        if isinstance( vertex, (pydot.Graph, pydot.Subgraph, pydot.Cluster)):

+                    for idx, vertex in enumerate(obj['points']):

+                        if isinstance(vertex, (pydot.Graph, pydot.Subgraph, pydot.Cluster)):

                             vertex.set_parent_graph(parent_graph)

-                        if isinstance( vertex, pydot.frozendict):

+                        if isinstance(vertex, pydot.frozendict):

                             if vertex['parent_graph'] is g:

                                 pass

                             else:

                                 vertex['parent_graph'].set_parent_graph(parent_graph)

-

 def add_defaults(element, defaults):

-

     d = element.__dict__

     for key, value in defaults.items():

         if not d.get(key):

             d[key] = value

-

 def add_elements(g, toks, defaults_graph=None, defaults_node=None, defaults_edge=None):

-    

     if defaults_graph is None:

         defaults_graph = {}

     if defaults_node is None:

         defaults_node = {}

     if defaults_edge is None:

         defaults_edge = {}

-        

+

     for elm_idx, element in enumerate(toks):

-        

         if isinstance(element, (pydot.Subgraph, pydot.Cluster)):

-        

             add_defaults(element, defaults_graph)

             g.add_subgraph(element)

-            

+

         elif isinstance(element, pydot.Node):

-        

             add_defaults(element, defaults_node)

             g.add_node(element)

-            

+

         elif isinstance(element, pydot.Edge):

-        

             add_defaults(element, defaults_edge)

             g.add_edge(element)

-            

+

         elif isinstance(element, ParseResults):

-        

             for e in element:

                 add_elements(g, [e], defaults_graph, defaults_node, defaults_edge)

-                

+

         elif isinstance(element, DefaultStatement):

-        

             if element.default_type == 'graph':

-            

                 default_graph_attrs = pydot.Node('graph', **element.attrs)

                 g.add_node(default_graph_attrs)

             elif element.default_type == 'node':

-            

                 default_node_attrs = pydot.Node('node', **element.attrs)

                 g.add_node(default_node_attrs)

             elif element.default_type == 'edge':

-            

                 default_edge_attrs = pydot.Node('edge', **element.attrs)

                 g.add_node(default_edge_attrs)

                 defaults_edge.update(element.attrs)

             else:

-                raise ValueError, "Unknown DefaultStatement: %s " % element.default_type

-                

+                raise ValueError("Unknown DefaultStatement: %s " % element.default_type)

+

         elif isinstance(element, P_AttrList):

-        

             g.obj_dict['attributes'].update(element.attrs)

         else:

-            raise ValueError, "Unknown element statement: %r" % element

+            raise ValueError("Unknown element statement: %r" % element)

-def push_graph_stmt(str, loc, toks):            

-                       

+def push_graph_stmt(str, loc, toks):

     g = pydot.Subgraph('')

     add_elements(g, toks)

     return g

 def push_subgraph_stmt(str, loc, toks):

-

     g = pydot.Subgraph('')

+

     for e in toks:

-        if len(e)==3:

+        if len(e) == 3:

             e[2].set_name(e[1])

             if e[0] == 'subgraph':

                 e[2].obj_dict['show_keyword'] = True

@@ -253,11 +231,9 @@ def push_subgraph_stmt(str, loc, toks):

 def push_default_stmt(str, loc, toks):

-

     # The pydot class instances should be marked as

     # default statements to be inherited by actual

     # graphs, nodes and edges.

-    #

     default_type = toks[0][0]

     if len(toks) > 1:

         attrs = toks[1].attrs

@@ -267,90 +243,80 @@ def push_default_stmt(str, loc, toks):

     if default_type in ['graph', 'node', 'edge']:

         return DefaultStatement(default_type, attrs)

     else:

-        raise ValueError, "Unknown default statement: %r " % toks

+        raise ValueError("Unknown default statement: %r " % toks)

 def push_attr_list(str, loc, toks):

-

     p = P_AttrList(toks)

     return p

 def get_port(node):

-

-    if len(node)>1:

+    if len(node) > 1:

         if isinstance(node[1], ParseResults):

-            if len(node[1][0])==2:

-                if node[1][0][0]==':':

+            if len(node[1][0]) == 2:

+                if node[1][0][0] == ':':

                     return node[1][0][1]

-                    

     return None

-    

-def do_node_ports(node):

+def do_node_ports(node):

     node_port = ''

+

     if len(node) > 1:

-        node_port = ''.join( [str(a)+str(b) for a,b in node[1] ] )

+        node_port = ''.join([str(a) + str(b) for a, b in node[1]])

     return node_port

-    

+

 def push_edge_stmt(str, loc, toks):

-    

     tok_attrs = [a for a in toks if isinstance(a, P_AttrList)]

     attrs = {}

+

     for a in tok_attrs:

         attrs.update(a.attrs)

     e = []

     if isinstance(toks[0][0], pydot.Graph):

-    

         n_prev = pydot.frozendict(toks[0][0].obj_dict)

-    else:        

-        n_prev = toks[0][0] + do_node_ports( toks[0] )

+    else:

+        n_prev = toks[0][0] + do_node_ports(toks[0])

     if isinstance(toks[2][0], ParseResults):

-    

-        n_next_list = [[n.get_name(),] for n in toks[2][0] ]

+        n_next_list = [[n.get_name()] for n in toks[2][0]]

         for n_next in [n for n in n_next_list]:

             n_next_port = do_node_ports(n_next)

-            e.append(pydot.Edge(n_prev, n_next[0]+n_next_port, **attrs))

+            e.append(pydot.Edge(n_prev, n_next[0] + n_next_port, **attrs))

     elif isinstance(toks[2][0], pydot.Graph):

-    

         e.append(pydot.Edge(n_prev, pydot.frozendict(toks[2][0].obj_dict), **attrs))

     elif isinstance(toks[2][0], pydot.Node):

-    

         node = toks[2][0]

-        

+

         if node.get_port() is not None:

             name_port = node.get_name() + ":" + node.get_port()

         else:

             name_port = node.get_name()

-        

+

         e.append(pydot.Edge(n_prev, name_port, **attrs))

     elif isinstance(toks[2][0], type('')):

-    

         for n_next in [n for n in tuple(toks)[2::2]]:

-

             if isinstance(n_next, P_AttrList) or not isinstance(n_next[0], type('')):

                 continue

-            n_next_port = do_node_ports( n_next )

-            e.append(pydot.Edge(n_prev, n_next[0]+n_next_port, **attrs))

-                

-            n_prev = n_next[0]+n_next_port

-            

+            n_next_port = do_node_ports(n_next)

+            e.append(pydot.Edge(n_prev, n_next[0] + n_next_port, **attrs))

+

+            n_prev = n_next[0] + n_next_port

+

     else:

         # UNEXPECTED EDGE TYPE

         pass

-        

-    return e

+    return e

 def push_node_stmt(s, loc, toks):

@@ -359,30 +325,25 @@ def push_node_stmt(s, loc, toks):

         attrs = toks[1].attrs

     else:

         attrs = {}

-        

+

     node_name = toks[0]

     if isinstance(node_name, list) or isinstance(node_name, tuple):

-        if len(node_name)>0:

+        if len(node_name) > 0:

             node_name = node_name[0]

-    

+

     n = pydot.Node(str(node_name), **attrs)

     return n

-

-    

-    

-

 graphparser = None

-def graph_definition():

+def graph_definition():

     global graphparser

-    

+

     if not graphparser:

-    

         # punctuation

-        colon  = Literal(":")

+        colon = Literal(":")

         lbrace = Literal("{")

         rbrace = Literal("}")

         lbrack = Literal("[")

@@ -390,142 +351,170 @@ def graph_definition():

         lparen = Literal("(")

         rparen = Literal(")")

         equals = Literal("=")

-        comma  = Literal(",")

-        dot    = Literal(".")

-        slash  = Literal("/")

-        bslash = Literal("\\")

-        star   = Literal("*")

-        semi   = Literal(";")

-        at     = Literal("@")

-        minus  = Literal("-")

-        

+        comma = Literal(",")

+        # dot = Literal(".")

+        # slash = Literal("/")

+        # bslash = Literal("\\")

+        # star = Literal("*")

+        semi = Literal(";")

+        at = Literal("@")

+        minus = Literal("-")

+

         # keywords

-        strict_    = CaselessLiteral("strict")

-        graph_     = CaselessLiteral("graph")

-        digraph_   = CaselessLiteral("digraph")

-        subgraph_  = CaselessLiteral("subgraph")

-        node_      = CaselessLiteral("node")

-        edge_      = CaselessLiteral("edge")

-        

-        

+        strict_ = CaselessLiteral("strict")

+        graph_ = CaselessLiteral("graph")

+        digraph_ = CaselessLiteral("digraph")

+        subgraph_ = CaselessLiteral("subgraph")

+        node_ = CaselessLiteral("node")

+        edge_ = CaselessLiteral("edge")

+

         # token definitions

-        

-        identifier = Word(alphanums + "_." ).setName("identifier")

-        

-        double_quoted_string = QuotedString('"', multiline=True, unquoteResults=False) # dblQuotedString

+        identifier = Word(alphanums + "_.").setName("identifier")

+

+        # dblQuotedString

+        double_quoted_string = QuotedString('"', multiline=True, unquoteResults=False)

-        alphastring_ = OneOrMore(CharsNotIn(_noncomma + ' '))

+        noncomma_ = "".join([c for c in printables if c != ","])

+        alphastring_ = OneOrMore(CharsNotIn(noncomma_ + ' '))

         def parse_html(s, loc, toks):

             return '<%s>' % ''.join(toks[0])

-            

-        

+

         opener = '<'

         closer = '>'

-        html_text = nestedExpr( opener, closer, 

-            ( CharsNotIn( opener + closer )  ) 

-                ).setParseAction(parse_html).leaveWhitespace()

-

-        ID = ( identifier | html_text | 

-            double_quoted_string | #.setParseAction(strip_quotes) |

-            alphastring_ ).setName("ID")

-            

-        

-        float_number = Combine(Optional(minus) +	

-            OneOrMore(Word(nums + "."))).setName("float_number")

-            

-        righthand_id =  (float_number | ID ).setName("righthand_id")

+        html_text = nestedExpr(

+            opener, closer,

+            (CharsNotIn(opener + closer))

+            ).setParseAction(parse_html).leaveWhitespace()

+

+        ID = (

+            identifier | html_text |

+            double_quoted_string |  # .setParseAction(strip_quotes) |

+            alphastring_

+            ).setName("ID")

+

+        float_number = Combine(

+            Optional(minus) +

+            OneOrMore(Word(nums + "."))

+            ).setName("float_number")

+

+        righthand_id = (float_number | ID).setName("righthand_id")

         port_angle = (at + ID).setName("port_angle")

-        

-        port_location = (OneOrMore(Group(colon + ID)) |	

-            Group(colon + lparen + ID + comma + ID + rparen)).setName("port_location")

-            

-        port = (Group(port_location + Optional(port_angle)) |	

-            Group(port_angle + Optional(port_location))).setName("port")

-            

+

+        port_location = (

+            OneOrMore(Group(colon + ID)) |

+            Group(colon + lparen + ID + comma + ID + rparen)

+            ).setName("port_location")

+

+        port = (

+            Group(port_location + Optional(port_angle)) |

+            Group(port_angle + Optional(port_location))

+            ).setName("port")

+

         node_id = (ID + Optional(port))

-        a_list = OneOrMore(ID + Optional(equals + righthand_id) +

-            Optional(comma.suppress())).setName("a_list")

-        

-        attr_list = OneOrMore(lbrack.suppress() + Optional(a_list) +	

-            rbrack.suppress()).setName("attr_list")

-        

+        a_list = OneOrMore(

+            ID + Optional(equals + righthand_id) + Optional(comma.suppress())

+            ).setName("a_list")

+

+        attr_list = OneOrMore(

+            lbrack.suppress() + Optional(a_list) + rbrack.suppress()

+            ).setName("attr_list")

+

         attr_stmt = (Group(graph_ | node_ | edge_) + attr_list).setName("attr_stmt")

-        

+

         edgeop = (Literal("--") | Literal("->")).setName("edgeop")

-        

+

         stmt_list = Forward()

-        graph_stmt = Group(lbrace.suppress() + Optional(stmt_list) +	

-            rbrace.suppress() + Optional(semi.suppress()) ).setName("graph_stmt")

-            

-            

+        graph_stmt = Group(

+            lbrace.suppress() + Optional(stmt_list) +

+            rbrace.suppress() + Optional(semi.suppress())

+            ).setName("graph_stmt")

+

         edge_point = Forward()

-        

+

         edgeRHS = OneOrMore(edgeop + edge_point)

         edge_stmt = edge_point + edgeRHS + Optional(attr_list)

-        

+

         subgraph = Group(subgraph_ + Optional(ID) + graph_stmt).setName("subgraph")

-        

-        edge_point << Group( subgraph | graph_stmt | node_id ).setName('edge_point')

-        

-        node_stmt = (node_id + Optional(attr_list) + Optional(semi.suppress())).setName("node_stmt")

-        

+

+        edge_point << Group(subgraph | graph_stmt | node_id).setName('edge_point')

+

+        node_stmt = (

+            node_id + Optional(attr_list) + Optional(semi.suppress())

+            ).setName("node_stmt")

+

         assignment = (ID + equals + righthand_id).setName("assignment")

-        stmt =  (assignment | edge_stmt | attr_stmt | subgraph | graph_stmt | node_stmt).setName("stmt")

+        stmt = (

+            assignment | edge_stmt | attr_stmt |

+            subgraph | graph_stmt | node_stmt

+            ).setName("stmt")

         stmt_list << OneOrMore(stmt + Optional(semi.suppress()))

-        

-        graphparser = OneOrMore( (Optional(strict_) + Group((graph_ | digraph_)) +

-            Optional(ID) + graph_stmt).setResultsName("graph") )

-        

+

+        graphparser = OneOrMore((

+            Optional(strict_) + Group((graph_ | digraph_)) +

+            Optional(ID) + graph_stmt

+            ).setResultsName("graph"))

+

         singleLineComment = Group("//" + restOfLine) | Group("#" + restOfLine)

-        

-        

+

         # actions

-        

         graphparser.ignore(singleLineComment)

         graphparser.ignore(cStyleComment)

-        

+

         assignment.setParseAction(push_attr_list)

         a_list.setParseAction(push_attr_list)

         edge_stmt.setParseAction(push_edge_stmt)

         node_stmt.setParseAction(push_node_stmt)

         attr_stmt.setParseAction(push_default_stmt)

-        

+

         subgraph.setParseAction(push_subgraph_stmt)

         graph_stmt.setParseAction(push_graph_stmt)

         graphparser.setParseAction(push_top_graph_stmt)

-        

-    

+

     return graphparser

 def parse_dot_data(data):

-

     global top_graphs

-    

+

     top_graphs = list()

-    if data.startswith(codecs.BOM_UTF8):

-        data = data.decode( 'utf-8' )

-        

+    if PY3:

+        if isinstance(data, bytes):

+            # this is extremely hackish

+            try:

+                idx = data.index(b'charset') + 7

+                while data[idx] in b' \t\n\r=':

+                    idx += 1

+                fst = idx

+                while data[idx] not in b' \t\n\r];,':

+                    idx += 1

+                charset = data[fst:idx].strip(b'"\'').decode('ascii')

+                data = data.decode(charset)

+            except:

+                data = data.decode('utf-8')

+    else:

+        if data.startswith(codecs.BOM_UTF8):

+            data = data.decode('utf-8')

+

     try:

-    

+

         graphparser = graph_definition()

-        

+

         if pyparsing_version >= '1.2':

             graphparser.parseWithTabs()

-            

+

         tokens = graphparser.parseString(data)

         if len(tokens) == 1:

             return tokens[0]

         else:

             return [g for g in tokens]

-        

-    except ParseException, err:

-    

-        print err.line

-        print " "*(err.column-1) + "^"

-        print err

+

+    except ParseException:

+        err = sys.exc_info()[1]

+        print(err.line)

+        print(" " * (err.column - 1) + "^")

+        print(err)

         return None

diff --git a/pydot.py b/pydot.py

index e9bd2a1..c20db18 100644

--- a/pydot.py

+++ b/pydot.py

@@ -17,24 +17,40 @@ Copyright (c) 2005-2011 Ero Carrera <ero.carrera@gmail.com>

 Distributed under MIT license [http://opensource.org/licenses/mit-license.html].

 """

-__revision__ = "$LastChangedRevision: 28 $"

+from __future__ import division, print_function

+

 __author__ = 'Ero Carrera'

-__version__ = '1.0.%d' % int( __revision__[21:-2] )

+__version__ = '1.0.29'

 __license__ = 'MIT'

 import os

 import re

 import subprocess

+import sys

 import tempfile

 import copy

+

+from operator import itemgetter

+

 try:

     import dot_parser

-except Exception, e:

-    print "Couldn't import dot_parser, loading of dot files will not be possible."

-    

+except Exception:

+    print("Couldn't import dot_parser, loading of dot files will not be possible.")

+

+PY3 = not sys.version_info < (3, 0, 0)

-GRAPH_ATTRIBUTES = set( ['Damping', 'K', 'URL', 'aspect', 'bb', 'bgcolor',

+if PY3:

+    NULL_SEP = b''

+    basestring = str

+    long = int

+    unicode = str

+else:

+    NULL_SEP = ''

+

+

+GRAPH_ATTRIBUTES = set([

+    'Damping', 'K', 'URL', 'aspect', 'bb', 'bgcolor',

     'center', 'charset', 'clusterrank', 'colorscheme', 'comment', 'compound',

     'concentrate', 'defaultdist', 'dim', 'dimen', 'diredgeconstraints',

     'dpi', 'epsilon', 'esep', 'fontcolor', 'fontname', 'fontnames',

@@ -46,13 +62,15 @@ GRAPH_ATTRIBUTES = set( ['Damping', 'K', 'URL', 'aspect', 'bb', 'bgcolor',

     'overlap_scaling', 'pack', 'packmode', 'pad', 'page', 'pagedir',

     'quadtree', 'quantum', 'rankdir', 'ranksep', 'ratio', 'remincross',

     'repulsiveforce', 'resolution', 'root', 'rotate', 'searchsize', 'sep',

-    'showboxes', 'size', 'smoothing', 'sortv', 'splines', 'start', 

+    'showboxes', 'size', 'smoothing', 'sortv', 'splines', 'start',

     'stylesheet', 'target', 'truecolor', 'viewport', 'voro_margin',

-    # for subgraphs 

-    'rank' ] )

+    # for subgraphs

+    'rank'

+   ])

-EDGE_ATTRIBUTES = set( ['URL', 'arrowhead', 'arrowsize', 'arrowtail',

+EDGE_ATTRIBUTES = set([

+    'URL', 'arrowhead', 'arrowsize', 'arrowtail',

     'color', 'colorscheme', 'comment', 'constraint', 'decorate', 'dir',

     'edgeURL', 'edgehref', 'edgetarget', 'edgetooltip', 'fontcolor',

     'fontname', 'fontsize', 'headURL', 'headclip', 'headhref', 'headlabel',

@@ -63,10 +81,12 @@ EDGE_ATTRIBUTES = set( ['URL', 'arrowhead', 'arrowsize', 'arrowtail',

     'nojustify', 'penwidth', 'pos', 'samehead', 'sametail', 'showboxes',

     'style', 'tailURL', 'tailclip', 'tailhref', 'taillabel', 'tailport',

     'tailtarget', 'tailtooltip', 'target', 'tooltip', 'weight',

-    'rank' ] )

+    'rank'

+   ])

-NODE_ATTRIBUTES = set( ['URL', 'color', 'colorscheme', 'comment',

+NODE_ATTRIBUTES = set([

+    'URL', 'color', 'colorscheme', 'comment',

     'distortion', 'fillcolor', 'fixedsize', 'fontcolor', 'fontname',

     'fontsize', 'group', 'height', 'id', 'image', 'imagescale', 'label',

     'labelloc', 'layer', 'margin', 'nojustify', 'orientation', 'penwidth',

@@ -74,14 +94,62 @@ NODE_ATTRIBUTES = set( ['URL', 'color', 'colorscheme', 'comment',

     'shape', 'shapefile', 'showboxes', 'sides', 'skew', 'sortv', 'style',

     'target', 'tooltip', 'vertices', 'width', 'z',

     # The following are attributes dot2tex

-    'texlbl',  'texmode' ] )

+    'texlbl', 'texmode'

+   ])

-CLUSTER_ATTRIBUTES = set( ['K', 'URL', 'bgcolor', 'color', 'colorscheme',

+CLUSTER_ATTRIBUTES = set([

+    'K', 'URL', 'bgcolor', 'color', 'colorscheme',

     'fillcolor', 'fontcolor', 'fontname', 'fontsize', 'label', 'labeljust',

     'labelloc', 'lheight', 'lp', 'lwidth', 'nojustify', 'pencolor',

-    'penwidth', 'peripheries', 'sortv', 'style', 'target', 'tooltip'] )

-            

+    'penwidth', 'peripheries', 'sortv', 'style', 'target', 'tooltip'

+   ])

+

+

+def is_string_like(obj): # from John Hunter, types-free version

+    """Check if obj is string."""

+    try:

+        obj + ''

+    except (TypeError, ValueError):

+        return False

+    return True

+

+def get_fobj(fname, mode='w+'):

+    """Obtain a proper file object.

+

+    Parameters

+    ----------

+    fname : string, file object, file descriptor

+        If a string or file descriptor, then we create a file object. If *fname*

+        is a file object, then we do nothing and ignore the specified *mode*

+        parameter.

+    mode : str

+        The mode of the file to be opened.

+

+    Returns

+    -------

+    fobj : file object

+        The file object.

+    close : bool

+        If *fname* was a string, then *close* will be *True* to signify that