code: def make_variant_multiple_calls(
      chrom="chr1",
      start=10,
      alleles=None,
      end=None,
      filters=None,
      qual=None,
      gts=None,
      gqs=None,
      sample_names=None,
      glss=None,
      is_phased=None,
      ad=None,
  ):
      """Creates a new Variant proto from args that contains multi-sample calls.
  
      Args:
        chrom: str. The reference_name for this variant.
        start: int. The starting position of this variant.
        alleles: list of str with at least one element. alleles[0] is the reference
          bases and alleles[1:] will be set to alternate_bases of variant. If None,
            defaults to ['A', 'C'].
        end: int or None. If not None, the variant's end will be set to this value.
          If None, will be set to the start + len(reference_bases).
        filters: str, list of str, or None. Sets the filters field of the variant to
          this value if not None. If filters is a string `value`, this is equivalent
          to an argument [`value`]. If None, no value will be assigned to the
          filters field.
        qual: int or None. The quality score for this variant. If None, no quality
          score will be written in the Variant.
        gts: A list of lists of ints. For each list in this list, creates a
          VariantCall in Variant with genotype field set to this value.
        gqs: A list of ints or None. Must match the gts arg if specified. Sets the
          GQ value of corresponding VariantCall.
        sample_names: A list of strs or None. Must match the gts arg if specified.
          Sets the call_set_name of the corresponding VariantCall.
        glss: A list of array-lists of float, or None. Must match the gts arg if
          specified. Sets the genotype_likelihoods of the corresponding VariantCall.
        is_phased: list of bools. Must match the gts arg if specified. Indicates
          whether the corresponding VariantCall should be phased.
        ad: list of allelic depths. These are added together to calculate DP.
  
      Returns:
        nucleus.genomics.v1.Variant proto.
      """
      if alleles is None:
          alleles = ["A", "C"]
  
      if not end:
          end = start + len(alleles[0])
  
      variant = variants_pb2.Variant(
          reference_name=chrom,
          start=start,
          end=end,
          reference_bases=alleles[0],
          alternate_bases=alleles[1:],
          quality=qual,
      )
  
      if filters is not None:
          if not isinstance(filters, (list, tuple)):
              filters = [filters]
          variant.filter[:] = filters
  
      if gts:
          for i in range(len(gts)):
              call = variant.calls.add(genotype=gts[i])
  
              if sample_names and sample_names[i] is not None:
                  call.call_set_name = sample_names[i]
  
              if gqs and gqs[i] is not None:
                  set_list_values(call.info["GQ"], [gqs[i]])
  
              if glss and glss[i] is not None:
                  call.genotype_likelihood.extend(glss[i])
  
              if is_phased and is_phased[i] is not None:
                  call.is_phased = is_phased[i]
  
              if ad and ad[i] is not None:
                  set_list_values(call.info["AD"], ad[i])
                  set_list_values(call.info["DP"], [sum(ad[i])])
  
      return variant
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import os
  from absl import flags
  from absl.testing import absltest
  from etils import epath
  import six
  from third_party.nucleus.protos import position_pb2
  from third_party.nucleus.protos import reads_pb2
  from third_party.nucleus.protos import struct_pb2
  from third_party.nucleus.protos import variants_pb2
  from third_party.nucleus.util import cigar
label_desc: Use image node_id 6 for calling a global function with example usage: make_variant_multiple_calls(chrom, start, alleles, end, filters, qual, gts, gqs, sample_names, glss, is_phased, ad) and returns: variant