[Python-modules-commits] [pydot] 04/13: merge patched into master
Sandro Tosi
morph at moszumanska.debian.org
Sun Jan 10 02:07:29 UTC 2016
This is an automated email from the git hooks/post-receive script.
morph pushed a commit to branch master
in repository pydot.
commit 999de2e6c5dfa65d373139e95aeb3242c41f9280
Merge: 3d52c86 18d7078
Author: Sandro Tosi <morph at debian.org>
Date: Sun Jan 10 00:25:49 2016 +0000
merge patched into master
debian/.git-dpm | 4 +-
debian/patches/0002-support-python3.patch | 3471 +++++++++++++++++++++++++++++
debian/patches/series | 1 +
dot_parser.py | 429 ++--
pydot.py | 1553 +++++++------
5 files changed, 4427 insertions(+), 1031 deletions(-)
diff --cc debian/.git-dpm
index 2ff81bf,0000000..5241a47
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
- 9082aad68503a6589f24cda3f9bfa9bd9834a476
- a9ef0a090ba73420f11746a7fc4791b77b8f91c5
++18d707883c9fe62d343f9f8590966af8b4e95339
++18d707883c9fe62d343f9f8590966af8b4e95339
+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/0002-support-python3.patch
index 0000000,0000000..2cacd45
new file mode 100644
--- /dev/null
+++ b/debian/patches/0002-support-python3.patch
@@@ -1,0 -1,0 +1,3471 @@@
++From 18d707883c9fe62d343f9f8590966af8b4e95339 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
++
++---
++ dot_parser.py | 429 ++++++++--------
++ pydot.py | 1553 +++++++++++++++++++++++++++------------------------------
++ 2 files changed, 953 insertions(+), 1029 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)
++
++
++-def needs_quotes( s ):
+++def needs_quotes(s):
++ """Checks whether a string is a dot language ID.
++-
+++
... 2518 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