code: def _try_to_compute_deterministic_class_id(cls, depth=5):
      
      # Pickling, loading, and pickling again seems to produce more consistent
      # results than simply pickling. This is a bit
      class_id = pickle.dumps(cls)
      for _ in range(depth):
          new_class_id = pickle.dumps(pickle.loads(class_id))
          if new_class_id == class_id:
              # We appear to have reached a fix point, so use this as the ID.
              return hashlib.sha1(new_class_id).digest()
          class_id = new_class_id
  
      # We have not reached a fixed point, so we may end up with a different
      # class ID for this custom class on each worker, which could lead to the
      # same class definition being exported many many times.
      logger.warning(
          "WARNING: Could not produce a deterministic class ID for class "
          "{}".format(cls))
      return hashlib.sha1(new_class_id).digest()
docs: Attempt to produce a deterministic class ID for a given class.
  
      The goal here is for the class ID to be the same when this is run on
      different worker processes. Pickling, loading, and pickling again seems to
      produce more consistent results than simply pickling. This is a bit crazy
      and could cause problems, in which case we should revert it and figure out
      something better.
  
      Args:
          cls: The class to produce an ID for.
          depth: The number of times to repeatedly try to load and dump the
              string while trying to reach a fixed point.
  
      Returns:
          A class ID for this class. We attempt to make the class ID the same
              when this function is run on different workers, but that is not
              guaranteed.
  
      Raises:
          Exception: This could raise an exception if cloudpickle raises an
              exception.