text: # coding=utf-8
  
  from __future__ import unicode_literals
  from __future__ import print_function
  
  import os
  import sys
  import argparse
  
  from faker import Faker, Factory, documentor
  from faker import VERSION
  from faker.config import AVAILABLE_LOCALES, DEFAULT_LOCALE, META_PROVIDERS_MODULES
  
  
  if sys.version < '3':
      text_type = unicode
      binary_type = str
  else:
      text_type = str
      binary_type = bytes
  
  
  __author__ = 'joke2k'
  
  
  def print_provider(doc, provider, formatters, excludes=None, output=None):
      output = output or sys.stdout
      if excludes is None:
          excludes = []
  
      print(file=output)
      print("### {0}".format(
            doc.get_provider_name(provider)), file=output)
      print(file=output)
  
      for signature, example in formatters.items():
          if signature in excludes:
              continue
          try:
              lines = text_type(example).expandtabs().splitlines()
          except UnicodeDecodeError:
              # The example is actually made of bytes.
              # We could coerce to bytes, but that would fail anyway when we wiil
              # try to `print` the line.
              lines = ["<bytes>"]
          except UnicodeEncodeError:
              raise Exception('error on "{0}" with value "{1}"'.format(
                              signature, example))
          margin = max(30, doc.max_name_len+1)
          remains = 150 - margin
          separator = '#'
          for line in lines:
              for i in range(0, (len(line) // remains) + 1):
                  print("\t{fake:<{margin}}{separator} {example}".format(
                      fake=signature,
                      separator=separator,
                      example=line[i*remains:(i+1)*remains],
                      margin=margin
                  ), file=output)
                  signature = separator = ' '
  
  
  def print_doc(provider_or_field=None,
                args=None, lang=DEFAULT_LOCALE, output=None, includes=None):
      args = args or []
      output = output or sys.stdout
      fake = Faker(locale=lang, includes=includes)
  
      from faker.providers import BaseProvider
      base_provider_formatters = [f for f in dir(BaseProvider)]
  
      if provider_or_field:
          if '.' in provider_or_field:
              parts = provider_or_field.split('.')
              locale = parts[-2] if parts[-2] in AVAILABLE_LOCALES else lang
              fake = Factory.create(locale, providers=[provider_or_field], includes=includes)
              doc = documentor.Documentor(fake)
              doc.already_generated = base_provider_formatters
              print_provider(
                  doc,
                  fake.get_providers()[0],
                  doc.get_provider_formatters(fake.get_providers()[0]),
                  output=output)
          else:
              try:
                  print(fake.format(provider_or_field, *args), end='', file=output)
              except AttributeError:
                  raise ValueError('No faker found for "{0}({1})"'.format(
                      provider_or_field, args))
  
      else:
          doc = documentor.Documentor(fake)
  
          formatters = doc.get_formatters(with_args=True, with_defaults=True)
  
          for provider, fakers in formatters:
  
              print_provider(doc, provider, fakers, output=output)
  
          for language in AVAILABLE_LOCALES:
              if language == lang:
                  continue
              print(file=output)
              print('## LANGUAGE {0}'.format(language), file=output)
              fake = Faker(locale=language)
              d = documentor.Documentor(fake)
  
              for p, fs in d.get_formatters(with_args=True, with_defaults=True,
                                            locale=language,
                                            excludes=base_provider_formatters):
                  print_provider(d, p, fs, output=output)
  
  
  class Command(object):
  
      def __init__(self, argv=None):
          self.argv = argv or sys.argv[:]
          self.prog_name = os.path.basename(self.argv[0])
  
      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
  
          formatter_class = argparse.RawDescriptionHelpFormatter
          parser = argparse.ArgumentParser(
              prog=self.prog_name,
              description='{0} version {1}'.format(self.prog_name, VERSION),
              formatter_class=formatter_class)
  
          parser.add_argument("--version", action="version",
                              version="%(prog)s {0}".format(VERSION))
  
          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,
                              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('-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:])
  
          for i in range(arguments.repeat):
  
              print_doc(arguments.fake,
                        arguments.fake_args,
                        lang=arguments.lang,
                        output=arguments.o,
                        includes=arguments.include
                        )
              print(arguments.sep, file=arguments.o)
  
              if not arguments.fake:
                  # repeat not supported for all docs
                  break
  
  
  def execute_from_command_line(argv=None):
      """A simple method that runs a Command."""
      if sys.stdout.encoding is None:
          print('please set python env PYTHONIOENCODING=UTF-8, example: '
                'export PYTHONIOENCODING=UTF-8, when writing to stdout',
                file=sys.stderr)
          exit(1)
  
      command = Command(argv)
      command.execute()
  