datarobot-moderations 11.2.3__py3-none-any.whl → 11.2.5__py3-none-any.whl

datarobot_dome/async_http_client.py

@@ -28,6 +28,7 @@ from datarobot_dome.constants import DATAROBOT_CONFIGURED_ON_PREM_ST_SAAS_URL
 from datarobot_dome.constants import DATAROBOT_SERVERLESS_PLATFORM
 from datarobot_dome.constants import DEFAULT_GUARD_PREDICTION_TIMEOUT_IN_SEC
 from datarobot_dome.constants import LOGGER_NAME_PREFIX
+from datarobot_dome.constants import MODERATIONS_USER_AGENT
 from datarobot_dome.constants import RETRY_COUNT
 from datarobot_dome.constants import ModerationEventTypes
 
@@ -81,11 +82,13 @@ class AsyncHTTPClient:
             "Content-Type": "text/csv",
             "Accept": "text/csv",
             "Authorization": f"Bearer {os.environ['DATAROBOT_API_TOKEN']}",
+            "User-Agent": MODERATIONS_USER_AGENT,
         }
         self.json_headers = {
             "Content-Type": "application/json",
             "Accept": "application/json",
             "Authorization": f"Bearer {os.environ['DATAROBOT_API_TOKEN']}",
+            "User-Agent": MODERATIONS_USER_AGENT,
         }
         self.session = None
         self.events_url = f"{os.environ['DATAROBOT_ENDPOINT']}/remoteEvents/"
@@ -100,9 +103,9 @@ class AsyncHTTPClient:
                 asyncio.set_event_loop(self.loop)
             else:
                 raise
+        nest_asyncio.apply(loop=self.loop)
         self.loop.run_until_complete(self.__create_client_session(timeout))
         self.loop.set_debug(True)
-        nest_asyncio.apply(loop=self.loop)
 
         atexit.register(self.shutdown)
 

datarobot_dome/constants.py

@@ -10,9 +10,12 @@
 #  https://www.datarobot.com/wp-content/uploads/2021/07/DataRobot-Tool-and-Utility-Agreement.pdf.
 #  ---------------------------------------------------------------------------------
 from enum import Enum
+from importlib.metadata import version
 
 __GUARD_ASSOCIATION_IDS_COLUMN_NAME__ = "datarobot_guard_association_id"
 
+MODERATIONS_USER_AGENT = f"datarobot-moderations:{version('datarobot-moderations')}"
+
 LOGGER_NAME_PREFIX = "moderations"
 
 DEFAULT_PROMPT_COLUMN_NAME = "promptText"
@@ -71,6 +74,8 @@ PROMPT_TOKEN_COUNT_COLUMN_NAME_FROM_USAGE = "prompt_token_count_from_usage"
 RESPONSE_TOKEN_COUNT_COLUMN_NAME_FROM_USAGE = "response_token_count_from_usage"
 
 SPAN_PREFIX = "datarobot.guard"
+DATAROBOT_ASSOCIATION_ID_FIELD_NAME = "datarobot_association_id"
+DATAROBOT_METRICS_DICT_FIELD_NAME = "datarobot_metrics"
 
 
 class TargetType(str, Enum):

datarobot_dome/drum_integration.py

@@ -24,6 +24,7 @@ import numpy as np
 import pandas as pd
 import yaml
 from openai.types.chat import ChatCompletionChunk
+from openai.types.chat import CompletionCreateParams
 from openai.types.chat.chat_completion import ChatCompletion
 from openai.types.chat.chat_completion import Choice
 from openai.types.chat.chat_completion_message import ChatCompletionMessage
@@ -40,6 +41,8 @@ from datarobot_dome.chat_helper import run_postscore_guards
 from datarobot_dome.constants import AGENTIC_PIPELINE_INTERACTIONS_ATTR
 from datarobot_dome.constants import CHAT_COMPLETION_OBJECT
 from datarobot_dome.constants import CITATIONS_ATTR
+from datarobot_dome.constants import DATAROBOT_ASSOCIATION_ID_FIELD_NAME
+from datarobot_dome.constants import DATAROBOT_METRICS_DICT_FIELD_NAME
 from datarobot_dome.constants import DATAROBOT_MODERATIONS_ATTR
 from datarobot_dome.constants import DISABLE_MODERATION_RUNTIME_PARAM_NAME
 from datarobot_dome.constants import LLM_BLUEPRINT_ID_ATTR
