code: def map_raw_ops_alias(
      alias: callable, kwargs_to_update: Optional[Dict] = None
  ) -> callable:
      """Map the raw_ops function with its respective frontend alias function, as
      the implementations of raw_ops is way similar to that of frontend
      functions, except that only arguments are passed as key-word only in
      raw_ops functions.
  
      Parameters
      ----------
      alias:
          The frontend function that is being referenced to as an alias to the
          current raw_ops function.
      kwargs_to_update:
          A dictionary containing key-word args to update to conform with a given
          raw_ops function
  
      Returns
      -------
      ret
          A decorated tf_frontend function to alias a given raw_ops function.
          Only accepting key-word only arguments.
      """
  
      def _wrap_raw_ops_alias(
          fn: callable, kw_update: Dict
      ) -> callable:
          # removing decorators from frontend function
          fn = inspect.unwrap(fn)
  
          # changing all the params to keyword-only
          sig = inspect.signature(fn)
          new_params = []
          kw_update_rev = (
              {value: key for key, value in kw_update.items()}
              if kw_update
              else {}
          )
          for param in sig.parameters.values():
              # updating the name of the parameter
              name = (
                  kw_update_rev[param.name]
                  if kw_update
                  and kw_update_rev.__contains__(param.name)
                  else param.name
              )
              new_params.append(
                  param.replace(name=name, kind=param.KEYWORD_ONLY)
              )
          new_signature = sig.replace(parameters=new_params)
  
          def _wraped_fn(**kwargs):
              # update kwargs dictionary keys
              if kw_update:
                  kwargs = _update_kwarg_keys(kwargs, kw_update)
              return fn(**kwargs)
  
          _wraped_fn.__signature__ = new_signature
          return _wraped_fn
  
      _wrap_raw_ops_alias.wrap_raw_ops_alias = True
      return _wrap_raw_ops_alias(alias, kwargs_to_update)
  
file_path: ivy/ivy/functional/frontends/tensorflow/func_wrapper.py
imports: import inspect
  from typing import Callable, Dict, Optional
  import functools
  import ivy
  import ivy.functional.frontends.tensorflow
  import ivy.functional.frontends.numpy
label_desc: Use image node_id 8 for calling a global function with example usage: map_raw_ops_alias(alias, kwargs_to_update) and returns: _wrap_raw_ops_alias, _wraped_fn, fn