refbrowser.py (7914B)

---

 #Embedded file name: C:\BuildAgent\work\20d73f1b24eed06e\eve\release\V24.01\packages\pympler\refbrowser.py
 from __future__ import print_function
 import gc
 import inspect
 import sys
 from pympler import muppy
 from pympler import summary
 from pympler.util.compat import tkinter
 
 class _Node(object):
 
     def __init__(self, o, str_func = None):
         self.o = o
         self.children = []
         self.str_func = str_func
 
     def __str__(self):
         if self.str_func is not None:
             return self.str_func(self.o)
         else:
             return str(self.o)
 
 
 class RefBrowser(object):
 
     def __init__(self, rootobject, maxdepth = 3, str_func = summary._repr, repeat = True, stream = None):
         self.root = rootobject
         self.maxdepth = maxdepth
         self.str_func = str_func
         self.repeat = repeat
         self.stream = stream
         self.ignore = []
         self.already_included = set()
         self.ignore.append(self.already_included)
 
     def get_tree(self):
         self.ignore.append(inspect.currentframe())
         return self._get_tree(self.root, self.maxdepth)
 
     def _get_tree(self, root, maxdepth):
         objects = gc.get_referrers(root)
         res = _Node(root, self.str_func)
         self.already_included.add(id(root))
         if maxdepth == 0:
             return res
         self.ignore.append(inspect.currentframe())
         self.ignore.append(objects)
         for o in objects:
             if isinstance(o, dict):
                 if any((isinstance(ref, (_Node, RefBrowser)) for ref in gc.get_referrers(o))):
                     continue
             _id = id(o)
             if not self.repeat and _id in self.already_included:
                 s = self.str_func(o)
                 res.children.append('%s (already included, id %s)' % (s, _id))
                 continue
             if not isinstance(o, _Node) and o not in self.ignore:
                 res.children.append(self._get_tree(o, maxdepth - 1))
 
         return res
 
 
 class StreamBrowser(RefBrowser):
     hline = '-'
     vline = '|'
     cross = '+'
     space = ' '
 
     def print_tree(self, tree = None):
         if tree is None:
             tree = self.get_tree()
         self._print(tree, '', '')
 
     def _print(self, tree, prefix, carryon):
         level = prefix.count(self.cross) + prefix.count(self.vline)
         len_children = 0
         if isinstance(tree, _Node):
             len_children = len(tree.children)
         prefix += str(tree)
         carryon += self.space * len(str(tree))
         if level == self.maxdepth or not isinstance(tree, _Node) or len_children == 0:
             self.stream.write(prefix + '\n')
             return
         prefix += self.hline
         carryon += self.space
         if len(tree.children) > 1:
             prefix += self.cross
             carryon += self.vline
         prefix += self.hline
         carryon += self.space
         if len_children > 0:
             self._print(tree.children[0], prefix, carryon)
             for b in range(1, len_children):
                 prefix = carryon[:-2] + self.cross + self.hline
                 if b == len_children - 1:
                     carryon = carryon[:-2] + 2 * self.space
                 self._print(tree.children[b], prefix, carryon)
                 if b == len_children - 1:
                     if len(carryon.strip(' ')) == 0:
                         return
                     self.stream.write(carryon[:-2].rstrip() + '\n')
 
 
 class ConsoleBrowser(StreamBrowser):
 
     def __init__(self, *args, **kwargs):
         super(ConsoleBrowser, self).__init__(*args, **kwargs)
         if not self.stream:
             self.stream = sys.stdout
 
 
 class FileBrowser(StreamBrowser):
 
     def print_tree(self, filename, tree = None):
         old_stream = self.stream
         self.stream = open(filename, 'w')
         try:
             super(FileBrowser, self).print_tree(tree=tree)
         finally:
             self.stream.close()
             self.stream = old_stream
 
 
 try:
     from idlelib import TreeWidget as _TreeWidget
 
     class _TreeNode(_TreeWidget.TreeNode):
 
         def reload_referrers(self):
             self.item.node = self.item.reftree._get_tree(self.item.node.o, 1)
             self.item._clear_children()
             self.expand()
             self.update()
 
         def print_object(self):
             print(self.item.node.o)
 
         def drawtext(self):
             _TreeWidget.TreeNode.drawtext(self)
             menu = tkinter.Menu(self.canvas, tearoff=0)
             menu.add_command(label='reload referrers', command=self.reload_referrers)
             menu.add_command(label='print', command=self.print_object)
             menu.add_separator()
             menu.add_command(label='expand', command=self.expand)
             menu.add_separator()
             menu.add_command(label='Close Popup Menu')
 
             def do_popup(event):
                 menu.post(event.x_root, event.y_root)
 
             self.label.bind('<Button-3>', do_popup)
 
             def edit(self, event = None):
                 pass
 
             def edit_finish(self, event = None):
                 pass
 
             def edit_cancel(self, event = None):
                 pass
 
 
     class _ReferrerTreeItem(_TreeWidget.TreeItem, tkinter.Label):
 
         def __init__(self, parentwindow, node, reftree):
             _TreeWidget.TreeItem.__init__(self)
             tkinter.Label.__init__(self, parentwindow)
             self.node = node
             self.parentwindow = parentwindow
             self.reftree = reftree
 
         def _clear_children(self):
             new_children = []
             for child in self.node.children:
                 if not isinstance(child, _TreeNode):
                     new_children.append(child)
 
             self.node.children = new_children
 
         def GetText(self):
             return str(self.node)
 
         def GetIconName(self):
             if not self.IsExpandable():
                 return 'python'
 
         def IsExpandable(self):
             if not isinstance(self.node, _Node):
                 return False
             elif len(self.node.children) > 0:
                 return True
             else:
                 return muppy._is_containerobject(self.node.o)
 
         def GetSubList(self):
             sublist = []
             children = self.node.children
             if len(children) == 0 and muppy._is_containerobject(self.node.o):
                 self.node = self.reftree._get_tree(self.node.o, 1)
                 self._clear_children()
                 children = self.node.children
             for child in children:
                 item = _ReferrerTreeItem(self.parentwindow, child, self.reftree)
                 sublist.append(item)
 
             return sublist
 
 
 except ImportError:
     _TreeWidget = None
 
 def gui_default_str_function(o):
     return summary._repr(o) + '(id=%s)' % id(o)
 
 
 class InteractiveBrowser(RefBrowser):
 
     def __init__(self, rootobject, maxdepth = 3, str_func = gui_default_str_function, repeat = True):
         if tkinter is None:
             raise ImportError('InteractiveBrowser requires Tkinter to be installed.')
         RefBrowser.__init__(self, rootobject, maxdepth, str_func, repeat)
 
     def main(self, standalone = False):
         window = tkinter.Tk()
         sc = _TreeWidget.ScrolledCanvas(window, bg='white', highlightthickness=0, takefocus=1)
         sc.frame.pack(expand=1, fill='both')
         item = _ReferrerTreeItem(window, self.get_tree(), self)
         node = _TreeNode(sc.canvas, None, item)
         node.expand()
         if standalone:
             window.mainloop()
 
 
 superlist = []
 root = 'root'
 for i in range(3):
     tmp = [root]
     superlist.append(tmp)
 
 def foo(o):
     return str(type(o))
 
 
 def print_sample():
     cb = ConsoleBrowser(root, str_func=foo)
     cb.print_tree()
 
 
 def write_sample():
     fb = FileBrowser(root, str_func=foo)
     fb.print_tree('sample.txt')
 
 
 if __name__ == '__main__':
     write_sample()