@@ -590,6 +593,29 @@ def _set_moderation_attribute_to_completion(pipeline, chat_completion, df, assoc
 
 
 def get_chat_prompt(completion_create_params):
+    """
+    Validate and extract the user prompt from completion create parameters (CCP).
+    Include tool calls if they were provided.
+
+    CCP "messages" list must be non-empty and include content with "user" role.
+    Example: "messages": [{"role": "user", "content": "What is the meaning of life?"}]
+
+    :param completion_create_params: dict containing chat request
+    :return: constructed prompt based on CCP content.
+    :raise ValueError if completion create parameters is not valid.
+    """
+    # ensure message content exists
+    if (
+        "messages" not in completion_create_params
+        or completion_create_params["messages"] is None
+        or len(completion_create_params["messages"]) == 0
+        or not isinstance(completion_create_params["messages"][-1], dict)
+        or "content" not in completion_create_params["messages"][-1]
+    ):
+        raise ValueError(
+            f"Chat input for moderation does not contain a message: {completion_create_params}"
+        )
+
     # Get the prompt with role = User
     last_user_message = None
     tool_calls = []
@@ -599,7 +625,7 @@ def get_chat_prompt(completion_create_params):
         if message["role"] == "tool":
             tool_calls.append(f"{message.get('name', '')}_{message['content']}")
     if last_user_message is None:
-        raise Exception("No message with 'user' role found in input")
+        raise ValueError("No message with 'user' role found in input")
 
     prompt_content = last_user_message["content"]
     tool_names = []
@@ -623,7 +649,7 @@ def get_chat_prompt(completion_create_params):
             concatenated_prompt.append(message)
         chat_prompt = "\n".join(concatenated_prompt)
     else:
-        raise Exception(f"Unhandled prompt type: {type(prompt_content)}")
+        raise ValueError(f"Unhandled prompt type: {type(prompt_content)}")
 
     if len(tool_calls) > 0:
         # Lets not add tool names if tool calls are present.  Tool calls are more
@@ -693,32 +719,91 @@ def report_otel_evaluation_set_metric(pipeline, result_df):
     current_span.set_attribute("datarobot.moderation.evaluation", json.dumps(final_value))
 
 
+def filter_extra_body(
+    completion_create_params: CompletionCreateParams,
+) -> tuple[CompletionCreateParams, dict]:
+    """
+    completion_create_params is a typed dict of a few standard fields,
+    and arbitrary fields from extra_body.
+    If "datarobot_metrics" is in extra_body, process it here.
+    Save its value only if it is a dict as expected.
+    :param completion_create_params: the chat completion params from OpenAI client via DRUM
+    :return: filtered completion_create_params; dict of {name: value} for "datarobot_" fields
+    """
+    datarobot_extra_body_params = {}
+    name = DATAROBOT_METRICS_DICT_FIELD_NAME
+    if name in completion_create_params:
+        value = completion_create_params[name]
+        _logger.debug("found DataRobot metrics in extra_body: %s", f"{name}={value}")
+        if isinstance(value, dict):
+            datarobot_extra_body_params = copy.deepcopy(value)
+        else:
+            _logger.warning("DataRobot metrics in extra_body is not a dict: %s", f"{name}={value}")
+        completion_create_params.pop(name, None)
+    return completion_create_params, datarobot_extra_body_params
+
+
+def filter_association_id(
+    completion_create_params: CompletionCreateParams,
+) -> tuple[CompletionCreateParams, str | None]:
+    """
+    completion_create_params (CCP) is a typed dict of a few standard fields,
+    and arbitrary fields from extra_body.
+    If a field for the association ID exists, extract that value and remove it from the CCP.
+    Do this before calling filter_extra_body(), which would otherwise capture the association ID.
+    :param completion_create_params: the chat completion params from OpenAI client via DRUM
+    :return: filtered completion_create_params, association ID value
+
+    If no association ID was found in extra body: return original CCP,None
+    """
+    name = DATAROBOT_ASSOCIATION_ID_FIELD_NAME
+    if name in completion_create_params:
+        value = completion_create_params[name]
+        _logger.debug("found association ID in extra_body: %s", f"{name}={value}")
+        completion_create_params.pop(name, None)
+        return completion_create_params, value
+    return completion_create_params, None
+
+
 def guard_chat_wrapper(
     completion_create_params, model, pipeline, drum_chat_fn, association_id=None, **kwargs
 ):
+    # if association ID was included in extra_body, extract field name and value
+    completion_create_params, eb_assoc_id_value = filter_association_id(completion_create_params)
+
+    # extract any fields mentioned in "datarobot_metrics" to send as custom metrics later
+    completion_create_params, chat_extra_body_params = filter_extra_body(completion_create_params)
+
+    # register them for ID lookup later
+    pipeline.add_extra_body_custom_metric_definition(chat_extra_body_params)
+
+    # define all pipeline-based and guard-based custom metrics (but not those from extra_body)
+    # sends single API request to look up IDs for all custom metrics (including extra_body)
     pipeline.get_new_metrics_payload()
 
+    # the chat request is not a dataframe, but we'll build a DF internally for moderation.
     prompt_column_name = pipeline.get_input_column(GuardStage.PROMPT)
-    if (
-        "messages" not in completion_create_params
-        or completion_create_params["messages"] is None
-        or len(completion_create_params["messages"]) == 0
-        or not isinstance(completion_create_params["messages"][-1], dict)
-        or "content" not in completion_create_params["messages"][-1]
-    ):
-        raise ValueError(f"Invalid chat input for moderation: {completion_create_params}")
-
     prompt = get_chat_prompt(completion_create_params)
     streaming_response_requested = completion_create_params.get("stream", False)
 
     data = pd.DataFrame({prompt_column_name: [prompt]})
+    # for association IDs (with or without extra_body): the column must be defined in the deployment
+    # (here, this means pipeline.get_association_id_column_name() ("standard name") is not empty.)
+    # there are 3 likely cases for association ID, and 1 corner case:
+    # 1. ID value not provided (drum or extra_body) => no association ID column
+    # 2. ID value provided by DRUM => new DF column with standard name and provided value
+    # 3. ID defined in extra_body => new DF column with standard name and extra_body value
+    # 4. ID in extra_body with empty value => no association ID column
+    # Moderation library no longer auto-generates an association ID for chat. However, DRUM does.
     association_id_column_name = pipeline.get_association_id_column_name()
+    association_id = eb_assoc_id_value or association_id
     if association_id_column_name:
         if association_id:
             data[association_id_column_name] = [association_id]
-        elif pipeline.auto_generate_association_ids:
-            data[association_id_column_name] = pipeline.generate_association_ids(1)
-            association_id = data[association_id_column_name].tolist()[0]
+
+    # report any metrics from extra_body. They are not tied to a prompt or response phase.
+    _logger.debug("Report extra_body params as custom metrics")
+    pipeline.report_custom_metrics_from_extra_body(association_id, chat_extra_body_params)
 
     # ==================================================================
     # Step 1: Prescore Guards processing
@@ -890,7 +975,13 @@ def init(model_dir: str = os.getcwd()):
 
 
 class ModerationPipeline:
-    """Base class to simplify interactions with DRUM."""
+    """
+    Base class to simplify interactions with DRUM.
+    This class is not used outside of testing;
+    moderation_pipeline_factory() will select the LLM or VDB subclass instead.
+    Also: Pipeline and ModerationPipeline are separate classes (not in samm hierarchy)
+    However, LlmModerationPipeline includes LLMPipeline by composition.
+    """
 
     def score(self, input_df: pd.DataFrame, model, drum_score_fn, **kwargs):
         """Default score function just runs the DRUM score function."""
@@ -898,7 +989,7 @@ class ModerationPipeline:
 
     def chat(
         self,
-        completion_create_params: pd.DataFrame,
+        completion_create_params: CompletionCreateParams,
         model,
         drum_chat_fn,
         association_id: str = None,
@@ -920,13 +1011,16 @@ class LlmModerationPipeline(ModerationPipeline):
 
     def chat(
         self,
-        completion_create_params: pd.DataFrame,
+        completion_create_params: CompletionCreateParams,
         model,
         drum_chat_fn,
         association_id=None,
         **kwargs,
     ):
-        """Calls the standard guard chat function."""
+        """
+        Calls the standard guard chat function.
+        See PythonModelAdapter.chat() in DRUM, which calls chat() here.
+        """
         return guard_chat_wrapper(
             completion_create_params,
             model,
@@ -949,6 +1043,14 @@ class VdbModerationPipeline(ModerationPipeline):
 def moderation_pipeline_factory(
     target_type: str, model_dir: str = os.getcwd()
 ) -> Optional[ModerationPipeline]:
+    """
+    Create and return a moderation pipeline based on model target type.
+    This function is the main integration point with DRUM;
+    called by DRUM's PythonModelAdapter._load_moderation_hooks.
+    :param target_type: usually textgen, agentic, or vdb
+    :param model_dir:
+    :return:
+    """
     # Disable ragas and deepeval tracking while loading the module.
     os.environ["RAGAS_DO_NOT_TRACK"] = "true"
     os.environ["DEEPEVAL_TELEMETRY_OPT_OUT"] = "YES"

datarobot_dome/pipeline/llm_pipeline.py

@@ -113,7 +113,7 @@ class LLMPipeline(Pipeline):
         self._custom_model_dir = os.path.dirname(guards_config_filename)
 
         self._modifier_guard_seen = {stage: None for stage in GuardStage.ALL}
-        self.auto_generate_association_ids = False
+        self.auto_generate_association_ids = False  # used for score, but not used for chat
 
         # Dictionary of async http clients per process - its important to maintain
         # this when moderation is running with CUSTOM_MODEL_WORKERS > 1
@@ -197,17 +197,17 @@ class LLMPipeline(Pipeline):
 
         if guard.has_average_score_custom_metric():
             metric_def = self._get_average_score_metric_definition(guard)
-            self.add_custom_metric(metric_def, True)
+            self.add_custom_metric_definition(metric_def, True)
 
         if guard.has_latency_custom_metric():
             metric_def = guard.get_latency_custom_metric()
-            self.add_custom_metric(metric_def, False)
+            self.add_custom_metric_definition(metric_def, False)
 
         if intervention_action:
             # Enforced metric for all kinds of guards, as long as they have intervention
             # action defined - even for token count
             metric_def = guard.get_enforced_custom_metric(guard_stage, intervention_action)
-            self.add_custom_metric(metric_def, True)
+            self.add_custom_metric_definition(metric_def, True)
 
     def _add_default_custom_metrics(self):
         """Default custom metrics"""
@@ -219,14 +219,14 @@ class LLMPipeline(Pipeline):
             postscore_guard_latency_custom_metric,
             score_latency,
         ]:
-            self.add_custom_metric(metric_def, False)
+            self.add_custom_metric_definition(metric_def, False)
 
         # These metrics report with an association-id
         for metric_def in [
             get_blocked_custom_metric(GuardStage.PROMPT),
             get_blocked_custom_metric(GuardStage.RESPONSE),
         ]:
-            self.add_custom_metric(metric_def, True)
+            self.add_custom_metric_definition(metric_def, True)
 
     def _add_guard_to_pipeline(self, guard):
         if guard.stage == GuardStage.PROMPT:
@@ -380,6 +380,55 @@ class LLMPipeline(Pipeline):
             buckets = self._add_guard_specific_custom_metrics(row, self.get_postscore_guards())
             payload["buckets"].extend(buckets)
 
+    def add_extra_body_custom_metric_definition(self, chat_extra_body_params: dict) -> None:
+        """
+        For each name found in extra_body earlier, add to the internal map for reporting later.
+        Custom metric IDs are looked up in create_custom_metrics().
+        :param chat_extra_body_params: dict of name=value pairs
+        """
+        for name in chat_extra_body_params.keys():
+            self.extra_body_custom_metric_map[name] = {"id": None}
+
+    def report_custom_metrics_from_extra_body(
+        self, association_id: str, extra_params: dict
+    ) -> None:
+        """
+        Add any key-value pairs extracted from extra_body as custom metrics.
+        :param association_id: Association ID of the chat request
+        :param extra_params: a dict of {"name": value} for all extra_body parameters found
+        """
+        # If no association ID is defined for deployment, custom metrics will not be processed
+        if self._association_id_column_name is None:
+            return
+        if not extra_params:
+            return  # nothing to send
+        payload = {"buckets": []}
+        for name, value in extra_params.items():
+            if name in self.custom_metric_map:
+                # In case of name collision:
+                # the extra_body metric will _not_ override the other moderation metric
+                self._logger.warning(
+                    "extra_body custom metric name is already in use in moderation; "
+                    f"will not be sent: {name}"
+                )
+                continue
+            if name not in self.extra_body_custom_metric_map:
+                self._logger.warning(f"extra_body custom metric ID not in map: {name}")
+                continue
+            metric_id = self.extra_body_custom_metric_map[name].get("id")
+            if not metric_id:
+                self._logger.warning(f"extra_body custom metric has missing ID: {name}")
+                continue
+            payload["buckets"].append(
+                {
+                    "customMetricId": metric_id,
+                    "value": value,
+                    "associationId": association_id,
+                }
+            )
+        self._logger.debug(f"Sending custom metrics payload from extra_body: {payload}")
+        self.upload_custom_metrics(payload)
+
     def report_custom_metrics(self, result_df):
         if self.delayed_custom_metric_creation:
             # Flag is not set yet, so no point reporting custom metrics

datarobot_dome/pipeline/pipeline.py

@@ -29,6 +29,7 @@ from datarobot.models.deployment import CustomMetric
 from datarobot_dome.async_http_client import AsyncHTTPClient
 from datarobot_dome.constants import DEFAULT_GUARD_PREDICTION_TIMEOUT_IN_SEC
 from datarobot_dome.constants import LOGGER_NAME_PREFIX
+from datarobot_dome.constants import MODERATIONS_USER_AGENT
 from datarobot_dome.constants import ModerationEventTypes
 
 CUSTOM_METRICS_BULK_UPLOAD_API_PREFIX = "deployments"
@@ -40,7 +41,6 @@ class Pipeline:
 
     def __init__(self, async_http_timeout_sec=DEFAULT_GUARD_PREDICTION_TIMEOUT_IN_SEC):
         self._logger = logging.getLogger(LOGGER_NAME_PREFIX + "." + self.__class__.__name__)
-        self.custom_metric = {}
         self._deployment = None
         self._association_id_column_name = None
         self._datarobot_url = None
@@ -53,6 +53,8 @@ class Pipeline:
         self._custom_metrics_bulk_upload_url = None
         self.aggregate_custom_metric = None
         self.custom_metric_map = dict()
+        # even though only LLMPipeline really uses the next map, Pipeline still references it
+        self.extra_body_custom_metric_map = dict()
         self.delayed_custom_metric_creation = False
         self.upload_custom_metrics_tasks = set()
 
@@ -76,11 +78,19 @@ class Pipeline:
             self._logger.warning(f"Missing DataRobot API Token, {self.common_message}")
             return
 
+        self._deployment_id = os.environ.get("MLOPS_DEPLOYMENT_ID", None)
+        if self._deployment_id is None:
+            self._logger.warning(
+                f"DataRobot deployment id not exported (MLOPS_DEPLOYMENT_ID), {self.common_message}"
+            )
+            return
+
         # This is regular / default DataRobot Client
         self.dr_client = dr.Client(endpoint=self._datarobot_url, token=self._datarobot_api_token)
         self._headers = {
             "Content-Type": "application/json",
             "Authorization": f"Bearer {self._datarobot_api_token}",
+            "User-Agent": MODERATIONS_USER_AGENT,
         }
 
     def _query_self_deployment(self):
@@ -89,7 +99,6 @@ class Pipeline:
         moderations for
         :return:
         """
-        self._deployment_id = os.environ.get("MLOPS_DEPLOYMENT_ID", None)
         if self._deployment_id is None:
             self._logger.warning(f'Custom Model workshop "test" mode?, {self.common_message}')
             return
@@ -170,13 +179,17 @@ class Pipeline:
             self.create_custom_metrics()
             self.delayed_custom_metric_creation = False
 
-    def add_custom_metric(
+    def add_custom_metric_definition(
         self, metric_definition: dict[str, Any], requires_association_id: bool, **kwargs
     ) -> None:
         """
         Adds an entry to the `custom_metric_map`.
+        Only 2 functions should write to this map:
+        * this function -- links the custom metric definition to its name
+        * create_custom_metrics() -- queries DR for the object ID and links it to the name
 
         NOTE: the kwargs allow implementations to add their own specialized values.
+        Currently only VDBPipeline calls this with kwargs.
         """
         name = metric_definition["name"]
         self.custom_metric_map[name] = {
@@ -191,6 +204,8 @@ class Pipeline:
 
         Updates the `custom_metric_map` with id's to insure the appropriate data
         is put in place for reporting.
+
+        Every custom metric we want to use must already exist by name in the map.
         """
         cleanup_metrics_list = list()
         for index, (metric_name, custom_metric) in enumerate(self.custom_metric_map.items()):
@@ -254,6 +269,10 @@ class Pipeline:
         # required in case a metric is duplicated, in which case, we don't have its
         # id in the loop above
         #
+        # Note: user-defined custom metrics (such as for extra_body params) will also
+        # be included in the list. We will warn if an existing metric is not found
+        # in either list, which means this chat request does not have a value for it.
+        #
         # We have to go through pagination - dmm list_custom_metrics does not implement
         # pagination
         custom_metrics_list = []
@@ -267,12 +286,19 @@ class Pipeline:
             if response_list["next"] is None:
                 break
 
+        # assign IDs to the "metric by name" maps so we can upload by ID later
         for metric in custom_metrics_list:
             metric_name = metric["name"]
-            if metric_name not in self.custom_metric_map:
-                self._logger.error(f"Metric '{metric_name}' exists at DR but not in moderation")
+            if metric_name in self.custom_metric_map:
+                self.custom_metric_map[metric_name]["id"] = metric["id"]
+            elif metric_name in self.extra_body_custom_metric_map:
+                self.extra_body_custom_metric_map[metric_name]["id"] = metric["id"]
+            else:
+                self._logger.warning(
+                    f"Metric '{metric_name}' exists at DR but not in moderation; "
+                    "no value will be reported"
+                )
                 continue
-            self.custom_metric_map[metric_name]["id"] = metric["id"]
 
         # These are the metrics we couldn't create - so, don't track them
         for metric_name in cleanup_metrics_list:

datarobot_dome/pipeline/vdb_pipeline.py

@@ -70,7 +70,7 @@ class VDBPipeline(Pipeline):
 
         # Metric list so far does not need association id for reporting
         for metric_def, per_row, score_type in metric_list:
-            self.add_custom_metric(metric_def, per_row, scorer_type=score_type)
+            self.add_custom_metric_definition(metric_def, per_row, scorer_type=score_type)
 
     def create_scorers(self):
         """

{datarobot_moderations-11.2.3.dist-info → datarobot_moderations-11.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: datarobot-moderations
-Version: 11.2.3
+Version: 11.2.5
 Summary: DataRobot Monitoring and Moderation framework
 License: DataRobot Tool and Utility Agreement
 Author: DataRobot
@@ -19,7 +19,7 @@ Requires-Dist: deepeval (>=3.3.5)
 Requires-Dist: langchain (>=0.1.12)
 Requires-Dist: langchain-nvidia-ai-endpoints (>=0.3.9)
 Requires-Dist: langchain-openai (>=0.1.7)
-Requires-Dist: llama-index (>=0.12.49)
+Requires-Dist: llama-index (>=0.13.0)
 Requires-Dist: llama-index-embeddings-azure-openai (>=0.1.6)
 Requires-Dist: llama-index-llms-bedrock-converse (>=0.1.6)
 Requires-Dist: llama-index-llms-langchain (>=0.1.3)

{datarobot_moderations-11.2.3.dist-info → datarobot_moderations-11.2.5.dist-info}/RECORD

@@ -1,8 +1,8 @@
 datarobot_dome/__init__.py,sha256=B5Rx8_CNCNsOpxBbRj27XOXCfRZmvmrAR-NzlzIKnDw,583
-datarobot_dome/async_http_client.py,sha256=wkB4irwvnchNGzO1bk2C_HWM-GOSB3AUn5TXKl-X0ZI,9649
+datarobot_dome/async_http_client.py,sha256=cQFoSI2ovt0Kyk4XWQPXod5PAfA-ZPkjLYVWQZhDGDE,9809
 datarobot_dome/chat_helper.py,sha256=BzvtUyZSZxzOqq-5a2wQKhHhr2kMlcP1MFrHaDAeD_o,9671
-datarobot_dome/constants.py,sha256=vM2_JkXbn4dkWARCqxNfLriSo0E05LDXVrwNktptpuc,10416
-datarobot_dome/drum_integration.py,sha256=BnhAP-D4AaEeh4ferZ-qXnORuWQzYzw9qKAZUTZZnJU,40542
+datarobot_dome/constants.py,sha256=jvgpHa3Wh_nZVZmfU-6ab8FHnKNW3KxOPYIIEb_oS6U,10662
+datarobot_dome/drum_integration.py,sha256=DIGeiw6fwKCbgi6mb-mJdjPEB6C1uMc-pZotpTnlGZQ,45770
 datarobot_dome/guard.py,sha256=xJds9hcbUaS-KD5nC1mn0GiPdBrileFUu6BuTAjDNuY,34668
 datarobot_dome/guard_executor.py,sha256=ox5_jOHcqMaxaaagIYJJHhCwEI7Wg-rUEiu5rutsfVU,35363
 datarobot_dome/guard_helpers.py,sha256=jfu8JTWCcxu4WD1MKxeP1n53DeebY3SSuP-t5sWyV1U,17187
@@ -14,11 +14,11 @@ datarobot_dome/metrics/citation_metrics.py,sha256=l2mnV1gz7nQeJ_yfaS4dcP3DFWf0p5
 datarobot_dome/metrics/factory.py,sha256=7caa8paI9LuFXDgguXdC4on28V7IwwIsKJT2Z-Aps8A,2187
 datarobot_dome/metrics/metric_scorer.py,sha256=uJ_IJRw7ZFHueg8xjsaXbt0ypO7JiydZ0WapCp96yng,2540
 datarobot_dome/pipeline/__init__.py,sha256=B5Rx8_CNCNsOpxBbRj27XOXCfRZmvmrAR-NzlzIKnDw,583
-datarobot_dome/pipeline/llm_pipeline.py,sha256=DMZ4gu88MiSSEQtshDyHOzT3R2Seuf8UqZ7A36QHj3M,18772
-datarobot_dome/pipeline/pipeline.py,sha256=7UmvrZtNxTGewpgM4cf2oThHPoJSarEU1Dyp7xEsASU,17401
-datarobot_dome/pipeline/vdb_pipeline.py,sha256=q3c_Z-hGUqhH6j6n8VpS3wZiBIkWgpRDsBnyJyZhiw4,9855
+datarobot_dome/pipeline/llm_pipeline.py,sha256=g8XZQjJPPs43GPqaBG4TtsCbvu1o7TWraOmzhtUGB_o,21172
+datarobot_dome/pipeline/pipeline.py,sha256=iDR6h25RDp4bnTW1eGWErG9W_ZXDdJ_sQGVD-tT_Ll0,18805
+datarobot_dome/pipeline/vdb_pipeline.py,sha256=zt5d_41oJjdT8qOtvpgz-l5uvImwKE9f6pQsAU_TdR4,9866
 datarobot_dome/runtime.py,sha256=FD8wXOweqoQVzbZMh-mucL66xT2kGxPsJUGAcJBgwxw,1468
 datarobot_dome/streaming.py,sha256=DkvKEH0yN0aPEWMTAjMFJB3Kx4iLGdjUMQU1pAplbeg,17751
-datarobot_moderations-11.2.3.dist-info/METADATA,sha256=dzpTYxhAXg-NEm8Rrko8U8qvbQncQoGw93a9ZhWV3jo,4742
-datarobot_moderations-11.2.3.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-datarobot_moderations-11.2.3.dist-info/RECORD,,
+datarobot_moderations-11.2.5.dist-info/METADATA,sha256=9Aj3fZnLvcgKpiAQwnvkkAzA3SxaBq2j45ctWEMCEaI,4741
+datarobot_moderations-11.2.5.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+datarobot_moderations-11.2.5.dist-info/RECORD,,

{datarobot_moderations-11.2.3.dist-info → datarobot_moderations-11.2.5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: true
 Tag: py3-none-any