code: def deprecated(
      since: str | None = None,
      removed: str | None = None,
      msg_suffix: str = "",
      version_val: str = __version__,
      warning_category: type[FutureWarning] = FutureWarning,
  ) -> Callable[[T], T]:
      """
      Marks a function or class as deprecated. If `since` is given this should be a version at or earlier than the
      current version and states at what version of the definition was marked as deprecated. If `removed` is given
      this can be any version and marks when the definition was removed.
  
      When the decorated definition is called, that is when the function is called or the class instantiated,
      a `warning_category` is issued if `since` is given and the current version is at or later than that given.
      a `DeprecatedError` exception is instead raised if `removed` is given and the current version is at or later
      than that, or if neither `since` nor `removed` is provided.
  
      The relevant docstring of the deprecating function should also be updated accordingly,
      using the Sphinx directives such as `.. versionchanged:: version` and `.. deprecated:: version`.
      https://www.sphinx-doc.org/en/master/usage/restructuredtext/directives.html#directive-versionadded
  
      Args:
          since: version at which the definition was marked deprecated but not removed.
          removed: version at which the definition was/will be removed and no longer usable.
          msg_suffix: message appended to warning/exception detailing reasons for deprecation and what to use instead.
          version_val: (used for testing) version to compare since and removed against, default is MONAI version.
          warning_category: a warning category class, defaults to `FutureWarning`.
  
      Returns:
          Decorated definition which warns or raises exception when used
      """
  
      if (
          since is not None
          and removed is not None
          and not version_leq(since, removed)
      ):
          raise ValueError(
              f"since must be less or equal to removed, got since={since}, removed={removed}."
          )
      is_not_yet_deprecated = (
          since is not None
          and version_val != since
          and version_leq(version_val, since)
      )
      if is_not_yet_deprecated:
          # smaller than `since`, do nothing
          return lambda obj: obj
  
      if since is None and removed is None:
          # raise a DeprecatedError directly
          is_removed = True
          is_deprecated = True
      else:
          # compare the numbers
          is_deprecated = since is not None and version_leq(
              since, version_val
          )
          is_removed = removed is not None and version_leq(
              removed, version_val
          )
  
      def _decorator(obj):
          is_func = isinstance(obj, FunctionType)
          call_obj = obj if is_func else obj.__init__
  
          msg_prefix = f"{'Function' if is_func else 'Class'} `{obj.__qualname__}`"
  
          if is_removed:
              msg_infix = f"was removed in version {removed}."
          elif is_deprecated:
              msg_infix = f"has been deprecated since version {since}."
              if removed is not None:
                  msg_infix += (
                      f" It will be removed in version {removed}."
                  )
          else:
              msg_infix = "has been deprecated."
  
          msg = f"{msg_prefix} {msg_infix} {msg_suffix}".strip()
  
          @wraps(call_obj)
          def _wrapper(*args, **kwargs):
              if is_removed:
                  raise DeprecatedError(msg)
              if is_deprecated:
                  warn_deprecated(obj, msg, warning_category)
  
              return call_obj(*args, **kwargs)
  
          if is_func:
              return _wrapper
          obj.__init__ = _wrapper
          return obj
  
      return _decorator
  
file_path: MONAI/monai/utils/deprecate_utils.py
imports: from __future__ import annotations
  import inspect
  import sys
  import warnings
  from collections.abc import Callable
  from functools import wraps
  from types import FunctionType
  from typing import Any, TypeVar
  from monai.utils.module import version_leq
  from ..None import __version__
label_desc: Use image node_id 2 for calling a global function with example usage: deprecated(since, removed, msg_suffix, version_val, warning_category) and returns: _decorator, function, obj, call_obj, _wrapper