class_docstr: This is a mixin for a kernel to override functions of the kernel. Because it overrides functions of the kernel,
  it needs to be placed first in the inheritance hierarchy. For this reason it is not possible to subclass the
  Mixin from the kernel class because this will prevent it from being instantiatable. Therefore, mypy won't know about
  anything related to the superclass and some type:ignore statements has to be added when accessing a member that is
  declared in the superclass such as `self.has_conditions`, `self._call`, `super().get_params`, etc.
  
  Parameters
  ----------
  operate_on : np.ndarray, defaults to None
      On which numpy array should be operated on.
  has_conditions : bool, defaults to False
      Whether the kernel has conditions.
  prior : AbstractPrior, defaults to None
      Which prior the kernel is using.
  
  Attributes
  ----------
  operate_on : np.ndarray, defaults to None
      On which numpy array should be operated on.
  has_conditions : bool, defaults to False
      Whether the kernel has conditions. Might be changed by the gaussian process.
  prior : AbstractPrior, defaults to None
      Which prior the kernel is using. Primarily used by sklearn.
docstr: Call the kernel function. Internally, `self._call` is called, which must be specified by a subclass.
docstr_tok: ["Call","the","kernel","function",".","Internally",",","`","self._call","`","is","called",",","which","must","be","specified","by","a","subclass","."]
code: def __call__(
      self,
      X: np.ndarray,
      Y: np.ndarray | None = None,
      eval_gradient: bool = False,
      active: np.ndarray | None = None,
  ) -> np.ndarray | tuple[np.ndarray, np.ndarray]:
      """Call the kernel function. Internally, `self._call` is called, which must be specified by a subclass."""
      if active is None and self.has_conditions:
          if self.operate_on is None:
              active = get_conditional_hyperparameters(X, Y)
          else:
              if Y is None:
                  active = get_conditional_hyperparameters(
                      X[:, self.operate_on], None
                  )
              else:
                  active = get_conditional_hyperparameters(
                      X[:, self.operate_on], Y[:, self.operate_on]
                  )
  
      if self.operate_on is None:
          rval = self._call(X, Y, eval_gradient, active)
      else:
          if self._len_active is None:
              raise RuntimeError(
                  "The internal variable `_len_active` is not set."
              )
  
          if Y is None:
              rval = self._call(
                  X=X[:, self.operate_on].reshape(
                      [-1, self._len_active]
                  ),
                  Y=None,
                  eval_gradient=eval_gradient,
                  active=active,
              )
              X = X[:, self.operate_on].reshape((-1, self._len_active))
          else:
              rval = self._call(
                  X=X[:, self.operate_on].reshape(
                      [-1, self._len_active]
                  ),
                  Y=Y[:, self.operate_on].reshape(
                      [-1, self._len_active]
                  ),
                  eval_gradient=eval_gradient,
                  active=active,
              )
              X = X[:, self.operate_on].reshape((-1, self._len_active))
              Y = Y[:, self.operate_on].reshape((-1, self._len_active))
  
      return rval
  
imports: from __future__ import annotations
  from abc import abstractmethod
  from typing import Any, Callable
  from inspect import Signature, signature
  import numpy
  import sklearn.gaussian_process.kernels
  from smac.model.gaussian_process.priors.abstract_prior import AbstractPrior
  from smac.utils.configspace import get_conditional_hyperparameters
label_desc: Use image node_id 6 for calling the AbstractKernel obj's underlying member method code with example usage: obj.__call__(X, Y, eval_gradient, active) and returns: rval