Traversing through Dir()

[Alf P. Steinbach]

* Andrej Mitrovic:
> I would like to traverse through the entire structure of dir(), and
> write it to a file.
> 
> Now, if I try to write the contents of dir() to a file (via pickle), I
> only get the top layer. So even if there are lists within the returned
> list from dir(), they get written as a list of strings to the file.
> 
> Basically, I have an embedded and somewhat stripped version of Python.
> I would like to find out just how much functionality it has (I have no
> documentation for it), so I thought the best way to do that is
> traverse thru the dir() call. Any clues as to how I could write the
> whole structure to a file? I guess I'll need some kind of recursion
> here. :)

The built-in dir() function just produces a sequence of strings.

You can inspect the attributes via the getattr() function. The getattr() 
function produces a reference to an object (as does every expression). Problem: 
if you start with the number 42 and apply dir(), do getattr() on the first 
string, apply dir() on that object, and so on, with CPython you then get into an 
infinite recursion because those objects are produced on demand...


<code language="Py3">
obj = 42
obj_name = "42"
for n in range( 12 ):
     where = id( obj )
     t = type( obj ).__name__
     print( "{:>2} {:>10} {:20} of type '{}'".format( n, where, obj_name, t ) )
     attribute_names = dir( obj )
     obj_name = attribute_names[0]
     obj = getattr( obj, obj_name )
</code>


Similarly, if you do this with the Turtle module as starting point, with CPython 
you get into a different kind of infinite recursion because the chain of 
attributes so obtained is circular.


<code langauge="Py3">
import turtle

obj = turtle
obj_name = 'turtle'
for n in range( 12 ):
     where = id( obj )
     t = type( obj ).__name__
     print( "{:>2} {:>10} {:20} of type '{}'".format( n, where, obj_name, t ) )
     attribute_names = dir( obj )
     obj_name = attribute_names[0]
     obj = getattr( obj, obj_name )
</code>


It's not a clean, strict hierarchy of objects.

However, the basic idea is sound when you only want to obtain some limited, 
known information, such as e.g. short descriptions of all string methods, or a 
listing of the standard exception hierarchy.


<code language="Py3">
for attribute_name in dir( str ):
     if attribute_name.startswith( "_" ):
         pass
     else:
         attribute = getattr( str, attribute_name )
         doc_string = attribute.__doc__
         doc_lines = doc_string.splitlines()
         if len( doc_lines ) > 2:
             essential_doc = doc_lines[2]
         else:
             essential_doc = doc_lines[0]
         print( attribute_name.ljust( 15 ) + essential_doc )
</code>


<code language="Py3">
"Lists the standard exception class hierarchy with short descriptions."
import builtins
import inspect

indentation     = "." + 2*" "

def is_type( o ):
     # Could use inspect.isclass for this, but in the DIY spirit:
     return isinstance( o, type )

def beginning_of( s, max_chars ):
     return s[:max_chars]    # Not yet discussed, but doesn't matter.

def print_hierarchy( h, level ):
     for o in h:
         if isinstance( o, tuple ):
             # o is a tuple describing a class
             cls = o[0]
             doc_lines = cls.__doc__.splitlines()
             short_doc = beginning_of( doc_lines[0], 55 )
             print( "{:<34} {}".format(
                 level*indentation + cls.__name__, short_doc
                 ) )
         else:
             # o is a list array of subclasses
             print_hierarchy( o, level + 1 )

classes = []
for name in dir( builtins ):
     o = getattr( builtins, name )
     if is_type( o ):
         if issubclass( o, BaseException ):
             classes.append( o )

hierarchy = inspect.getclasstree( classes )
# 'hierarchy' is a list array of tuples and nested list arrays of the same form.
# The top level is an array of two items, the first item a tuple describing the 
'object'
# class, and the second item a list array representing the BaseException hierarchy.
print_hierarchy( hierarchy[1], level = 0 )
</code>


Cheers & hth.,

- Alf