code: def quaternion_weights(
      quaternion1: type_alias.TensorLike,
      quaternion2: type_alias.TensorLike,
      percent: Union[type_alias.Float, type_alias.TensorLike],
      eps: Optional[type_alias.Float] = None,
      name: str = "quaternion_weights",
  ) -> Tuple[tf.Tensor, tf.Tensor]:
      """Calculates slerp weights for two normalized quaternions.
  
      Given a percent and two normalized quaternions, this function returns the
      slerp weights. It can also produce extrapolation weights when percent is
      outside of the [0, 1] range. It reduces to lerp when input quaternions are
      almost parallel or anti-parallel. Input quaternions are assumed to be
      normalized. The tf.graphics debug flag TFG_ADD_ASSERTS_TO_GRAPH defined
      in tfg_flags.py can be set to add assertions to the graph that check whether
      the inputs are normalized, and whether Inf or Nan values are produced.
  
      Note:
        In the following, A1 to An are optional batch dimensions.
  
      Args:
        quaternion1: A tensor of shape `[A1, ... , An, 4]` storing normalized
          quaternions in its last dimension.
        quaternion2: A tensor of shape `[A1, ... , An, 4]` storing normalized
          quaternions in its last dimension.
        percent: A `float` or tensor with shape broadcastable to the shape of input
          vectors.
        eps: A `float` used to make operations safe. When left as None, the function
          automatically picks the best epsilon based on the dtype and the operation.
        name: A name for this op. Defaults to "quaternion_weights".
  
      Raises:
        ValueError: If the shapes of quaternions do not match, if the last
          dimensions of quaternions are not 4, or if percent is neither a float, nor
          a tensor with last dimension 1.
  
      Returns:
        Two tensors of shape `[A1, ... , An, 1]` each, which are the two slerp
          weights for each quaternion.
      """
      with tf.name_scope(name):
          quaternion1 = tf.convert_to_tensor(value=quaternion1)
          quaternion2 = tf.convert_to_tensor(value=quaternion2)
          percent = tf.convert_to_tensor(
              value=percent, dtype=quaternion1.dtype
          )
  
          if percent.shape.ndims == 0:
              percent = tf.expand_dims(percent, axis=0)
          shape.check_static(
              tensor=quaternion1,
              tensor_name="quaternion1",
              has_dim_equals=(-1, 4),
          )
          shape.check_static(
              tensor=quaternion2,
              tensor_name="quaternion2",
              has_dim_equals=(-1, 4),
          )
          shape.compare_batch_dimensions(
              tensors=(quaternion1, quaternion2, percent),
              last_axes=-1,
              broadcast_compatible=True,
              tensor_names=("quaternion1", "quaternion2", "percent"),
          )
          quaternion1 = asserts.assert_normalized(quaternion1)
          quaternion2 = asserts.assert_normalized(quaternion2)
  
          dot_product = _safe_dot(quaternion1, quaternion2, eps)
  
          # Take the shorter path
          theta = tf.acos(tf.abs(dot_product))
  
          # safe_sinpx_div_sinx returns p for very small x, which means slerp reduces
          # to lerp automatically.
          scale1 = safe_ops.safe_sinpx_div_sinx(
              theta, 1.0 - percent, eps
          )
          scale2 = safe_ops.safe_sinpx_div_sinx(theta, percent, eps)
  
          # Flip the sign of scale1 if quaternions are in different hemispheres.
          # tf.sign can make scale1 zero if quaternions are orthogonal.
          scale1 *= safe_ops.nonzero_sign(dot_product)
          return scale1, scale2
  
file_path: graphics/tensorflow_graphics/math/interpolation/slerp.py
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import enum
  from typing import Optional, Tuple, Union
  import tensorflow
  from tensorflow_graphics.math import vector
  from tensorflow_graphics.util import asserts
  from tensorflow_graphics.util import export_api
  from tensorflow_graphics.util import safe_ops
  from tensorflow_graphics.util import shape
  from tensorflow_graphics.util import type_alias
label_desc: Use image node_id 4 for calling a global function with example usage: quaternion_weights(quaternion1, quaternion2, percent, eps, name) and returns: scale1,  scale2