class StdNode:
indent = " "
truncate = 100
def __init__(self, data, parent=None, level=0):
self.ASN_id = encode(data['ASN_id'])
self.description = encode(data['description'])
self.children = UserDict()
self.level = level
for child in data['children']:
node = StdNode(child, self, self.level + 1)
self.children[node.ASN_id] = node
def prtln(self, s):
print '%s%s' % (self.level * self.indent, s)
def report(self):
description = self.description
if len(description) > self.truncate:
description = description[:self.truncate] + " ..."
if self.level == 0:
self.prtln('%s' % (description))
else:
self.prtln('%s (%s)' % (description, self.ASN_id))
# self.prtln (self.ASN_id)
for child in self.children.values():
child.report()
def test_dict_like_extract(self):
"""We should be able to use a dict-like object for choices, not only a
dict, and still get dict-like output.
"""
try:
from UserDict import UserDict
except ImportError:
from collections import UserDict
choices = UserDict({"aa": "bb", "a1": None})
search = "aaa"
result = process.extract(search, choices)
self.assertTrue(len(result) > 0)
for value, confidence, key in result:
self.assertTrue(value in choices.values())
def test_dict_like_extract(self):
"""We should be able to use a dict-like object for choices, not only a
dict, and still get dict-like output.
"""
try:
from UserDict import UserDict
except ImportError:
from collections import UserDict
choices = UserDict({'aa': 'bb', 'a1': None})
search = 'aaa'
result = process.extract(search, choices)
self.assertTrue(len(result) > 0)
for value, confidence, key in result:
self.assertTrue(value in choices.values())
class EadCollection(EadComponent):
"""
collection elements correspond to the "c02" level of the EAD document
"""
def __init__(self, element, parent):
EadComponent.__init__(self, element, parent)
self._items = UserDict()
self.boxes = UserDict()
for node in XmlUtils.selectNodes(element, "c03"):
self.add(EadItem(node, self))
def getItems(self):
return self._items.values()
def getBox(self, key):
if not self.boxes.has_key(key):
self.boxes[key] = Box()
return self.boxes[key]
def getFolder(self, box_key, folder_key):
if not self.boxes.has_key(box_key):
raise Exception, "box not found for %s" % box_key
box = self.boxes[box_key]
if not box.has_key(folder_key):
raise Exception, "folder not found in box %s for %s" % (box_key,
folder_key)
return box.getFolder(folder_key)
def add(self, item):
self._items[item.id] = item
box = self.getBox(item.box)
box.addItem(item)
def report(self):
EadComponent.report(self)
print "id: %s" % self.id
print "items: %d" % len(self._items)
u2a = u2.copy()
assert u2a == u2
class MyUserDict(UserDict):
def display(self): print self
m2 = MyUserDict(u2)
m2a = m2.copy()
assert m2a == m2
# Test keys, items, values
assert u2.keys() == d2.keys()
assert u2.items() == d2.items()
assert u2.values() == d2.values()
# Test has_key
for i in u2.keys():
assert u2.has_key(i) == 1
assert u1.has_key(i) == d1.has_key(i)
assert u0.has_key(i) == d0.has_key(i)
# Test update
t = UserDict()
t.update(u2)
assert t == u2
# Test get
def values(self):
self.__populate()
return UserDict.values( self )
def values(self):
self.__populate()
return UserDict.values( self )
class VdxRecord(MetaDataRecord):
verbose = 0
xpath_delimiter = '/'
# default_vdx_template = 'VDX-TEMPLATE.xml'
default_vdx_template = util.getTemplate('VDX-TEMPLATE')
def __init__(self, template=None):
template = template or self.default_vdx_template
MetaDataRecord.__init__(self, path=template)
self.shapes = UserDict()
self.edges = UserDict()
self.nodes = UserDict()
def getShapeNodes(self):
"""
return the shape elements from DOM
"""
return self.selectNodes(self.dom,
'VisioDocument/Pages/Page/Shapes/Shape')
def getShapeId(self):
return str(len(self.getShapeNodes()) + 1)
def _shapeGetter(self, shapeId):
return self.getShape(shapeId)
def getShapeByName(self, name):
# print 'getShapeByName (%s)' % name
for node in self.shapes.values():
if node.Name == name:
return node
def getShape(self, shapeId):
"""
return the Shape instance for provided shapeId or None if not defined
"""
return self.shapes.has_key(shapeId) and self.shapes[shapeId] or None
def makeEdgeShape(self, source, target, relation, id=None):
id = id or self.getShapeId()
# return makeConnectorShape(source, target, relation, self.getShapeId())
line_args = {
'name': 'connector',
'label': {
'text': relation
},
# 'x' : avg (start[0], end[0]),
# 'y' : avg (start[1], end[1]),
# 'x' : start[0],
# 'y' : start[1],
# 'height' : diff (end[1], start[1]) or util.pt2in(2),
# 'width' : diff (end[0],start[0]),
# 'begin_x' : start[0],
# 'begin_y' : start[1],
# 'end_x' : end[0],
# 'end_y' : end[1]
}
return Line(id, line_args)
def addEdge(self, sourceId, targetId, relation):
try:
# source = self.getShape(sourceId)
#source = self.getShapeByName(sourceId)
source = self._shapeGetter(sourceId)
if not source:
raise Exception, "sourceId '%s'" % sourceId
# target = self.getShape(targetId)
# target = self.getShapeByName(targetId)
target = self._shapeGetter(targetId)
if not target:
raise Exception, "targetId '%s'" % targetId
except Exception, msg:
print "addEdge Error: could not find a shape (%s)" % msg
# print self
print "SHAPE KEYS: %s" % self.shapes.keys()
for key in self.shapes.keys():
# print "%s: %s" % (key, self.shapes[key])
print " - ", key
print "HALTInG ..."
sys.exit()
# edge = makeConnectorShape(source, target, relation, self.getShapeId())
edge = self.makeEdgeShape(source, target, relation, self.getShapeId())
# parent = self.selectSingleNode (self.dom, 'VisioDocument/Pages/Page/Shapes')
# if not parent:
# raise xml.dom.NotFoundErr, 'Shapes node not found'
# parent.appendChild(edge.getElement());
self.edges[edge.ID] = edge
self.addShapeObj(edge)
# add the connect element
self.addConnect(edge, source, target)
return edge.ID
u2a = u2.copy()
verify(u2a == u2)
class MyUserDict(UserDict):
def display(self): print self
m2 = MyUserDict(u2)
m2a = m2.copy()
verify(m2a == m2)
# Test keys, items, values
verify(u2.keys() == d2.keys())
verify(u2.items() == d2.items())
verify(u2.values() == d2.values())
# Test has_key
for i in u2.keys():
verify(u2.has_key(i) == 1)
verify(u1.has_key(i) == d1.has_key(i))
verify(u0.has_key(i) == d0.has_key(i))
# Test update
t = UserDict()
t.update(u2)
verify(t == u2)
# Test get
