code: def run(
      target,
      target_type,
      tags=None,
      ruleset_name=None,
      ruleset_file=None,
      ruleset=None,
      logging_level=logging.WARNING,
      checks_paths=None,
      pull=None,
      insecure=False,
      skips=None,
      timeout=None,
  ):
      
      _set_logging(level=logging_level)
      logger.debug("Checking started.")
      target = Target.get_instance(
          target=target,
          logging_level=logging_level,
          pull=pull,
          target_type=target_type,
          insecure=insecure,
      )
      checks_to_run = _get_checks(
          target_type=target.__class__,
          tags=tags,
          ruleset_name=ruleset_name,
          ruleset_file=ruleset_file,
          ruleset=ruleset,
          checks_paths=checks_paths,
          skips=skips,
      )
      result = go_through_checks(target=target, checks=checks_to_run, timeout=timeout)
      return result
docs: Runs the sanity checks for the target.
  
      :param timeout: timeout per-check (in seconds)
      :param skips: name of checks to skip
      :param target: str (image name, ostree or dockertar)
                      or ImageTarget
                      or path/file-like object for dockerfile
      :param target_type: string, either image, dockerfile, dockertar
      :param tags: list of str (if not None, the checks will be filtered by tags.)
      :param ruleset_name: str (e.g. fedora; if None, default would be used)
      :param ruleset_file: fileobj instance holding ruleset configuration
      :param ruleset: dict, content of a ruleset file
      :param logging_level: logging level (default logging.WARNING)
      :param checks_paths: list of str, directories where the checks are present
      :param pull: bool, pull the image from registry
      :param insecure: bool, pull from an insecure registry (HTTP/invalid TLS)
      :return: Results instance