code: def is_variant_call(
      variant,
      require_non_ref_genotype=True,
      no_calls_are_variant=False,
      call_indices=None,
      apply_filter=True,
  ):
      """Is variant a non-reference call?
  
      A Variant proto doesn't always imply that there's a variant present in the
      genome. The call may not have alternate bases, may be filtered, may a have
      hom-ref genotype, etc. This function looks for all of those configurations
      and returns true iff the variant is asserting that a mutation is present
      in the same.
  
      Note that this code allows a variant without a calls field to be variant,
      but one with a genotype call must have a non-reference genotype to be
      considered variant (if require_non_ref_genotype is True, the default). If
      False, a variant that passes all of the site-level requirements for being
      a variant_call will return a True value, regardless of the genotypes, which
      means that we'll consider a site with a sample with a hom-ref or no-call site
      a variant call.
  
      Args:
        variant: nucleus.genomics.v1.Variant.
        require_non_ref_genotype: Should we require a site with a genotype call to
          have a non-reference (het, hom-var) genotype for the site to be considered
          a variant call?
        no_calls_are_variant: If a site has genotypes, should we consider no_call
          genotypes as being variant or not? e.g. -1/1 listed as ./. in VCF
        call_indices: A list of 0-based indices. If specified, only the calls
          at the given indices will be considered. The function will return
          True if any of those calls are variant.
        apply_filter: If set to True, will never treat this site as variant when
          any filter other than PASS or . is set.
  
      Returns:
        True if variant is really a mutation call.
      """
      if is_ref(variant):
          # No actual alt allele listed in ALT column
          return False
      elif apply_filter and is_filtered(variant):
          # Anything other than PASS or . in FILTER column
          return False
      elif not variant.calls or not require_non_ref_genotype:
          return True
      # All tests after this point should only look at genotype-based fields, as
      # we may have aborted out in the prev. line due to require_non_ref_genotype.
      else:
          # Check for non-ref genotypes and optionally no-call (-1) genotypes
          if call_indices is None:
              call_indices = range(len(variant.calls))
          for i in call_indices:
              for g in variant.calls[i].genotype:
                  if g > 0 or (no_calls_are_variant and g < 0):
                      return True
          return False
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import collections
  import enum
  import itertools
  import six
  from third_party.nucleus.protos import variants_pb2
  from third_party.nucleus.util import ranges
  from third_party.nucleus.util import variantcall_utils
  from third_party.nucleus.util import vcf_constants
label_desc: Use image node_id 27 for calling a global function with example usage: is_variant_call(variant, require_non_ref_genotype, no_calls_are_variant, call_indices, apply_filter) and returns: False, False, True, False, True