docs: def run_account(account, region, policies_config, output_path,
                  cache_period, cache_path, metrics, dryrun, debug):
      """Execute a set of policies on an account.
      """
      logging.getLogger('custodian.output').setLevel(logging.ERROR + 1)
      CONN_CACHE.session = None
      CONN_CACHE.time = None
  
      # allow users to specify interpolated output paths
      if '{' not in output_path:
          output_path = os.path.join(output_path, account['name'], region)
  
      cache_path = os.path.join(cache_path, "%s-%s.cache" % (account['account_id'], region))
  
      config = Config.empty(
          region=region, cache=cache_path,
          cache_period=cache_period, dryrun=dryrun, output_dir=output_path,
          account_id=account['account_id'], metrics_enabled=metrics,
          log_group=None, profile=None, external_id=None)
  
      env_vars = account_tags(account)
  
      if account.get('role'):
          if isinstance(account['role'], six.string_types):
              config['assume_role'] = account['role']
              config['external_id'] = account.get('external_id')
          else:
              env_vars.update(
                  _get_env_creds(get_session(account, 'custodian', region), region))
  
      elif account.get('profile'):
          config['profile'] = account['profile']
  
      policies = PolicyCollection.from_data(policies_config, config)
      policy_counts = {}
      success = True
      st = time.time()
  
      with environ(**env_vars):
          for p in policies:
              # Variable expansion and non schema validation (not optional)
              p.expand_variables(p.get_variables(account.get('vars', {})))
              p.validate()
  
              log.debug(
                  "Running policy:%s account:%s region:%s",
                  p.name, account['name'], region)
              try:
                  resources = p.run()
                  policy_counts[p.name] = resources and len(resources) or 0
                  if not resources:
                      continue
                  log.info(
                      "Ran account:%s region:%s policy:%s matched:%d time:%0.2f",
                      account['name'], region, p.name, len(resources),
                      time.time() - st)
              except ClientError as e:
                  success = False
                  if e.response['Error']['Code'] == 'AccessDenied':
                      log.warning('Access denied account:%s region:%s',
                                  account['name'], region)
                      return policy_counts, success
                  log.error(
                      "Exception running policy:%s account:%s region:%s error:%s",
                      p.name, account['name'], region, e)
                  continue
              except Exception as e:
                  success = False
                  log.error(
                      "Exception running policy:%s account:%s region:%s error:%s",
                      p.name, account['name'], region, e)
                  if not debug:
                      continue
                  import traceback, pdb, sys
                  traceback.print_exc()
                  pdb.post_mortem(sys.exc_info()[-1])
                  raise
  
      return policy_counts, success