class_docstr: A base for proxies of shared objects.
class_docstr_tok: ["A","base","for","proxies","of","shared","objects","."]
code: def __init__(
      self,
      token,
      serializer,
      manager=None,
      authkey=None,
      exposed=None,
      incref=True,
      manager_owned=False,
  ):
      with BaseProxy._mutex:
          tls_idset = BaseProxy._address_to_local.get(
              token.address, None
          )
          if tls_idset is None:
              tls_idset = fiber.util.ForkAwareLocal(), ProcessLocalSet()
              BaseProxy._address_to_local[token.address] = tls_idset
  
      # self._tls is used to record the connection used by this
      # thread to communicate with the manager at token.address
      self._tls = tls_idset[0]
  
      # self._idset is used to record the identities of all shared
      # objects for which the current process owns references and
      # which are in the manager at token.address
      self._idset = tls_idset[1]
  
      self._token = token
      self._id = self._token.id
      self._manager = manager
      self._serializer = serializer
      self._Client = listener_client[serializer][1]
  
      # Should be set to True only when a proxy object is being created
      # on the manager server; primary use case: nested proxy objects.
      # RebuildProxy detects when a proxy is being created on the manager
      # and sets this value appropriately.
      self._owned_by_manager = manager_owned
  
      if authkey is not None:
          self._authkey = AuthenticationString(authkey)
      elif self._manager is not None:
          self._authkey = self._manager._authkey
      else:
          self._authkey = process.current_process().authkey
  
      if incref:
          self._incref()
  
      fiber.util.register_after_fork(self, BaseProxy._after_fork)
  
imports: import logging
  import multiprocessing
  import multiprocessing.util
  import queue
  import threading
  from multiprocessing.connection import SocketListener, _validate_family, address_type
  from multiprocessing.context import get_spawning_popen
  from multiprocessing.managers import Array, DictProxy, ListProxy, Namespace, RebuildProxy, State, Value, dispatch
  from multiprocessing.process import AuthenticationString
  import fiber.util
  import fiber.queues
  from fiber import process
  from fiber.backend import get_backend
label_desc: Use image node_id 1 to create a new BaseProxy object from inherited base classes: multiprocessing.managers with example: obj = BaseProxy(token, serializer, manager, authkey, exposed, incref, manager_owned)