Python weakref.ProxyType方法代码示例

# 需要导入模块: import weakref [as 别名]
# 或者: from weakref import ProxyType [as 别名]
def __init__(self, parent_message):
    """Args:
      parent_message: The message whose _Modified() method we should call when
        we receive Modified() messages.
    """
    # This listener establishes a back reference from a child (contained) object
    # to its parent (containing) object.  We make this a weak reference to avoid
    # creating cyclic garbage when the client finishes with the 'parent' object
    # in the tree.
    if isinstance(parent_message, weakref.ProxyType):
      self._parent_message_weakref = parent_message
    else:
      self._parent_message_weakref = weakref.proxy(parent_message)

    # As an optimization, we also indicate directly on the listener whether
    # or not the parent message is dirty.  This way we can avoid traversing
    # up the tree in the common case.
    self.dirty = False 

# 需要导入模块: import weakref [as 别名]
# 或者: from weakref import ProxyType [as 别名]
def __init__(self,runner):
    """
    Param
    ----------------------------------------------------------
    runner - Instance of TaskRunner
    """
    ipc.Responder.__init__(self, inputProtocol)

    self.log=logging.getLogger("TaskRunnerResponder")

    # should we use weak references to avoid circular references?
    # We use weak references b\c self.runner owns this instance of TaskRunnerResponder
    if isinstance(runner,weakref.ProxyType):
      self.runner=runner
    else:
      self.runner=weakref.proxy(runner)

    self.task=weakref.proxy(runner.task) 

# 需要导入模块: import weakref [as 别名]
# 或者: from weakref import ProxyType [as 别名]
def __init__(self, parent_message):
    """Args:
      parent_message: The message whose _Modified() method we should call when
        we receive Modified() messages.
    """




    if isinstance(parent_message, weakref.ProxyType):
      self._parent_message_weakref = parent_message
    else:
      self._parent_message_weakref = weakref.proxy(parent_message)




    self.dirty = False 

# 需要导入模块: import weakref [as 别名]
# 或者: from weakref import ProxyType [as 别名]
def _recompile_physics_and_update_observables(self):
    """Sets up the environment for latest MJCF model from the task."""
    self._physics_proxy = None
    self._recompile_physics()
    if isinstance(self._physics, weakref.ProxyType):
      self._physics_proxy = self._physics
    else:
      self._physics_proxy = weakref.proxy(self._physics)

    if self._overridden_n_sub_steps is not None:
      self._n_sub_steps = self._overridden_n_sub_steps
    else:
      self._n_sub_steps = self._task.physics_steps_per_control_step

    self._hooks.refresh_entity_hooks()
    self._hooks.after_compile(self._physics_proxy, self._random_state)
    self._observation_updater = self._make_observation_updater()
    self._observation_updater.reset(self._physics_proxy, self._random_state) 

# 需要导入模块: import weakref [as 别名]
# 或者: from weakref import ProxyType [as 别名]
def _parent(self, value):
        if value is not None and not isinstance(value, weakref.ProxyType):
            value = weakref.proxy(value)
        self.__parent = value 

# 需要导入模块: import weakref [as 别名]
# 或者: from weakref import ProxyType [as 别名]
def _request(self, value):
        if value is not None and not isinstance(value, weakref.ProxyType):
            value = weakref.proxy(value)
        self.__request = value 

# 需要导入模块: import weakref [as 别名]
# 或者: from weakref import ProxyType [as 别名]
def HTTPHandlerGen(runner):
  """
  This is a class factory for the HTTPHandler. We need
  a factory b\c we need a reference to the runner

  Parameters
  -----------------------------------------------------------------
  runner - instance of the task runner
  """

  if not(isinstance(runner,weakref.ProxyType)):
    runnerref=weakref.proxy(runner)
  else:
    runnerref=runner

  class TaskRunnerHTTPHandler(BaseHTTPRequestHandler):
    """Create a handler for the parent.
    """

    runner=runnerref
    def __init__(self,*args,**param):
      """
      """
      BaseHTTPRequestHandler.__init__(self,*args,**param)

    def do_POST(self):
      self.responder =TaskRunnerResponder(self.runner)
      call_request_reader = ipc.FramedReader(self.rfile)
      call_request = call_request_reader.read_framed_message()
      resp_body = self.responder.respond(call_request)
      self.send_response(200)
      self.send_header('Content-Type', 'avro/binary')
      self.end_headers()
      resp_writer = ipc.FramedWriter(self.wfile)
      resp_writer.write_framed_message(resp_body)

  return TaskRunnerHTTPHandler 

# 需要导入模块: import weakref [as 别名]
# 或者: from weakref import ProxyType [as 别名]
def CheckCursorConnection(self):
        if not isinstance(self.cur.connection, weakref.ProxyType) and \
           not isinstance(self.cur.connection, weakref.CallableProxyType):
            fail("cursor.connection doesn't return the correct type") 

# 需要导入模块: import weakref [as 别名]
# 或者: from weakref import ProxyType [as 别名]
def physics(self):
    """Returns a `weakref.ProxyType` pointing to the current `mjcf.Physics`.

    Note that the underlying `mjcf.Physics` will be destroyed whenever the MJCF
    model is recompiled. It is therefore unsafe for external objects to hold a
    reference to `environment.physics`. Attempting to access attributes of a
    dead `Physics` instance will result in a `ReferenceError`.
    """
    return self._physics_proxy 

# 需要导入模块: import weakref [as 别名]
# 或者: from weakref import ProxyType [as 别名]
def enter(self, handlers, loop=None):
        assert self._loop or loop
        if loop:
            if not isinstance(loop, weakref.ProxyType):
                loop = weakref.proxy(loop)
            self._loop = loop

        if not isinstance(handlers, weakref.ProxyType):
            handlers = weakref.proxy(handlers)

        token = self.__context__.set(handlers)

        yield self
        self.__context__.reset(token)