rasa-pro 3.14.0.dev6__py3-none-any.whl → 3.14.0.dev8__py3-none-any.whl

rasa/tracing/config.py

@@ -6,7 +6,6 @@ import os
 from typing import Any, Dict, Optional, Text
 
 import grpc
-from opentelemetry.exporter.jaeger.thrift import JaegerExporter
 from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import OTLPMetricExporter
 from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
 from opentelemetry.metrics import set_meter_provider
@@ -172,19 +171,35 @@ class TracerConfigurer(abc.ABC):
 
 
 class JaegerTracerConfigurer(TracerConfigurer):
-    """The `TracerConfigurer` for a Jaeger backend."""
+    """The `TracerConfigurer` for a Jaeger backend.
+
+    This class maintains backward compatibility with the old Jaeger configuration format
+    while internally using OTLP to avoid protobuf compatibility issues.
+    """
 
     @classmethod
     def configure_from_endpoint_config(cls, cfg: EndpointConfig) -> TracerProvider:
-        """Configure tracing for Jaeger.
+        """Configure tracing for Jaeger using OTLP under the hood.
 
-        This will read the Jaeger-specific configuration from the `EndpointConfig` and
-        create a corresponding `TracerProvider` that exports to the given Jaeger
-        backend.
+        This maintains backward compatibility with the old Jaeger configuration format
+        while using OTLP internally to avoid protobuf compatibility issues.
 
         :param cfg: The configuration to be read for configuring tracing.
         :return: The configured `TracerProvider`.
         """
+        # Extract Jaeger-specific configuration
+        jaeger_config = cls._extract_config(cfg)
+
+        # Map Jaeger configuration to OTLP endpoint
+        otlp_endpoint = f"http://{jaeger_config['agent_host_name']}:{jaeger_config.get('agent_port', 4317)}"  # noqa: E501
+
+        # Create OTLP exporter with Jaeger-compatible configuration
+        otlp_exporter = OTLPSpanExporter(
+            endpoint=otlp_endpoint,
+            insecure=True,  # Jaeger typically runs without TLS in development
+            headers=cls._build_headers(jaeger_config),
+        )
+
         provider = TracerProvider(
             resource=Resource.create(
                 {
@@ -195,19 +210,17 @@ class JaegerTracerConfigurer(TracerConfigurer):
             )
         )
 
-        jaeger_exporter = JaegerExporter(
-            **cls._extract_config(cfg), udp_split_oversized_batches=True
-        )
         logger.info(
-            f"Registered {cfg.type} endpoint for tracing. Traces will be exported to"
-            f" {jaeger_exporter.agent_host_name}:{jaeger_exporter.agent_port}"
+            f"Registered {cfg.type} endpoint for tracing using OTLP. "
+            f"Traces will be exported to {otlp_endpoint}."
         )
-        provider.add_span_processor(BatchSpanProcessor(jaeger_exporter))
+        provider.add_span_processor(BatchSpanProcessor(otlp_exporter))
 
         return provider
 
     @classmethod
     def _extract_config(cls, cfg: EndpointConfig) -> Dict[str, Any]:
+        """Extract Jaeger configuration parameters."""
         return {
             "agent_host_name": (cfg.kwargs.get("host", "localhost")),
             "agent_port": (cfg.kwargs.get("port", 6831)),
@@ -215,6 +228,19 @@ class JaegerTracerConfigurer(TracerConfigurer):
             "password": cfg.kwargs.get("password"),
         }
 
+    @classmethod
+    def _build_headers(cls, jaeger_config: Dict[str, Any]) -> Optional[Dict[str, str]]:
+        """Build OTLP headers from Jaeger authentication config."""
+        headers = {}
+        if jaeger_config.get("username") and jaeger_config.get("password"):
+            import base64
+
+            credentials = base64.b64encode(
+                f"{jaeger_config['username']}:{jaeger_config['password']}".encode()
+            ).decode()
+            headers["Authorization"] = f"Basic {credentials}"
+        return headers if headers else None
+
 
 class OTLPCollectorConfigurer(TracerConfigurer):
     """The `TracerConfigurer` for an OTLP collector backend."""

rasa/tracing/instrumentation/attribute_extractors.py

@@ -60,6 +60,7 @@ from rasa.shared.core.constants import REQUESTED_SLOT
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.events import DialogueStackUpdated, Event
 from rasa.shared.core.flows import Flow, FlowsList, FlowStep
+from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.core.training_data.structures import StoryGraph
 from rasa.shared.importers.importer import TrainingDataImporter
@@ -585,7 +586,10 @@ def extract_attrs_for_check_commands_against_startable_flows(
 
 
 def extract_attrs_for_advance_flows(
-    tracker: DialogueStateTracker, available_actions: List[str], flows: FlowsList
+    tracker: DialogueStateTracker,
+    available_actions: List[str],
+    flows: FlowsList,
+    slots: List[Slot],
 ) -> Dict[str, Any]:
     from rasa.tracing.instrumentation.instrumentation import FLOW_EXECUTOR_MODULE_NAME
 

rasa/tracing/instrumentation/instrumentation.py

@@ -245,6 +245,67 @@ def traceable_async(
     return async_wrapper
 
 
+def traceable_module_async(
+    fn: Callable[..., Awaitable[S]],
+    tracer: Tracer,
+    attr_extractor: Optional[Callable[..., Dict[str, Any]]],
+    header_extractor: Optional[Callable[..., Dict[str, Any]]],
+    metrics_recorder: Optional[Callable],
+) -> Callable[..., Awaitable[S]]:
+    """Wrap a module-level async function with tracing functionality.
+
+    :param fn: The async function to be wrapped.
+    :param tracer: The `Tracer` that shall be used for tracing this function.
+    :param attr_extractor: A function that is applied to the function's arguments.
+    :param header_extractor: A function that is applied to the function's arguments.
+    :param metrics_recorder: A function that records metric measurements.
+    :return: The wrapped function.
+    """
+    should_extract_args = _check_extractor_argument_list(fn, attr_extractor)
+
+    @functools.wraps(fn)
+    async def async_wrapper(*args: Any, **kwargs: Any) -> S:
+        attrs = (
+            attr_extractor(*args, **kwargs)
+            if attr_extractor and should_extract_args
+            else {}
+        )
+        headers = header_extractor(*args, **kwargs) if header_extractor else {}
+        context = extract_tracing_context_from_headers(headers)
+
+        # Use module name from attrs or fallback to function module
+        module_name = attrs.pop("module_name", "")
+        if module_name in [
+            "command_processor",
+            FLOW_EXECUTOR_MODULE_NAME,
+            DIALOG_UNDERSTANDING_TEST_IO_MODULE_NAME,
+        ]:
+            span_name = f"{module_name}.{fn.__name__}"
+        else:
+            span_name = f"{fn.__module__}.{fn.__name__}"
+
+        with tracer.start_as_current_span(
+            span_name,
+            attributes=attrs,
+            context=context,
+        ) as span:
+            TraceContextTextMapPropagator().inject(headers)
+
+            ctx = span.get_span_context()
+            logger.debug(
+                f"The trace id for the current span '{span_name}' is '{ctx.trace_id}'."
+            )
+
+            result = await fn(*args, **kwargs)
+
+            if metrics_recorder:
+                metrics_recorder(attrs)
+
+            return result
+
+    return async_wrapper
+
+
 def traceable_async_generator(
     fn: Callable[[T, Any, Any], AsyncIterator[S]],
     tracer: Tracer,
@@ -1160,7 +1221,11 @@ def _instrument_function(
     module = importlib.import_module(module_name)
     function_to_trace = getattr(module, function_name)
     traced_function = _wrap_with_tracing_decorator(
-        function_to_trace, tracer, attr_extractor, header_extractor
+        function_to_trace,
+        tracer,
+        attr_extractor,
+        header_extractor,
+        is_module_function=True,
     )
 
     setattr(module, function_name, traced_function)
@@ -1176,15 +1241,27 @@ def _wrap_with_tracing_decorator(
     attr_extractor: Optional[Callable],
     header_extractor: Optional[Callable] = None,
     metrics_recorder: Optional[Callable] = None,
+    is_module_function: bool = False,
 ) -> Callable:
     if inspect.iscoroutinefunction(callable_to_trace):
-        traced_callable = traceable_async(
-            callable_to_trace,
-            tracer,
-            attr_extractor,
-            header_extractor,
-            metrics_recorder,
-        )
+        if is_module_function:
+            # This is a module-level async function
+            traced_callable = traceable_module_async(
+                callable_to_trace,
+                tracer,
+                attr_extractor,
+                header_extractor,
+                metrics_recorder,
+            )
+        else:
+            # This is a class method
+            traced_callable = traceable_async(
+                callable_to_trace,
+                tracer,
+                attr_extractor,
+                header_extractor,
+                metrics_recorder,
+            )
     else:
         traced_callable = traceable(
             callable_to_trace, tracer, attr_extractor, metrics_recorder

rasa/utils/common.py

@@ -52,7 +52,7 @@ EXPECTED_WARNINGS: List[Tuple[Type[Warning], str]] = [
     # TODO (issue #9932)
     #  DM1 warnings
     (
-        np.VisibleDeprecationWarning,
+        np.exceptions.VisibleDeprecationWarning,
         "Creating an ndarray from ragged nested sequences.*",
     ),
     # raised by magic_filter, google rpc

rasa/utils/io.py

@@ -26,6 +26,7 @@ from typing_extensions import Protocol
 
 import rasa.shared.constants
 import rasa.shared.utils.io
+from rasa.shared.exceptions import RasaException
 
 if TYPE_CHECKING:
     from prompt_toolkit.validation import Validator
@@ -124,9 +125,7 @@ def create_path(file_path: Text) -> None:
 def file_type_validator(
     valid_file_types: List[Text], error_message: Text
 ) -> Type["Validator"]:
-    """Creates a `Validator` class which can be used with `questionary` to validate
-    file paths.
-    """
+    """Creates a file type validator class for the questionary package."""
 
     def is_valid(path: Text) -> bool:
         return path is not None and any(
@@ -137,9 +136,7 @@ def file_type_validator(
 
 
 def not_empty_validator(error_message: Text) -> Type["Validator"]:
-    """Creates a `Validator` class which can be used with `questionary` to validate
-    that the user entered something other than whitespace.
-    """
+    """Creates a not empty validator class for the questionary package."""
 
     def is_valid(input: Text) -> bool:
         return input is not None and input.strip() != ""
@@ -150,9 +147,7 @@ def not_empty_validator(error_message: Text) -> Type["Validator"]:
 def create_validator(
     function: Callable[[Text], bool], error_message: Text
 ) -> Type["Validator"]:
-    """Helper method to create `Validator` classes from callable functions. Should be
-    removed when questionary supports `Validator` objects.
-    """
+    """Helper method to create a validator class from a callable function."""
     from prompt_toolkit.document import Document
     from prompt_toolkit.validation import ValidationError, Validator
 
@@ -250,3 +245,26 @@ def write_yaml(
 
     with Path(target).open("w", encoding="utf-8") as outfile:
         dumper.dump(data, outfile, transform=transform)
+
+
+class InvalidPathException(RasaException):
+    """Raised if a path is invalid - e.g. path traversal is detected."""
+
+
+def subpath(parent: str, child: str) -> str:
+    """Return the path to the child directory of the parent directory.
+
+    Ensures, that child doesn't navigate to parent directories. Prevents
+    path traversal. Raises an InvalidPathException if the path is invalid.
+
+    Based on Snyk's directory traversal mitigation:
+    https://learn.snyk.io/lesson/directory-traversal/
+    """
+    safe_path = os.path.abspath(os.path.join(parent, child))
+    parent = os.path.abspath(parent)
+
+    common_base = os.path.commonpath([parent, safe_path])
+    if common_base != parent:
+        raise InvalidPathException(f"Invalid path: {safe_path}")
+
+    return safe_path

rasa/utils/json_utils.py

@@ -1,6 +1,6 @@
 import json
 from decimal import Decimal
-from typing import Any, Text
+from typing import Any, Dict, List, Text
 
 
 class DecimalEncoder(json.JSONEncoder):
@@ -58,3 +58,8 @@ def replace_decimals_with_floats(obj: Any) -> Any:
         Input `obj` with all `Decimal` types replaced by `float`s.
     """
     return json.loads(json.dumps(obj, cls=DecimalEncoder))
