text: """Pylama's shell support."""
  
  import sys
  import warnings
  from json import dumps
  from os import path as op
  from os import walk
  from pathlib import Path
  from typing import List, Optional
  
  from .check_async import check_async
  from .config import CURDIR, Namespace, parse_options, setup_logger
  from .core import LOGGER, run
  from .errors import Error
  from .utils import read_stdin
  
  DEFAULT_FORMAT = "{filename}:{lnum}:{col} [{etype}] {number} {message} [{source}]"
  MESSAGE_FORMATS = {
      "pylint": "{filename}:{lnum}: [{etype}] {number} {message} [{source}]",
      "pycodestyle": "{filename}:{lnum}:{col} {number} {message} [{source}]",
      "parsable": DEFAULT_FORMAT,
  }
  
  
  def check_paths(
      paths: Optional[List[str]],
      options: Namespace,
      code: str = None,
      rootdir: Path = None,
  ) -> List[Error]:
      """Check the given paths.
  
      :param rootdir: Root directory (for making relative file paths)
      :param options: Parsed pylama options (from pylama.config.parse_options)
      """
      paths = paths or options.paths
      if not paths:
          return []
  
      if code is None:
          candidates = []
          for path in paths or options.paths:
              if not op.exists(path):
                  continue
  
              if not op.isdir(path):
                  candidates.append(op.abspath(path))
  
              for root, _, files in walk(path):
                  candidates += [op.relpath(op.join(root, f), CURDIR) for f in files]
      else:
          candidates = [paths[0]]
  
      if not candidates:
          return []
  
      if rootdir is None:
          path = candidates[0]
          rootdir = Path(path if op.isdir(path) else op.dirname(path))
  
      candidates = [path for path in candidates if path.endswith(".py")]
  
      if options.concurrent:
          return check_async(candidates, code=code, options=options, rootdir=rootdir)
  
      errors = []
      for path in candidates:
          errors += run(path=path, code=code, rootdir=rootdir, options=options)
  
      return errors
  
  
  def check_path(
      options: Namespace,
      rootdir: str = None,
      candidates: List[str] = None,
      code: str = None,  # noqa
  ) -> List[Error]:
      """Support legacy code."""
      warnings.warn(
          "pylama.main.check_path is depricated and will be removed in pylama 9",
          DeprecationWarning,
      )
      return check_paths(
          candidates,
          code=code,
          options=options,
          rootdir=rootdir and Path(rootdir) or None,
      )
  
  
  def shell(args: List[str] = None, error: bool = True):
      """Endpoint for console.
  
      Parse a command arguments, configuration files and run a checkers.
      """
      if args is None:
          args = sys.argv[1:]
  
      options = parse_options(args)
      setup_logger(options)
      LOGGER.info(options)
  
      # Install VSC hook
      if options.hook:
          from .hook import install_hook  # noqa
  
          for path in options.paths:
              return install_hook(path)
  
      if options.from_stdin and not options.paths:
          LOGGER.error("--from-stdin requires a filename")
          return sys.exit(1)
  
      errors = check_paths(
          options.paths,
          code=read_stdin() if options.from_stdin else None,
          options=options,
          rootdir=CURDIR,
      )
      display_errors(errors, options)
  
      if error:
          sys.exit(int(bool(errors)))
  
      return errors
  
  
  def display_errors(errors: List[Error], options: Namespace):
      """Format and display the given errors."""
      if options.format == "json":
          LOGGER.warning(dumps([err.to_dict() for err in errors]))
  
      else:
          pattern = MESSAGE_FORMATS.get(options.format, DEFAULT_FORMAT)
          for err in errors:
              LOGGER.warning(err.format(pattern))
  
  
  if __name__ == "__main__":
      shell()
  
  # pylama:ignore=F0001
  