code: def sort(self):
          
          if self.sorted:
              return
  
          def key(variant):
              requested_key = []
              names = set()
  
              for i, request in enumerate(self.solver.request_list):
                  if not request.conflict:
                      req = variant.requires_list.get(request.name)
                      if req is not None:
                          requested_key.append((-i, req.range))
                          names.add(req.name)
  
              additional_key = []
              for request in variant.requires_list:
                  if not request.conflict and request.name not in names:
                      additional_key.append((request.range, request.name))
  
              if (VariantSelectMode[config.variant_select_mode] ==
                      VariantSelectMode.version_priority):
                  k = (requested_key,
                       -len(additional_key),
                       additional_key,
                       variant.index)
              else:  # VariantSelectMode.intersection_priority
                  k = (len(requested_key),
                       requested_key,
                       -len(additional_key),
                       additional_key,
                       variant.index)
  
              return k
  
          self.variants.sort(key=key, reverse=True)
          self.sorted = True
docs: Sort variants from most correct to consume, to least.
  
          Sort rules:
  
          version_priority:
          - sort by highest versions of packages shared with request;
          - THEN least number of additional packages added to solve;
          - THEN highest versions of additional packages;
          - THEN alphabetical on name of additional packages;
          - THEN variant index.
  
          intersection_priority:
          - sort by highest number of packages shared with request;
          - THEN sort according to version_priority
  
          Note:
              In theory 'variant.index' should never factor into the sort unless
              two variants are identical (which shouldn't happen) - this is just
              here as a safety measure so that sorting is guaranteed repeatable
              regardless.