docs: def _find_calls(self, ast_tree, called_module, called_func):
          '''
          scan the abstract source tree looking for possible ways to call the called_module
          and called_func
  
          since -- 7-2-12 -- Jay
  
          example -- 
              # import the module a couple ways:
              import pout
              from pout import v
              from pout import v as voom
              import pout as poom
  
              # this function would return: ['pout.v', 'v', 'voom', 'poom.v']
  
          module finder might be useful someday
          link -- http://docs.python.org/library/modulefinder.html
          link -- http://stackoverflow.com/questions/2572582/return-a-list-of-imported-python-modules-used-in-a-script
  
          ast_tree -- _ast.* instance -- the internal ast object that is being checked, returned from compile()
              with ast.PyCF_ONLY_AST flag
          called_module -- string -- we are checking the ast for imports of this module
          called_func -- string -- we are checking the ast for aliases of this function
  
          return -- set -- the list of possible calls the ast_tree could make to call the called_func
          ''' 
          s = set()
  
          # always add the default call, the set will make sure there are no dupes...
          s.add("{}.{}".format(called_module, called_func))
  
          if hasattr(ast_tree, 'name'):
              if ast_tree.name == called_func:
                  # the function is defined in this module
                  s.add(called_func)
  
          if hasattr(ast_tree, 'body'):
              # further down the rabbit hole we go
              if isinstance(ast_tree.body, Iterable):
                  for ast_body in ast_tree.body:
                      s.update(self._find_calls(ast_body, called_module, called_func))
  
          elif hasattr(ast_tree, 'names'):
              # base case
              if hasattr(ast_tree, 'module'):
                  # we are in a from ... import ... statement
                  if ast_tree.module == called_module:
                      for ast_name in ast_tree.names:
                          if ast_name.name == called_func:
                              s.add(unicode(ast_name.asname if ast_name.asname is not None else ast_name.name))
  
              else:
                  # we are in a import ... statement
                  for ast_name in ast_tree.names:
                      if hasattr(ast_name, 'name') and (ast_name.name == called_module):
                          call = "{}.{}".format(
                              ast_name.asname if ast_name.asname is not None else ast_name.name,
                              called_func
                          )
                          s.add(call)
  
          return s