NAME

       pyreverse - parse python sources files and extract diagrams from them.

SYNOPSIS

       pyreverse [options] <modules>

DESCRIPTION

       pyreverse is a python source analyzer. It parses python packages and produces UML diagrams
       in different output formats.  (dot,  all  formats  available  for  dot,  and  vcg).   With
       different  options,  you  can  have  fine  tuning  on  what  and  how modules, classes and
       attributes will be shown in the diagram.  You can combine several modules in  one  project
       (except with -c ).

       If no -c and no --diadefs option specified, pyreverse will create
        - a diagram 'classes_<name>' for the classes in <modules> and
          ( if there is more than one module in <projects> )
        - a diagram 'packages_<name>' for the package dependencies in <modules>

       With   -c   <class>,   pyreverse   creates  a  diagram  for  that  <class>  with  filename
       <class>.<format>.  You can do -c <class1> , -c <class2>.

OPTIONS

       -h, --help
              show help message and exit

       -p<name>, --project=<name>
              set project name to <name> if not using -c option. (default:'No Name')

       --ignore=<file[,file...]>
              add files or directories to the blacklist. They should be base  names,  not  paths.
              [current: CVS]

       -f<mode>, --filter-mode=<mode>
              filter  attributes  and  functions according to <mode>. You can combine modes using
              '+' like 'SPECIAL+OTHER'. Correct modes are :
               - 'PUB_ONLY' : filter all non public attributes (default)
               - 'ALL' : no filter
               - 'SPECIAL' : filter Python special functions except constructor
               - 'OTHER' : filter protected and private attributes [current: PUB_ONLY]

       -d<file>, --diadefs=<file>
              create diagram according to the diagram definitions in <file>

       -c <class>, --class=<class>
              create a class diagram with all classes related to  <class>   [current:  none]  the
              class  must  be  in the file <modules>. By default, this will include all ancestors
              and associated classes of <class> and include module names (i.e. '-ASmy' ).

       -a <ancestor>, --show-ancestors=<ancestor>
              show <ancestor> generations of ancestor classes not in <projects>

       -A, --all-ancestors=[yn]
              show all ancestors off all classes in <projects> [current: none]

       -s <ass_level>, --show-associated=<associated>
              show <ass_level> associated classes. <ass_level>=1 will only take classes  directly
              related  to  the  classes   in the project,  while <ass_level>=2 will also take all
              classes related to those fetched by<depth>=1.

       -S, --all-associated=[yn]
              show recursively all associated off all associated classes [current: none]

       -b, --builtin
              include builtin objects in representation of classes [current: False]

       -m [yn], --module-names=[yn]
              include module name in representation of classes. This will include the full module
              path in the class name. [current: none]

       -k, --only-classnames
              don't  show  attributes  and  methods  in  the class boxes; this disables -f values
              [current: False]

       -o <format>, --output=<format>
              create a *.<format> output file if format  available.  Available  formats  are  all
              formats that dot can produce and vcg.  [default: dot]

EXAMPLES

       Here are some examples for command line options:

       pyreverse <project> -a1 -s1 -m

              -a1  -s1  will  include one level of ancestor and associated classes in the diagram
              of the <project> modules, while -m will show the full module path  of  each  class.
              You  can  use  the  -a,  -s,  -A,  -S  options in the same way.  Note that on class
              diagrams (using -c ) -a and -s will rather reduce than enlarge your diagram.

       pyreverse mod/foo.py mod/fee.py -k

              This is interesting if the diagram for <project>=mod is too  complicated:  you  can
              show  only  the class names (no attributes or methods, option -k); or take only the
              modules you are interested in (here fee.py and foo.py).

REQUIRES

       Python

SEE ALSO

       dot(1), pylint(1)

       http://www.logilab.org/pyreverse

AUTHORS

       Sylvain Thenault, Emile Anclin

       This manpage was written by Emile Anclin <emile.anclin@logilab.fr>