code: def _deserialization_helper(self, state, ray_forking):
          
          worker = ray.worker.get_global_worker()
          worker.check_connected()
  
          if state["ray_forking"]:
              actor_handle_id = state["actor_handle_id"]
          else:
              # Right now, if the actor handle has been pickled, we create a
              # temporary actor handle id for invocations.
              # TODO(pcm): This still leads to a lot of actor handles being
              # created, there should be a better way to handle pickled
              # actor handles.
              # TODO(swang): Accessing the worker's current task ID is not
              # thread-safe.
              # TODO(swang): Unpickling the same actor handle twice in the same
              # task will break the application, and unpickling it twice in the
              # same actor is likely a performance bug. We should consider
              # logging a warning in these cases.
              actor_handle_id = compute_actor_handle_id_non_forked(
                  state["actor_handle_id"], worker.current_task_id)
  
          self.__init__(
              state["actor_id"],
              state["module_name"],
              state["class_name"],
              state["actor_cursor"],
              state["actor_method_names"],
              state["method_signatures"],
              state["method_num_return_vals"],
              state["actor_creation_dummy_object_id"],
              state["actor_method_cpus"],
              # This is the driver ID of the driver that owns the actor, not
              # necessarily the driver that owns this actor handle.
              state["actor_driver_id"],
              actor_handle_id=actor_handle_id)
docs: This is defined in order to make pickling work.
  
          Args:
              state: The serialized state of the actor handle.
              ray_forking: True if this is being called because Ray is forking
                  the actor handle and false if it is being called by pickling.