code: def _replace_event_shape_in_tensorshape(
      input_tensorshape, event_shape_in, event_shape_out
  ):
      """Replaces the event shape dims of a `TensorShape`.
  
      Args:
        input_tensorshape: a `TensorShape` instance in which to attempt replacing
          event shape.
        event_shape_in: `Tensor` shape representing the event shape expected to
          be present in (rightmost dims of) `tensorshape_in`. Must be compatible
          with the rightmost dims of `tensorshape_in`.
        event_shape_out: `Tensor` shape representing the new event shape, i.e.,
          the replacement of `event_shape_in`,
  
      Returns:
        output_tensorshape: `TensorShape` with the rightmost `event_shape_in`
          replaced by `event_shape_out`. Might be partially defined, i.e.,
          `TensorShape(None)`.
        is_validated: Python `bool` indicating static validation happened.
  
      Raises:
        ValueError: if we can determine the event shape portion of
          `tensorshape_in` as well as `event_shape_in` both statically, and they
          are not compatible. "Compatible" here means that they are identical on
          any dims that are not -1 in `event_shape_in`.
      """
      event_shape_in_ndims = tensorshape_util.num_elements(
          event_shape_in.shape
      )
      if (
          tensorshape_util.rank(input_tensorshape) is None
          or event_shape_in_ndims is None
      ):
          return tf.TensorShape(None), False  # Not is_validated.
  
      input_non_event_ndims = (
          tensorshape_util.rank(input_tensorshape)
          - event_shape_in_ndims
      )
      if input_non_event_ndims < 0:
          raise ValueError(
              "Input has lower rank ({}) than `event_shape_ndims` ({}).".format(
                  tensorshape_util.rank(input_tensorshape),
                  event_shape_in_ndims,
              )
          )
  
      input_non_event_tensorshape = input_tensorshape[
          :input_non_event_ndims
      ]
      input_event_tensorshape = input_tensorshape[
          input_non_event_ndims:
      ]
  
      # Check that `input_event_shape_` and `event_shape_in` are compatible in the
      # sense that they have equal entries in any position that isn't a `-1` in
      # `event_shape_in`. Note that our validations at construction time ensure
      # there is at most one such entry in `event_shape_in`.
      event_shape_in_ = tf.get_static_value(event_shape_in)
      is_validated = (
          tensorshape_util.is_fully_defined(input_event_tensorshape)
          and event_shape_in_ is not None
      )
      if is_validated:
          input_event_shape_ = np.int32(input_event_tensorshape)
          mask = event_shape_in_ >= 0
          explicit_input_event_shape_ = input_event_shape_[mask]
          explicit_event_shape_in_ = event_shape_in_[mask]
          if not np.all(
              explicit_input_event_shape_ == explicit_event_shape_in_
          ):
              raise ValueError(
                  "Input `event_shape` does not match `event_shape_in` "
                  "({} vs {}).".format(
                      input_event_shape_, event_shape_in_
                  )
              )
  
      event_tensorshape_out = tensorshape_util.constant_value_as_shape(
          event_shape_out
      )
      if tensorshape_util.rank(event_tensorshape_out) is None:
          output_tensorshape = tf.TensorShape(None)
      else:
          output_tensorshape = tensorshape_util.concatenate(
              input_non_event_tensorshape, event_tensorshape_out
          )
      return output_tensorshape, is_validated
  
imports: import numpy
  import tensorflow.compat.v2
  from tensorflow_probability.python.bijectors import bijector
  from tensorflow_probability.python.internal import assert_util
  from tensorflow_probability.python.internal import dtype_util
  from tensorflow_probability.python.internal import parameter_properties
  from tensorflow_probability.python.internal import prefer_static
  from tensorflow_probability.python.internal import tensor_util
  from tensorflow_probability.python.internal import tensorshape_util
label_desc: Use image node_id 2 for calling a global function with example usage: _replace_event_shape_in_tensorshape(input_tensorshape, event_shape_in, event_shape_out) and returns: output_tensorshape,  is_validated, tf,  False