class_docstr: A class used to export/load remote functions and actors.
  Attributes:
      _worker: The associated worker that this manager related.
      _functions_to_export: The remote functions to export when
          the worker gets connected.
      _actors_to_export: The actors to export when the worker gets
          connected.
      _function_execution_info: The function_id
          and execution_info.
      _num_task_executions: The function
          execution times.
      imported_actor_classes: The set of actor classes keys (format:
          ActorClass:function_id) that are already in GCS.
class_docstr_tok: ["A","class","used","to","export\/load","remote","functions","and","actors",".","Attributes",":","_worker",":","The","associated","worker","that","this","manager","related",".","_functions_to_export",":","The","remote","functions","to","export","when","the","worker","gets","connected",".","_actors_to_export",":","The","actors","to","export","when","the","worker","gets","connected",".","_function_execution_info",":","The","function_id","and","execution_info",".","_num_task_executions",":","The","function","execution","times",".","imported_actor_classes",":","The","set","of","actor","classes","keys","(","format",":","ActorClass",":","function_id",")","that","are","already","in","GCS","."]
docstr: Load the actor class.
  Args:
      job_id: job ID of the actor.
      actor_creation_function_descriptor: Function descriptor of
          the actor constructor.
  Returns:
      The actor class.
code: def load_actor_class(
      self, job_id, actor_creation_function_descriptor
  ):
      """Load the actor class.
      Args:
          job_id: job ID of the actor.
          actor_creation_function_descriptor: Function descriptor of
              the actor constructor.
      Returns:
          The actor class.
      """
      function_id = actor_creation_function_descriptor.function_id
      # Check if the actor class already exists in the cache.
      actor_class = self._loaded_actor_classes.get(function_id, None)
      if actor_class is None:
          # Load actor class.
          if self._worker.load_code_from_local:
              # Load actor class from local code first.
              actor_class = self._load_actor_class_from_local(
                  actor_creation_function_descriptor
              )
              # If the actor is unable to be loaded
              # from local, try to load it
              # from GCS even if load_code_from_local is set True
              if actor_class is None:
                  actor_class = self._load_actor_class_from_gcs(
                      job_id, actor_creation_function_descriptor
                  )
  
          else:
              # Load actor class from GCS.
              actor_class = self._load_actor_class_from_gcs(
                  job_id, actor_creation_function_descriptor
              )
          # Save the loaded actor class in cache.
          self._loaded_actor_classes[function_id] = actor_class
  
          # Generate execution info for the methods of this actor class.
          module_name = actor_creation_function_descriptor.module_name
          actor_class_name = (
              actor_creation_function_descriptor.class_name
          )
          actor_methods = inspect.getmembers(
              actor_class, predicate=is_function_or_method
          )
          for actor_method_name, actor_method in actor_methods:
              # Actor creation function descriptor use a unique function
              # hash to solve actor name conflict. When constructing an
              # actor, the actor creation function descriptor will be the
              # key to find __init__ method execution info. So, here we
              # use actor creation function descriptor as method descriptor
              # for generating __init__ method execution info.
              if actor_method_name == "__init__":
                  method_descriptor = actor_creation_function_descriptor
              else:
                  method_descriptor = PythonFunctionDescriptor(
                      module_name, actor_method_name, actor_class_name
                  )
              method_id = method_descriptor.function_id
              executor = self._make_actor_method_executor(
                  actor_method_name,
                  actor_method,
                  actor_imported=True,
              )
              self._function_execution_info[
                  method_id
              ] = FunctionExecutionInfo(
                  function=executor,
                  function_name=actor_method_name,
                  max_calls=0,
              )
              self._num_task_executions[method_id] = 0
          self._num_task_executions[function_id] = 0
      return actor_class
  
imports: import dis
  import sys
  import hashlib
  import importlib
  import inspect
  import json
  import logging
  import os
  import threading
  import time
  import traceback
  from collections import defaultdict, namedtuple
  from typing import Optional, Callable
  import ray
  import ray._private.profiling
  from ray import cloudpickle
  from ray._private import ray_constants
  from ray._private.inspect_util import is_class_method, is_function_or_method, is_static_method
  from ray._private.ray_constants import KV_NAMESPACE_FUNCTION_TABLE
  from ray._private.utils import check_oversized_function, ensure_str, format_error_message
  from ray._private.serialization import pickle_dumps
  from ray._raylet import JobID, PythonFunctionDescriptor, WORKER_PROCESS_SETUP_HOOK_KEY_NAME_GCS
label_desc: Use image node_id 15 for calling the FunctionActorManager obj's underlying member method code with example usage: obj.load_actor_class(job_id, actor_creation_function_descriptor) and returns: actor_class