Method __getattr__

dm_control/mjcf/physics.py:314–354

(self, name)

    return element_id

  def __getattr__(self, name):
    if name in Binding.__slots__:
      return super().__getattr__(name)
    else:
      try:
        out = self._getattr_cache[name]
        out._synchronize_from_backing_array()  # pylint: disable=protected-access
      except KeyError:
        array, index = self._get_cached_array_and_index(name)
        triggers_dirty = self._attributes[name].triggers_dirty

        # A list of (array, index) tuples specifying other addresses that need
        # to be zeroed out when this array attribute is written to.
        disable_on_write = []
        for name_to_disable in self._attributes[name].disable_on_write:
          array_to_disable, index_to_disable = self._get_cached_array_and_index(
              name_to_disable)
          # Ensure that the result of indexing is a `SynchronizingArrayWrapper`
          # rather than a scalar, otherwise we won't be able to write into it.
          if array_to_disable.ndim == 1:
            if isinstance(index_to_disable, np.ndarray):
              index_to_disable = index_to_disable.copy().reshape(-1, 1)
            else:
              index_to_disable = [index_to_disable]
          disable_on_write.append((array_to_disable, index_to_disable))

        if self._physics.is_dirty and not triggers_dirty:
          self._physics.forward()
        if np.issubdtype(type(index), np.integer) and array.ndim == 1:
          # Case where indexing results in a scalar.
          out = array[index]
        else:
          # Case where indexing results in an array.
          out = SynchronizingArrayWrapper(
              backing_array=array,
              backing_index=index,
              physics=self._physics,
              triggers_dirty=triggers_dirty,
              disable_on_write=disable_on_write)
          self._getattr_cache[name] = out
      return out

  def __setattr__(self, name, value):
    if name in Binding.__slots__: