[Python-modules-commits] [pydot] 03/14: merge patched into master
Sandro Tosi
morph at moszumanska.debian.org
Sat Nov 25 19:47:21 UTC 2017
This is an automated email from the git hooks/post-receive script.
morph pushed a commit to branch master
in repository pydot.
commit 5c24fba0c601af9a5a30710a5b7371771bd145ce
Merge: 90ef7aa 36cdebb
Author: Sandro Tosi <morph at debian.org>
Date: Sat Nov 25 12:56:29 2017 -0500
merge patched into master
debian/.git-dpm | 4 ++--
...ort-python3.patch => 0001-support-python3.patch} | 9 ++-------
debian/patches/01-setup-py-nodata.patch | 21 ---------------------
debian/patches/series | 3 +--
setup.py | 3 ++-
5 files changed, 7 insertions(+), 33 deletions(-)
diff --cc debian/.git-dpm
index 86ad1dd,0000000..90dbcb3
mode 100644,000000..100644
--- a/debian/.git-dpm
+++ b/debian/.git-dpm
@@@ -1,11 -1,0 +1,11 @@@
+# see git-dpm(1) from git-dpm package
- 050e291cbf63fd190f1ec14d65d1154a23ce8756
- 050e291cbf63fd190f1ec14d65d1154a23ce8756
++36cdebbe253bdf22bce2b74070d1111f098a66b1
++36cdebbe253bdf22bce2b74070d1111f098a66b1
+7a2668df205a82c26ff478cee16bdac7ac77026b
+7a2668df205a82c26ff478cee16bdac7ac77026b
+pydot_1.0.28.orig.tar.gz
+3945af1765943807d72e773c7ac853f008ebb0b2
+19711
+debianTag="debian/%e%v"
+patchedTag="patched/%e%v"
+upstreamTag="upstream/%e%u"
diff --cc debian/patches/0001-support-python3.patch
index 6602ed7,0000000..bb40a4e
mode 100644,000000..100644
--- a/debian/patches/0001-support-python3.patch
+++ b/debian/patches/0001-support-python3.patch
@@@ -1,3493 -1,0 +1,3488 @@@
- From 050e291cbf63fd190f1ec14d65d1154a23ce8756 Mon Sep 17 00:00:00 2001
++From 36cdebbe253bdf22bce2b74070d1111f098a66b1 Mon Sep 17 00:00:00 2001
+From: Sandro Tosi <morph at 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 at 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 at krause-software.de>
+ Fixes by: Ero Carrera <ero at 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 at 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
++ the file object should be closed after writing to it. Otherwise, *close*
++ will be *False* signifying that the user, in essence, created the file
++ object already and that subsequent operations should not close it.
++
++ """
++ if is_string_like(fname):
++ fobj = open(fname, mode)
++ close = True
++ elif hasattr(fname, 'write'):
++ # fname is a file-like object, perhaps a StringIO (for example)
++ fobj = fname
++ close = False
++ else:
++ # assume it is a file descriptor
++ fobj = os.fdopen(fname, mode)
++ close = False
++ return fobj, close
++
+
+ #
+ # Extented version of ASPN's Python Cookbook Recipe:
+@@ -92,7 +160,7 @@ CLUSTER_ATTRIBUTES = set( ['K', 'URL', 'bgcolor', 'color', 'colorscheme',
+ #
+ class frozendict(dict):
+ def _blocked_attribute(obj):
+- raise AttributeError, "A frozendict cannot be modified."
++ raise AttributeError("A frozendict cannot be modified.")
+ _blocked_attribute = property(_blocked_attribute)
+
+ __delitem__ = __setitem__ = clear = _blocked_attribute
+@@ -105,7 +173,7 @@ class frozendict(dict):
+ for arg in args:
+ if isinstance(arg, dict):
+ arg = copy.copy(arg)
+- for k, v in arg.iteritems():
++ for k, v in arg.items():
+ if isinstance(v, frozendict):
+ arg[k] = v
+ elif isinstance(v, dict):
+@@ -114,13 +182,13 @@ class frozendict(dict):
+ v_ = list()
+ for elm in v:
+ if isinstance(elm, dict):
+- v_.append( frozendict(elm) )
++ v_.append(frozendict(elm))
+ else:
+- v_.append( elm )
++ v_.append(elm)
+ arg[k] = tuple(v_)
+- args_.append( arg )
++ args_.append(arg)
+ else:
+- args_.append( arg )
++ args_.append(arg)
+
+ dict.__init__(new, *args_, **kw)
+ return new
+@@ -132,7 +200,7 @@ class frozendict(dict):
+ try:
+ return self._cached_hash
+ except AttributeError:
+- h = self._cached_hash = hash(tuple(sorted(self.iteritems())))
++ h = self._cached_hash = hash(tuple(sorted(self.items())))
+ return h
+
+ def __repr__(self):
+@@ -142,23 +210,25 @@ class frozendict(dict):
+ dot_keywords = ['graph', 'subgraph', 'digraph', 'node', 'edge', 'strict']
+
+ id_re_alpha_nums = re.compile('^[_a-zA-Z][a-zA-Z0-9_,]*$', re.UNICODE)
+-id_re_alpha_nums_with_ports = re.compile('^[_a-zA-Z][a-zA-Z0-9_,:\"]*[a-zA-Z0-9_,\"]+$', re.UNICODE)
++id_re_alpha_nums_with_ports = re.compile(
++ '^[_a-zA-Z][a-zA-Z0-9_,:\"]*[a-zA-Z0-9_,\"]+$', re.UNICODE
++ )
+ id_re_num = re.compile('^[0-9,]+$', re.UNICODE)
+ id_re_with_port = re.compile('^([^:]*):([^:]*)$', re.UNICODE)
+-id_re_dbl_quoted = re.compile('^\".*\"$', re.S|re.UNICODE)
+-id_re_html = re.compile('^<.*>$', re.S|re.UNICODE)
++id_re_dbl_quoted = re.compile('^\".*\"$', re.S | re.UNICODE)
++id_re_html = re.compile('^<.*>$', re.S | re.UNICODE)
... 2543 lines suppressed ...
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/python-modules/packages/pydot.git
More information about the Python-modules-commits
mailing list