docs: def clone(self, forced_version_date=None, in_bulk=False):
          """
          Clones a Versionable and returns a fresh copy of the original object.
          Original source: ClonableMixin snippet
          (http://djangosnippets.org/snippets/1271), with the pk/id change
          suggested in the comments
  
          :param forced_version_date: a timestamp including tzinfo; this value
              is usually set only internally!
          :param in_bulk: whether not to write this objects to the database
              already, if not necessary; this value is usually set only
              internally for performance optimization
          :return: returns a fresh clone of the original object
              (with adjusted relations)
          """
          if not self.pk:
              raise ValueError('Instance must be saved before it can be cloned')
  
          if self.version_end_date:
              raise ValueError(
                  'This is a historical item and can not be cloned.')
  
          if forced_version_date:
              if not self.version_start_date <= forced_version_date <= \
                      get_utc_now():
                  raise ValueError(
                      'The clone date must be between the version start date '
                      'and now.')
          else:
              forced_version_date = get_utc_now()
  
          if self.get_deferred_fields():
              # It would be necessary to fetch the record from the database
              # again for this to succeed.
              # Alternatively, perhaps it would be possible to create a copy of
              # the object after fetching the missing fields.
              # Doing so may be unexpected by the calling code, so raise an
              # exception: the calling code should be adapted if necessary.
              raise ValueError(
                  'Can not clone a model instance that has deferred fields')
  
          earlier_version = self
  
          later_version = copy.copy(earlier_version)
          later_version.version_end_date = None
          later_version.version_start_date = forced_version_date
  
          # set earlier_version's ID to a new UUID so the clone (later_version)
          # can get the old one -- this allows 'head' to always have the original
          # id allowing us to get at all historic foreign key relationships
          earlier_version.id = self.uuid()
          earlier_version.version_end_date = forced_version_date
  
          if not in_bulk:
              # This condition might save us a lot of database queries if we are
              # being called from a loop like in .clone_relations
              earlier_version.save()
              later_version.save()
          else:
              earlier_version._not_created = True
  
          # re-create ManyToMany relations
          for field_name in self.get_all_m2m_field_names():
              earlier_version.clone_relations(later_version, field_name,
                                              forced_version_date)
  
          return later_version