docs: def execute(self):
          """
          Given the command-line arguments, this creates a parser appropriate
          to that command, and runs it.
          """
  
          # retrieve default language from system environment
          default_locale = os.environ.get('LANG', 'en_US').split('.')[0]
          if default_locale not in AVAILABLE_LOCALES:
              default_locale = DEFAULT_LOCALE
  
          epilog = """supported locales:
  
    {0}
  
    Faker can take a locale as an optional argument, to return localized data. If
    no locale argument is specified, the factory falls back to the user's OS
    locale as long as it is supported by at least one of the providers.
       - for this user, the default locale is {1}.
  
    If the optional argument locale and/or user's default locale is not available
    for the specified provider, the factory falls back to faker's default locale,
    which is {2}.
  
  examples:
  
    $ faker address
    968 Bahringer Garden Apt. 722
    Kristinaland, NJ 09890
  
    $ faker -l de_DE address
    Samira-Niemeier-Allee 56
    94812 Biedenkopf
  
    $ faker profile ssn,birthdate
    {{'ssn': u'628-10-1085', 'birthdate': '2008-03-29'}}
  
    $ faker -r=3 -s=";" name
    Willam Kertzmann;
    Josiah Maggio;
    Gayla Schmitt;
  
  """.format(', '.join(sorted(AVAILABLE_LOCALES)),
             default_locale,
             DEFAULT_LOCALE)
  
          formatter_class = argparse.RawDescriptionHelpFormatter
          parser = argparse.ArgumentParser(
              prog=self.prog_name,
              description='{0} version {1}'.format(self.prog_name, VERSION),
              epilog=epilog,
              formatter_class=formatter_class)
  
          parser.add_argument("--version", action="version",
                              version="%(prog)s {0}".format(VERSION))
  
          parser.add_argument('-v',
                              '--verbose',
                              action='store_true',
                              help="show INFO logging events instead "
                              "of CRITICAL, which is the default. These logging "
                              "events provide insight into localization of "
                              "specific providers.")
  
          parser.add_argument('-o', metavar="output",
                              type=argparse.FileType('w'),
                              default=sys.stdout,
                              help="redirect output to a file")
  
          parser.add_argument('-l', '--lang',
                              choices=AVAILABLE_LOCALES,
                              default=default_locale,
                              metavar='LOCALE',
                              help="specify the language for a localized "
                              "provider (e.g. de_DE)")
          parser.add_argument('-r', '--repeat',
                              default=1,
                              type=int,
                              help="generate the specified number of outputs")
          parser.add_argument('-s', '--sep',
                              default='\n',
                              help="use the specified separator after each "
                              "output")
  
          parser.add_argument('--seed', metavar='SEED',
                              type=int,
                              help="specify a seed for the random generator so "
                              "that results are repeatable. Also compatible "
                              "with 'repeat' option")
  
          parser.add_argument('-i',
                              '--include',
                              default=META_PROVIDERS_MODULES,
                              nargs='*',
                              help="list of additional custom providers to "
                              "user, given as the import path of the module "
                              "containing your Provider class (not the provider "
                              "class itself)")
  
          parser.add_argument('fake',
                              action='store',
                              nargs='?',
                              help="name of the fake to generate output for "
                                   "(e.g. profile)")
  
          parser.add_argument('fake_args',
                              metavar="fake argument",
                              action='store',
                              nargs='*',
                              help="optional arguments to pass to the fake "
                                   "(e.g. the profile fake takes an optional "
                                   "list of comma separated field names as the "
                                   "first argument)")
  
          arguments = parser.parse_args(self.argv[1:])
  
          if arguments.verbose:
              logging.basicConfig(level=logging.DEBUG)
          else:
              logging.basicConfig(level=logging.CRITICAL)
  
          random.seed(arguments.seed)
          seeds = random.sample(range(arguments.repeat*10), arguments.repeat)
  
          for i in range(arguments.repeat):
  
              print_doc(arguments.fake,
                        arguments.fake_args,
                        lang=arguments.lang,
                        output=arguments.o,
                        seed=seeds[i],
                        includes=arguments.include,
                        )
              print(arguments.sep, file=arguments.o)
  
              if not arguments.fake:
                  # repeat not supported for all docs
                  break