code: def _serialize(self, version, serialize_format, context, raise_if_incomplete=False):
          
          values = context.copy()
          for k in version:
              values[k] = version[k]
  
          # TODO dump complete context on debug level
  
          try:
              # test whether all parts required in the format have values
              serialized = serialize_format.format(**values)
  
          except KeyError as e:
              missing_key = getattr(e, "message", e.args[0])
              raise MissingValueForSerializationException(
                  "Did not find key {} in {} when serializing version number".format(
                      repr(missing_key), repr(version)
                  )
              )
  
          keys_needing_representation = set()
          found_required = False
  
          for k in self.order():
              v = values[k]
  
              if not isinstance(v, VersionPart):
                  # values coming from environment variables don't need
                  # representation
                  continue
  
              if not v.is_optional():
                  found_required = True
                  keys_needing_representation.add(k)
              elif not found_required:
                  keys_needing_representation.add(k)
  
          required_by_format = set(self._labels_for_format(serialize_format))
  
          # try whether all parsed keys are represented
          if raise_if_incomplete:
              if not (keys_needing_representation <= required_by_format):
                  raise IncompleteVersionRepresentationException(
                      "Could not represent '{}' in format '{}'".format(
                          "', '".join(keys_needing_representation ^ required_by_format),
                          serialize_format,
                      )
                  )
  
          return serialized
docs: Attempts to serialize a version with the given serialization format.
  
          Raises MissingValueForSerializationException if not serializable