+
+
+def extract_values(data: Dict, keys: List[Text]) -> Dict:
+    """Extracts values for given keys from a dictionary."""
+    return {key: data.get(key) for key in keys if data.get(key)}

rasa/utils/log_utils.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 import os
 import sys
-from typing import Any, Optional
+from typing import Any, List, Optional
 
 import structlog
 from structlog.dev import ConsoleRenderer
@@ -37,6 +37,7 @@ class HumanConsoleRenderer(ConsoleRenderer):
 def configure_structlog(
     log_level: Optional[int] = None,
     include_time: bool = False,
+    additional_processors: Optional[List[structlog.typing.Processor]] = None,
 ) -> None:
     """Configure logging of the server."""
     if log_level is None:  # Log level NOTSET is 0 so we use `is None` here
@@ -75,6 +76,9 @@ def configure_structlog(
     if include_time:
         shared_processors.append(structlog.processors.TimeStamper(fmt="iso"))
 
+    if additional_processors:
+        shared_processors.extend(additional_processors)
+
     if not FORCE_JSON_LOGGING and sys.stderr.isatty():
         # Pretty printing when we run in a terminal session.
         # Automatically prints pretty tracebacks when "rich" is installed

rasa/utils/openapi.py

@@ -0,0 +1,144 @@
+from typing import Any, Dict, List, Type
+
+from pydantic.main import BaseModel
+from sanic_openapi import openapi
+from sanic_openapi.openapi3.types import Schema
+
+_SUPPORTED_ATTRIBUTES = frozenset(["format", "enum", "required", "example"])
+
+
+def _to_schema(
+    definition_stack: List[str], schema_def: Dict[str, Any], definitions: Dict[str, Any]
+) -> Schema:
+    type = schema_def.get("type")
+
+    if type == "object":
+        properties_spec = schema_def.get("properties", {})
+        properties = {}
+        for key in properties_spec:
+            properties[key] = _to_schema(
+                definition_stack=definition_stack,
+                schema_def=properties_spec[key],
+                definitions=definitions,
+            )
+        schema = openapi.Object(
+            title=schema_def.get("title"),
+            description=schema_def.get("description"),
+            required=schema_def.get("required"),
+            properties=properties,
+        )
+    elif type == "array":
+        schema = openapi.Array(
+            description=schema_def.get("description"),
+            required=schema_def.get("required"),
+            items=_to_schema(
+                definition_stack=definition_stack,
+                schema_def=schema_def.get("items"),
+                definitions=definitions,
+            ),
+        )
+    elif type is None:
+        if allof_spec := schema_def.get("allOf"):  # Model, Enum
+            definition = allof_spec[0]["$ref"].split("/")[-1]
+            definition_data = definitions.get(definition)
+            if definition_data is None:
+                schema = openapi.Object(
+                    title=definition, description=schema_def.get("description")
+                )
+            else:
+                schema = (
+                    _to_schema(
+                        definition_stack=definition_stack + [definition],
+                        schema_def={**definition_data},
+                        definitions=definitions,
+                    )
+                    if definition not in definition_stack
+                    else openapi.Object(
+                        title=definition, description=schema_def.get("description")
+                    )
+                )
+
+        elif anyof_spec := schema_def.get("anyOf"):  # Union
+            anyof = []
+            for any in anyof_spec:
+                if any.get("type"):
+                    schema_type_obj = Schema(
+                        **{
+                            "type": any.get("type"),
+                            "description": any.get("description"),
+                        }
+                    )
+                    anyof.append(schema_type_obj)
+                else:
+                    definition = any["$ref"].split("/")[-1]
+                    if definition not in definition_stack:
+                        definition_data = definitions.get(definition)
+                        if definition_data is not None:
+                            anyof.append(
+                                _to_schema(
+                                    definition_stack=definition_stack + [definition],
+                                    schema_def=definition_data,
+                                    definitions=definitions,
+                                )
+                            )
+                        else:
+                            anyof.append(
+                                openapi.Object(
+                                    title=definition,
+                                    description=schema_def.get(
+                                        "description", definition
+                                    ),
+                                    properties={},
+                                )
+                            )
+                    else:
+                        anyof.append(
+                            openapi.Object(
+                                title=definition,
+                                description=schema_def.get("description", definition),
+                                properties={},
+                            )
+                        )
+            schema = Schema(anyOf=anyof)
+        elif ref := schema_def.get("$ref"):  # $ref
+            definition = ref.split("/")[-1]
+            definition_data = definitions.get(definition)
+            if definition_data is not None:
+                schema = _to_schema(
+                    definition_stack=definition_stack,
+                    schema_def=definition_data,
+                    definitions=definitions,
+                )
+            else:
+                schema = openapi.Object(
+                    title=definition, description=schema_def.get("description")
+                )
+        else:  # Any type
+            schema = Schema(
+                **{"type": "object", "description": schema_def.get("description")}
+            )
+
+    else:
+        schema_spec = {
+            "type": schema_def.get("type"),
+            "description": schema_def.get("description"),
+        }
+        for spec in _SUPPORTED_ATTRIBUTES:
+            if schema_def.get(spec):
+                schema_spec[spec] = schema_def.get(spec)
+        schema = Schema(**schema_spec)
+
+    return schema
+
+
+def model_to_schema(model: Type[BaseModel]) -> Schema:
+    schema = model.model_json_schema()
+    # Handle both $defs (newer JSON Schema) and definitions (older JSON Schema)
+    definitions = schema.get("$defs") or schema.get("definitions") or {}
+    return _to_schema(
+        definition_stack=[],
+        schema_def=dict(
+            filter(lambda key: key[0] not in ("definitions", "$defs"), schema.items())
+        ),
+        definitions=definitions,
+    )

rasa/utils/tensorflow/__init__.py

@@ -0,0 +1,29 @@
+"""TensorFlow utilities for Rasa components.
+
+This module provides TensorFlow-related utilities and components.
+TensorFlow is an optional dependency and should be installed separately
+if you want to use components that require it. These are:
+- DIETClassifier
+- TEDPolicy
+- UnexpecTEDIntentPolicy
+- ResponseSelector
+- ConveRTFeaturizer
+- LanguageModelFeaturizer
+
+To install Rasa with TensorFlow support:
+`pip install "rasa[tensorflow]"`
+
+To install it with poetry:
+`poetry install --extras tensorflow`
+
+For macOS with Apple Silicon (M1/M2) (platform-specific TensorFlow installation):
+`pip install "rasa[tensorflow,metal]"`
+"""
+
+import importlib.util
+import logging
+
+logger = logging.getLogger(__name__)
+
+# check if TensorFlow is available
+TENSORFLOW_AVAILABLE = importlib.util.find_spec("tensorflow") is not None

rasa/utils/tensorflow/callback.py

@@ -55,7 +55,7 @@ class RasaModelCheckpoint(tf.keras.callbacks.Callback):
         """
         super().__init__()
 
-        self.checkpoint_file = checkpoint_dir / "checkpoint.tf_model"
+        self.checkpoint_file = checkpoint_dir / "checkpoint.weights.h5"
         self.best_metrics_so_far: Dict[Text, Any] = {}
 
     def on_epoch_end(self, epoch: int, logs: Optional[Dict[Text, Any]] = None) -> None:

rasa/utils/tensorflow/crf.py

@@ -9,7 +9,7 @@ from tensorflow.types.experimental import TensorLike
 # (modified to our neeeds)
 
 
-class CrfDecodeForwardRnnCell(tf.keras.layers.AbstractRNNCell):
+class CrfDecodeForwardRnnCell(tf.keras.layers.Layer):
     """Computes the forward decoding in a linear-chain CRF."""
 
     def __init__(self, transition_params: TensorLike, **kwargs: Any) -> None:

rasa/utils/tensorflow/data_generator.py

@@ -71,13 +71,22 @@ class RasaDataGenerator(Sequence):
         # balancing on the next epoch
         return data
 
+    @staticmethod
+    def _create_default_array() -> np.ndarray:
+        """Create a default empty array for missing features.
+
+        Returns:
+            A default empty array with shape (0, 1) and dtype float32.
+        """
+        return np.zeros((0, 1), dtype=np.float32)
+
     @staticmethod
     def prepare_batch(
         data: Data,
         start: Optional[int] = None,
         end: Optional[int] = None,
         tuple_sizes: Optional[Dict[Text, int]] = None,
-    ) -> Tuple[Optional[np.ndarray], ...]:
+    ) -> Tuple[np.ndarray, ...]:
         """Slices model data into batch using given start and end value.
 
         Args:
@@ -85,8 +94,8 @@ class RasaDataGenerator(Sequence):
             start: The start index of the batch
             end: The end index of the batch
             tuple_sizes: In case the feature is not present we propagate the batch with
-              None. Tuple sizes contains the number of how many None values to add for
-              what kind of feature.
+              default arrays. Tuple sizes contains the number of how many default values
+              to add for what kind of feature.
 
         Returns:
             The features of the batch.
@@ -95,12 +104,14 @@ class RasaDataGenerator(Sequence):
 
         for key, attribute_data in data.items():
             for sub_key, f_data in attribute_data.items():
-                # add None for not present values during processing
+                # add default arrays for not present values during processing
                 if not f_data:
                     if tuple_sizes:
-                        batch_data += [None] * tuple_sizes[key]
+                        batch_data += [
+                            RasaDataGenerator._create_default_array()
+                        ] * tuple_sizes[key]
                     else:
-                        batch_data.append(None)
+                        batch_data.append(RasaDataGenerator._create_default_array())
                     continue
 
                 for v in f_data:
@@ -409,8 +420,10 @@ class RasaBatchDataGenerator(RasaDataGenerator):
         end = start + self._current_batch_size
 
         # return input and target data, as our target data is inside the input
-        # data return None for the target data
-        return self.prepare_batch(self._data, start, end), None
+        # data return default array for the target data
+        return self.prepare_batch(
+            self._data, start, end
+        ), RasaDataGenerator._create_default_array()
 
     def on_epoch_end(self) -> None:
         """Update the data after every epoch."""

rasa/utils/tensorflow/layers.py

@@ -3,9 +3,7 @@ from typing import Any, Callable, List, Optional, Text, Tuple, Union
 
 import tensorflow as tf
 import tensorflow.keras.backend as K
-
-# TODO: The following is not (yet) available via tf.keras
-from keras.src.utils.control_flow_util import smart_cond
+from tensorflow.python.keras.utils.control_flow_util import smart_cond
 
 import rasa.utils.tensorflow.crf
 import rasa.utils.tensorflow.layers_utils as layers_utils
@@ -278,6 +276,7 @@ class RandomlyConnectedDense(tf.keras.layers.Dense):
             kernel_constraint: Constraint function applied to
                 the `kernel` weights matrix.
             bias_constraint: Constraint function applied to the bias vector.
+            **kwargs: Additional keyword arguments passed to the parent class.
         """
         super().__init__(**kwargs)
 
@@ -367,7 +366,12 @@ class RandomlyConnectedDense(tf.keras.layers.Dense):
         Returns:
             The processed inputs.
         """
-        if self.density < 1.0:
+        # Apply kernel masking if needed (Keras 3.x compatibility check)
+        if (
+            self.density < 1.0
+            and hasattr(self, "kernel_mask")
+            and self.kernel_mask is not None
+        ):
             # Set fraction of the `kernel` weights to zero according to precomputed mask
             self.kernel.assign(self.kernel * self.kernel_mask)
         return super().call(inputs)
@@ -724,6 +728,7 @@ class DotProductLoss(tf.keras.layers.Layer):
                 Currently, the only possible value is `SOFTMAX`.
             similarity_type: Similarity measure to use, either `cosine` or `inner`.
             name: Optional name of the layer.
+            **kwargs: Additional keyword arguments passed to the parent class.
 
         Raises:
             TFLayerConfigException: When `similarity_type` is not one of `COSINE` or
@@ -883,6 +888,7 @@ class SingleLabelDotProductLoss(DotProductLoss):
                 values are approximately bounded.
             model_confidence: Normalization of confidence values during inference.
                 Currently, the only possible value is `SOFTMAX`.
+            **kwargs: Additional keyword arguments passed to the parent class.
         """
         super().__init__(
             num_candidates,
@@ -1244,6 +1250,7 @@ class MultiLabelDotProductLoss(DotProductLoss):
                 Used inside _loss_cross_entropy() only.
             model_confidence: Normalization of confidence values during inference.
                 Currently, the only possible value is `SOFTMAX`.
+            **kwargs: Additional keyword arguments passed to the parent class.
         """
         super().__init__(
             num_candidates,