text: #!/usr/bin/env python
  """Module for Lexicon command-line interface"""
  from __future__ import absolute_import, print_function
  
  import json
  import logging
  import os
  import sys
  
  from lexicon.client import Client
  from lexicon.config import ConfigResolver
  from lexicon.parser import generate_cli_main_parser
  
  logger = logging.getLogger(__name__)
  
  
  def generate_list_table_result(lexicon_logger, output=None, without_header=None):
      """Convert returned data from list actions into a nice table for command line usage"""
      if not isinstance(output, list):
          lexicon_logger.debug(
              "Command output is not a list, and then cannot "
              "be printed with --quiet parameter not enabled."
          )
          return None
  
      array = [
          [
              row.get("id", ""),
              row.get("type", ""),
              row.get("name", ""),
              row.get("content", ""),
              row.get("ttl", ""),
          ]
          for row in output
      ]
  
      # Insert header (insert before calculating the max width of each column
      # to take headers size into account)
      if not without_header:
          headers = ["ID", "TYPE", "NAME", "CONTENT", "TTL"]
          array.insert(0, headers)
  
      column_widths = [0, 0, 0, 0, 0]
      # Find max width for each column
      for row in array:
          for idx, col in enumerate(row):
              width = len(str(col))
              if width > column_widths[idx]:
                  column_widths[idx] = width
  
      # Add a 'nice' separator
      if not without_header:
          array.insert(1, ["-" * column_widths[idx] for idx in range(len(column_widths))])
  
      # Construct table to be printed
      table = []
      for row in array:
          row_list = []
          for idx, col in enumerate(row):
              row_list.append(str(col).ljust(column_widths[idx]))
          table.append(" ".join(row_list))
  
      # Return table
      return os.linesep.join(table)
  
  
  def generate_table_results(output=None, without_header=None):
      """Convert returned data from non-list actions into a nice table for command line usage"""
      array = []
      str_output = str(output)
  
      if not without_header:
          array.append("RESULT")
          array.append("-" * max(6, len(str_output)))
  
      array.append(str_output)
      return os.linesep.join(array)
  
  
  def handle_output(results, output_type, action):
      """Print the relevant output for given output_type"""
      if output_type == "QUIET":
          return
  
      if not output_type == "JSON":
          if action == "list":
              table = generate_list_table_result(
                  logger, results, output_type == "TABLE-NO-HEADER"
              )
          else:
              table = generate_table_results(results, output_type == "TABLE-NO-HEADER")
          if table:
              print(table)
      else:
          try:
              json_str = json.dumps(results)
              if json_str:
                  print(json_str)
          except TypeError:
              logger.debug(
                  "Output is not JSON serializable, and then cannot "
                  "be printed with --output=JSON parameter."
              )
  
  
  def main():
      """Main function of Lexicon."""
      # Dynamically determine all the providers available and gather command line arguments.
      parsed_args = generate_cli_main_parser().parse_args()
  
      log_level = logging.getLevelName(parsed_args.log_level)
      logging.basicConfig(stream=sys.stdout, level=log_level, format="%(message)s")
      logger.debug("Arguments: %s", parsed_args)
  
      # In the CLI context, will get configuration interactively:
      #   * from the command line
      #   * from the environment variables
      #   * from lexicon configuration files found in given --config-dir (default is current dir)
      config = ConfigResolver()
      config.with_args(parsed_args).with_env().with_config_dir(parsed_args.config_dir)
  
      client = Client(config)
  
      results = client.execute()
  
      handle_output(results, parsed_args.output, config.resolve("lexicon:action"))
  
  
  if __name__ == "__main__":
      main()
  