libtbx.objgraph (version 1.1dev, 2008-09-05)
index
/net/chevy/raid1/nat/src/cctbx_project/libtbx/objgraph.py

Ad-hoc tools for drawing Python object reference graphs with graphviz.
 
This module is more useful as a repository of sample code and ideas, than
as a finished product.  For documentation and background, read
 
  http://mg.pov.lt/blog/hunting-python-memleaks.html
  http://mg.pov.lt/blog/python-object-graphs.html
  http://mg.pov.lt/blog/object-graphs-with-graphviz.html
 
in that order.  Then use pydoc to read the docstrings, as there were
improvements made since those blog posts.
 
Copyright (c) 2008 Marius Gedminas <marius@pov.lt>
 
Released under the MIT licence.
 
See also:
  http://www.lshift.net/blog/2008/11/14/tracing-python-memory-leaks
 
 
Changes
=======
 
1.1dev (2008-09-05)
-------------------
 
New function: show_refs() for showing forward references.
 
New functions: typestats() and show_most_common_types().
 
Object boxes are less crammed with useless information (such as IDs).
 
Spawns xdot if it is available.

 
Modules
       
gc
inspect
operator
os
types
weakref

 
Functions
       
at(addr)
Return an object at a given memory address.
 
The reverse of id(obj):
 
    >>> at(id(obj)) is obj
    True
 
Note that this function does not work on objects that are not tracked by
the GC (e.g. ints or strings).
by_type(typename)
Return objects tracked by the garbage collector with a given class name.
 
Example:
 
    >>> by_type('MyClass')
    [<mymodule.MyClass object at 0x...>]
 
Note that the GC does not track simple objects like int or str.
count(typename)
Count objects tracked by the garbage collector with a given class name.
 
Example:
 
    >>> count('dict')
    42
    >>> count('MyClass')
    3
 
Note that the GC does not track simple objects like int or str.
edge_label(source, target)
find_backref_chain(obj, predicate, max_depth=20, extra_ignore=())
Find a shortest chain of references leading to obj.
 
The start of the chain will be some object that matches your predicate.
 
``max_depth`` limits the search depth.
 
``extra_ignore`` can be a list of object IDs to exclude those objects from
your search.
 
Example:
 
    >>> find_backref_chain(obj, inspect.ismodule)
    [<module ...>, ..., obj]
 
Returns None if such a chain could not be found.
gradient(start_color, end_color, depth, max_depth)
obj_label(obj, depth)
obj_node_id(obj)
quote(s)
safe_repr(obj)
short_repr(obj)
show_backrefs(objs, max_depth=3, extra_ignore=(), filter=None, too_many=10, highlight=None)
Generate an object reference graph ending at ``objs``
 
The graph will show you what objects refer to ``objs``, directly and
indirectly.
 
``objs`` can be a single object, or it can be a list of objects.
 
Produces a Graphviz .dot file and spawns a viewer (xdot) if one is
installed, otherwise converts the graph to a .png image.
 
Use ``max_depth`` and ``too_many`` to limit the depth and breadth of the
graph.
 
Use ``filter`` (a predicate) and ``extra_ignore`` (a list of object IDs) to
remove undesired objects from the graph.
 
Use ``highlight`` (a predicate) to highlight certain graph nodes in blue.
 
Examples:
 
    >>> show_backrefs(obj)
    >>> show_backrefs([obj1, obj2])
    >>> show_backrefs(obj, max_depth=5)
    >>> show_backrefs(obj, filter=lambda x: not inspect.isclass(x))
    >>> show_backrefs(obj, highlight=inspect.isclass)
    >>> show_backrefs(obj, extra_ignore=[id(locals())])
show_graph(objs, edge_func, swap_source_target, max_depth=3, extra_ignore=(), filter=None, too_many=10, highlight=None)
show_most_common_types(limit=10, f=None)
Count the names of types with the most instances.
 
Note that the GC does not track simple objects like int or str.
 
Note that classes with the same name but defined in different modules
will be lumped together.
show_refs(objs, max_depth=3, extra_ignore=(), filter=None, too_many=10, highlight=None)
Generate an object reference graph starting at ``objs``
 
The graph will show you what objects are reachable from ``objs``, directly
and indirectly.
 
``objs`` can be a single object, or it can be a list of objects.
 
Produces a Graphviz .dot file and spawns a viewer (xdot) if one is
installed, otherwise converts the graph to a .png image.
 
Use ``max_depth`` and ``too_many`` to limit the depth and breadth of the
graph.
 
Use ``filter`` (a predicate) and ``extra_ignore`` (a list of object IDs) to
remove undesired objects from the graph.
 
Use ``highlight`` (a predicate) to highlight certain graph nodes in blue.
 
Examples:
 
    >>> show_refs(obj)
    >>> show_refs([obj1, obj2])
    >>> show_refs(obj, max_depth=5)
    >>> show_refs(obj, filter=lambda x: not inspect.isclass(x))
    >>> show_refs(obj, highlight=inspect.isclass)
    >>> show_refs(obj, extra_ignore=[id(locals())])
typestats()
Count the number of instances for each type tracked by the GC.
 
Note that the GC does not track simple objects like int or str.
 
Note that classes with the same name but defined in different modules
will be lumped together.

 
Data
        __author__ = 'Marius Gedminas (marius@gedmin.as)'
__copyright__ = 'Copyright (c) 2008 Marius Gedminas'
__date__ = '2008-09-05'
__license__ = 'MIT'
__version__ = '1.1dev'
division = _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

 
Author
        Marius Gedminas (marius@gedmin.as)