docs: def register_package(module=None, package=None, separator='.', ignore=[],
                       strict=True):
      """
      This is a helper function that takes the concept of Actionscript packages
      and registers all the classes in the supplied Python module under that
      package. It auto-aliased all classes in C{module} based on the parent
      C{package}.
  
      @param module: The Python module that will contain all the classes to
          auto alias.
      @type module: C{module} or C{dict}
      @param package: The base package name. e.g. 'com.example.app'. If this
          is C{None} then the value is inferred from C{module.__name__}.
      @type package: C{string} or C{None}
      @param separator: The separator used to append to C{package} to form the
          complete alias.
      @param ignore: To give fine grain control over what gets aliased and what
          doesn't, supply a list of classes that you B{do not} want to be aliased.
      @type ignore: C{iterable}
      @param strict: Whether only classes that originate from C{module} will be
          registered.
  
      @return: A dict of all the classes that were registered and their respective
          L{ClassAlias} counterparts.
      @since: 0.5
      @raise TypeError: Cannot get a list of classes from C{module}
      """
      if isinstance(module, python.str_types):
          if module == '':
              raise TypeError('Cannot get list of classes from %r' % (module,))
  
          package = module
          module = None
  
      if module is None:
          import inspect
  
          prev_frame = inspect.stack()[1][0]
          module = prev_frame.f_locals
  
      if type(module) is dict:
          has = lambda x: x in module
          get = module.__getitem__
      elif type(module) is list:
          has = lambda x: x in module
          get = module.__getitem__
          strict = False
      else:
          has = lambda x: hasattr(module, x)
          get = lambda x: getattr(module, x)
  
      if package is None:
          if has('__name__'):
              package = get('__name__')
          else:
              raise TypeError('Cannot get list of classes from %r' % (module,))
  
      if has('__all__'):
          keys = get('__all__')
      elif hasattr(module, '__dict__'):
          keys = module.__dict__.keys()
      elif hasattr(module, 'keys'):
          keys = module.keys()
      elif isinstance(module, list):
          keys = range(len(module))
      else:
          raise TypeError('Cannot get list of classes from %r' % (module,))
  
      def check_attr(attr):
          if not isinstance(attr, python.class_types):
              return False
  
          if attr.__name__ in ignore:
              return False
  
          try:
              if strict and attr.__module__ != get('__name__'):
                  return False
          except AttributeError:
              return False
  
          return True
  
      # gotta love python
      classes = filter(check_attr, [get(x) for x in keys])
  
      registered = {}
  
      for klass in classes:
          alias = '%s%s%s' % (package, separator, klass.__name__)
  
          registered[klass] = register_class(klass, alias)
  
      return registered