generated_descriptors.py
1 from typing import Any 2 from typing import Dict 3 from typing import List 4 from typing import Optional 5 from typing import Type 6 from typing import Union 7 8 from evidently.core.datasets import DescriptorTest 9 from evidently.core.datasets import FeatureDescriptor 10 from evidently.core.tests import GenericTest 11 from evidently.legacy.core import ColumnType 12 from evidently.legacy.features.llm_judge import BaseLLMPromptTemplate 13 from evidently.legacy.features.llm_judge import Uncertainty 14 15 16 def BERTScore( 17 columns: List[str], 18 model: str = "bert-base-uncased", 19 tfidf_weighted: bool = False, 20 alias: Optional[str] = None, 21 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 22 ): 23 """Compute BERTScore similarity between text columns. 24 25 Args: 26 * `columns`: List of column names to compare. 27 * `model`: Pretrained BERT model name. 28 * `tfidf_weighted`: Whether to weight embeddings with IDF. 29 * `alias`: Optional alias for the descriptor. 30 * `tests`: Optional list of tests to apply. 31 """ 32 from evidently.legacy.features.BERTScore_feature import BERTScoreFeature as BERTScoreFeatureV1 33 34 feature = BERTScoreFeatureV1(columns=columns, model=model, tfidf_weighted=tfidf_weighted, display_name=alias) 35 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 36 37 38 def BeginsWith( 39 column_name: str, 40 prefix: str, 41 case_sensitive: bool = True, 42 alias: Optional[str] = None, 43 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 44 ): 45 """Check if text column values begin with the specified prefix. 46 47 Args: 48 * `column_name`: Name of the text column to check. 49 * `prefix`: Prefix string to match. 50 * `case_sensitive`: Whether matching is case-sensitive. 51 * `alias`: Optional alias for the descriptor. 52 * `tests`: Optional list of tests to apply. 53 """ 54 from evidently.legacy.features.text_part_feature import BeginsWith as BeginsWithV1 55 56 feature = BeginsWithV1(column_name=column_name, prefix=prefix, case_sensitive=case_sensitive, display_name=alias) 57 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 58 59 60 def Contains( 61 column_name: str, 62 items: List[str], 63 case_sensitive: bool = True, 64 mode: str = "any", 65 alias: Optional[str] = None, 66 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 67 ): 68 """Check if text column contains any or all of the specified items. 69 70 Args: 71 * `column_name`: Name of the text column to check. 72 * `items`: List of strings to search for. 73 * `case_sensitive`: Whether matching is case-sensitive. 74 * `mode`: Matching mode: "any" or "all". 75 * `alias`: Optional alias for the descriptor. 76 * `tests`: Optional list of tests to apply. 77 """ 78 from evidently.legacy.features.text_contains_feature import Contains as ContainsV1 79 80 feature = ContainsV1( 81 column_name=column_name, items=items, case_sensitive=case_sensitive, mode=mode, display_name=alias 82 ) 83 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 84 85 86 def ContainsLink( 87 column_name: str, alias: Optional[str] = None, tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None 88 ): 89 """Check if text column contains URLs or links. 90 91 Args: 92 * `column_name`: Name of the text column to check. 93 * `alias`: Optional alias for the descriptor. 94 * `tests`: Optional list of tests to apply. 95 """ 96 from evidently.legacy.features.contains_link_feature import ContainsLink as ContainsLinkV1 97 98 feature = ContainsLinkV1(column_name=column_name, display_name=alias) 99 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 100 101 102 def DoesNotContain( 103 column_name: str, 104 items: List[str], 105 case_sensitive: bool = True, 106 mode: str = "any", 107 alias: Optional[str] = None, 108 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 109 ): 110 """Check if text column does not contain specified items. 111 112 Args: 113 * `column_name`: Name of the text column to check. 114 * `items`: List of strings to search for. 115 * `case_sensitive`: Whether matching is case-sensitive. 116 * `mode`: Matching mode: "any" or "all". 117 * `alias`: Optional alias for the descriptor. 118 * `tests`: Optional list of tests to apply. 119 """ 120 from evidently.legacy.features.text_contains_feature import DoesNotContain as DoesNotContainV1 121 122 feature = DoesNotContainV1( 123 column_name=column_name, items=items, case_sensitive=case_sensitive, mode=mode, display_name=alias 124 ) 125 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 126 127 128 def EndsWith( 129 column_name: str, 130 suffix: str, 131 case_sensitive: bool = True, 132 alias: Optional[str] = None, 133 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 134 ): 135 """Check if text column values end with the specified suffix. 136 137 Args: 138 * `column_name`: Name of the text column to check. 139 * `suffix`: Suffix string to match. 140 * `case_sensitive`: Whether matching is case-sensitive. 141 * `alias`: Optional alias for the descriptor. 142 * `tests`: Optional list of tests to apply. 143 """ 144 from evidently.legacy.features.text_part_feature import EndsWith as EndsWithV1 145 146 feature = EndsWithV1(column_name=column_name, suffix=suffix, case_sensitive=case_sensitive, display_name=alias) 147 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 148 149 150 def ExactMatch( 151 columns: List[str], 152 alias: Optional[str] = None, 153 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 154 ): 155 """Check if multiple columns have exactly matching values. 156 157 Args: 158 * `columns`: List of column names to compare. 159 * `alias`: Optional alias for the descriptor. 160 * `tests`: Optional list of tests to apply. 161 """ 162 from evidently.legacy.features.exact_match_feature import ExactMatchFeature as ExactMatchFeatureV1 163 164 feature = ExactMatchFeatureV1(columns=columns, display_name=alias) 165 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 166 167 168 def ExcludesWords( 169 column_name: str, 170 words_list: List[str], 171 mode: str = "any", 172 lemmatize: bool = True, 173 alias: Optional[str] = None, 174 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 175 ): 176 """Check if text column excludes specified words. 177 178 Args: 179 * `column_name`: Name of the text column to check. 180 * `words_list`: List of words to check for exclusion. 181 * `mode`: Matching mode: "any" or "all". 182 * `lemmatize`: Whether to lemmatize words before matching. 183 * `alias`: Optional alias for the descriptor. 184 * `tests`: Optional list of tests to apply. 185 """ 186 from evidently.legacy.features.words_feature import ExcludesWords as ExcludesWordsV1 187 188 feature = ExcludesWordsV1( 189 column_name=column_name, words_list=words_list, mode=mode, lemmatize=lemmatize, display_name=alias 190 ) 191 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 192 193 194 def HuggingFace( 195 column_name: str, 196 model: str, 197 params: dict, 198 alias: str, 199 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 200 ): 201 """Apply a HuggingFace model to text column. 202 203 Args: 204 * `column_name`: Name of the text column to process. 205 * `model`: HuggingFace model name or path. 206 * `params`: Additional parameters for the model. 207 * `alias`: Alias for the descriptor. 208 * `tests`: Optional list of tests to apply. 209 """ 210 from evidently.legacy.features.hf_feature import HuggingFaceFeature as HuggingFaceFeatureV1 211 212 feature = HuggingFaceFeatureV1(column_name=column_name, model=model, params=params, display_name=alias) 213 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 214 215 216 def HuggingFaceToxicity( 217 column_name: str, 218 alias: str, 219 model: Optional[str] = None, 220 toxic_label: Optional[str] = None, 221 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 222 ): 223 """Detect toxicity in text using HuggingFace models. 224 225 Args: 226 * `column_name`: Name of the text column to check. 227 * `alias`: Alias for the descriptor. 228 * `model`: HuggingFace model name or path. If None, uses default. 229 * `toxic_label`: Label to use for toxic predictions. 230 * `tests`: Optional list of tests to apply. 231 """ 232 from evidently.legacy.features.hf_feature import HuggingFaceToxicityFeature as HuggingFaceToxicityFeatureV1 233 234 feature = HuggingFaceToxicityFeatureV1( 235 column_name=column_name, model=model, toxic_label=toxic_label, display_name=alias 236 ) 237 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 238 239 240 def IncludesWords( 241 column_name: str, 242 words_list: List[str], 243 mode: str = "any", 244 lemmatize: bool = True, 245 alias: Optional[str] = None, 246 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 247 ): 248 """Check if text column includes specified words. 249 250 Args: 251 * `column_name`: Name of the text column to check. 252 * `words_list`: List of words to search for. 253 * `mode`: Matching mode: "any" or "all". 254 * `lemmatize`: Whether to lemmatize words before matching. 255 * `alias`: Optional alias for the descriptor. 256 * `tests`: Optional list of tests to apply. 257 """ 258 from evidently.legacy.features.words_feature import IncludesWords as IncludesWordsV1 259 260 feature = IncludesWordsV1( 261 column_name=column_name, words_list=words_list, mode=mode, lemmatize=lemmatize, display_name=alias 262 ) 263 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 264 265 266 def IsValidJSON( 267 column_name: str, alias: Optional[str] = None, tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None 268 ): 269 """Check if text column contains valid JSON. 270 271 Args: 272 * `column_name`: Name of the text column to validate. 273 * `alias`: Optional alias for the descriptor. 274 * `tests`: Optional list of tests to apply. 275 """ 276 from evidently.legacy.features.is_valid_json_feature import IsValidJSON as IsValidJSONV1 277 278 feature = IsValidJSONV1(column_name=column_name, display_name=alias) 279 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 280 281 282 def IsValidPython( 283 column_name: str, alias: Optional[str] = None, tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None 284 ): 285 """Check if text column contains valid Python code. 286 287 Args: 288 * `column_name`: Name of the text column to validate. 289 * `alias`: Optional alias for the descriptor. 290 * `tests`: Optional list of tests to apply. 291 """ 292 from evidently.legacy.features.is_valid_python_feature import IsValidPython as IsValidPythonV1 293 294 feature = IsValidPythonV1(column_name=column_name, display_name=alias) 295 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 296 297 298 def IsValidSQL( 299 column_name: str, alias: Optional[str] = None, tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None 300 ): 301 """Check if text column contains valid SQL. 302 303 Args: 304 * `column_name`: Name of the text column to validate. 305 * `alias`: Optional alias for the descriptor. 306 * `tests`: Optional list of tests to apply. 307 """ 308 from evidently.legacy.features.is_valid_sql_feature import IsValidSQL as IsValidSQLV1 309 310 feature = IsValidSQLV1(column_name=column_name, display_name=alias) 311 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 312 313 314 def ItemMatch( 315 columns: List[str], 316 case_sensitive: bool = True, 317 mode: str = "any", 318 alias: Optional[str] = None, 319 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 320 ): 321 """Check if items from one column match items in another column. 322 323 Args: 324 * `columns`: List of two column names to compare. 325 * `case_sensitive`: Whether matching is case-sensitive. 326 * `mode`: Matching mode: "any" or "all". 327 * `alias`: Optional alias for the descriptor. 328 * `tests`: Optional list of tests to apply. 329 """ 330 from evidently.legacy.features.text_contains_feature import ItemMatch as ItemMatchV1 331 332 feature = ItemMatchV1(columns=columns, case_sensitive=case_sensitive, mode=mode, display_name=alias) 333 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 334 335 336 def ItemNoMatch( 337 columns: List[str], 338 case_sensitive: bool = True, 339 mode: str = "any", 340 alias: Optional[str] = None, 341 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 342 ): 343 """Check if items from one column do not match items in another column. 344 345 Args: 346 * `columns`: List of two column names to compare. 347 * `case_sensitive`: Whether matching is case-sensitive. 348 * `mode`: Matching mode: "any" or "all". 349 * `alias`: Optional alias for the descriptor. 350 * `tests`: Optional list of tests to apply. 351 """ 352 from evidently.legacy.features.text_contains_feature import ItemNoMatch as ItemNoMatchV1 353 354 feature = ItemNoMatchV1(columns=columns, case_sensitive=case_sensitive, mode=mode, display_name=alias) 355 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 356 357 358 def JSONMatch( 359 first_column: str, 360 second_column: str, 361 feature_type: ColumnType = ColumnType.Categorical, 362 alias: Optional[str] = None, 363 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 364 ): 365 """Check if JSON values in two columns match. 366 367 Args: 368 * `first_column`: Name of the first JSON column. 369 * `second_column`: Name of the second JSON column. 370 * `feature_type`: Type of the output feature. 371 * `alias`: Optional alias for the descriptor. 372 * `tests`: Optional list of tests to apply. 373 """ 374 from evidently.legacy.features.json_match_feature import JSONMatch as JSONMatchV1 375 376 feature = JSONMatchV1( 377 first_column=first_column, second_column=second_column, feature_type=feature_type, display_name=alias 378 ) 379 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 380 381 382 def JSONSchemaMatch( 383 column_name: str, 384 expected_schema: Dict[str, Type], 385 validate_types: bool = False, 386 exact_match: bool = False, 387 alias: Optional[str] = None, 388 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 389 ): 390 """Check if JSON values match the expected schema. 391 392 Args: 393 * `column_name`: Name of the JSON column to validate. 394 * `expected_schema`: Dictionary mapping field names to expected types. 395 * `validate_types`: Whether to validate field types. 396 * `exact_match`: Whether schema must match exactly. 397 * `alias`: Optional alias for the descriptor. 398 * `tests`: Optional list of tests to apply. 399 """ 400 from evidently.legacy.features.json_schema_match_feature import JSONSchemaMatch as JSONSchemaMatchV1 401 402 feature = JSONSchemaMatchV1( 403 column_name=column_name, 404 expected_schema=expected_schema, 405 validate_types=validate_types, 406 exact_match=exact_match, 407 display_name=alias, 408 ) 409 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 410 411 412 def LLMJudge( 413 provider: str, 414 model: str, 415 template: BaseLLMPromptTemplate, 416 input_column: Optional[str] = None, 417 input_columns: Optional[Dict[str, str]] = None, 418 alias: Optional[str] = None, 419 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 420 ): 421 """Evaluate text using LLM with a custom prompt template. 422 423 Args: 424 * `provider`: LLM provider name (e.g., "openai", "anthropic"). 425 * `model`: Model name to use (e.g., "gpt-4o-mini"). 426 * `template`: Prompt template defining the evaluation task. 427 * `input_column`: Single input column name (if using single column). 428 * `input_columns`: Mapping of prompt variables to column names (if using multiple columns). 429 * `alias`: Optional alias for the descriptor. 430 * `tests`: Optional list of tests to apply. 431 """ 432 from evidently.legacy.features.llm_judge import LLMJudge as LLMJudgeV1 433 434 feature = LLMJudgeV1( 435 provider=provider, 436 model=model, 437 template=template, 438 input_column=input_column, 439 input_columns=input_columns, 440 display_name=alias, 441 ) 442 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 443 444 445 def NonLetterCharacterPercentage( 446 column_name: str, alias: Optional[str] = None, tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None 447 ): 448 """Compute percentage of non-letter characters in text. 449 450 Args: 451 * `column_name`: Name of the text column to analyze. 452 * `alias`: Optional alias for the descriptor. 453 * `tests`: Optional list of tests to apply. 454 """ 455 from evidently.legacy.features.non_letter_character_percentage_feature import ( 456 NonLetterCharacterPercentage as NonLetterCharacterPercentageV1, 457 ) 458 459 feature = NonLetterCharacterPercentageV1(column_name=column_name, display_name=alias) 460 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 461 462 463 def OOVWordsPercentage( 464 column_name: str, 465 ignore_words: Any = (), 466 alias: Optional[str] = None, 467 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 468 ): 469 """Compute percentage of out-of-vocabulary words in text. 470 471 Args: 472 * `column_name`: Name of the text column to analyze. 473 * `ignore_words`: Words to ignore when computing OOV percentage. 474 * `alias`: Optional alias for the descriptor. 475 * `tests`: Optional list of tests to apply. 476 """ 477 from evidently.legacy.features.OOV_words_percentage_feature import OOVWordsPercentage as OOVWordsPercentageV1 478 479 feature = OOVWordsPercentageV1(column_name=column_name, ignore_words=ignore_words, display_name=alias) 480 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 481 482 483 def OpenAI( 484 column_name: str, 485 model: str, 486 prompt: str, 487 feature_type: str, 488 context: Optional[str] = None, 489 context_column: Optional[str] = None, 490 prompt_replace_string: str = "REPLACE", 491 context_replace_string: str = "CONTEXT", 492 check_mode: str = "any_line", 493 possible_values: Optional[List[str]] = None, 494 openai_params: Optional[dict] = None, 495 alias: Optional[str] = None, 496 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 497 ): 498 """Evaluate text using OpenAI models with custom prompts. 499 500 Args: 501 * `column_name`: Name of the text column to evaluate. 502 * `model`: OpenAI model name to use. 503 * `prompt`: Prompt template string. 504 * `feature_type`: Type of output feature. 505 * `context`: Optional context string. 506 * `context_column`: Optional column name containing context. 507 * `prompt_replace_string`: String to replace in prompt with column value. 508 * `context_replace_string`: String to replace in prompt with context. 509 * `check_mode`: Mode for checking results: "any_line" or other modes. 510 * `possible_values`: Optional list of possible output values. 511 * `openai_params`: Optional dictionary of additional OpenAI API parameters. 512 * `alias`: Optional alias for the descriptor. 513 * `tests`: Optional list of tests to apply. 514 """ 515 from evidently.legacy.features.openai_feature import OpenAIFeature as OpenAIFeatureV1 516 517 feature = OpenAIFeatureV1( 518 column_name=column_name, 519 model=model, 520 prompt=prompt, 521 feature_type=feature_type, 522 context=context, 523 context_column=context_column, 524 prompt_replace_string=prompt_replace_string, 525 context_replace_string=context_replace_string, 526 check_mode=check_mode, 527 possible_values=possible_values, 528 openai_params=openai_params, 529 display_name=alias, 530 ) 531 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 532 533 534 def RegExp( 535 column_name: str, 536 reg_exp: str, 537 alias: Optional[str] = None, 538 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 539 ): 540 """Check if text matches a regular expression pattern. 541 542 Args: 543 * `column_name`: Name of the text column to check. 544 * `reg_exp`: Regular expression pattern to match. 545 * `alias`: Optional alias for the descriptor. 546 * `tests`: Optional list of tests to apply. 547 """ 548 from evidently.legacy.features.regexp_feature import RegExp as RegExpV1 549 550 feature = RegExpV1(column_name=column_name, reg_exp=reg_exp, display_name=alias) 551 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 552 553 554 def SemanticSimilarity( 555 columns: List[str], 556 model: str = "all-MiniLM-L6-v2", 557 alias: Optional[str] = None, 558 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 559 ): 560 """Compute semantic similarity between text columns. 561 562 Args: 563 * `columns`: List of column names to compare. 564 * `model`: Sentence transformer model name. 565 * `alias`: Optional alias for the descriptor. 566 * `tests`: Optional list of tests to apply. 567 """ 568 from evidently.legacy.features.semantic_similarity_feature import ( 569 SemanticSimilarityFeature as SemanticSimilarityFeatureV1, 570 ) 571 572 feature = SemanticSimilarityFeatureV1(columns=columns, model=model, display_name=alias) 573 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 574 575 576 def SentenceCount( 577 column_name: str, alias: Optional[str] = None, tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None 578 ): 579 """Count the number of sentences in text. 580 581 Args: 582 * `column_name`: Name of the text column to analyze. 583 * `alias`: Optional alias for the descriptor. 584 * `tests`: Optional list of tests to apply. 585 """ 586 from evidently.legacy.features.sentence_count_feature import SentenceCount as SentenceCountV1 587 588 feature = SentenceCountV1(column_name=column_name, display_name=alias) 589 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 590 591 592 def Sentiment( 593 column_name: str, alias: Optional[str] = None, tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None 594 ): 595 """Compute sentiment score for text. 596 597 Args: 598 * `column_name`: Name of the text column to analyze. 599 * `alias`: Optional alias for the descriptor. 600 * `tests`: Optional list of tests to apply. 601 """ 602 from evidently.legacy.features.sentiment_feature import Sentiment as SentimentV1 603 604 feature = SentimentV1(column_name=column_name, display_name=alias) 605 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 606 607 608 def TriggerWordsPresent( 609 column_name: str, 610 words_list: List[str], 611 lemmatize: bool = True, 612 alias: Optional[str] = None, 613 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 614 ): 615 """Check if trigger words are present in text. 616 617 Args: 618 * `column_name`: Name of the text column to check. 619 * `words_list`: List of trigger words to search for. 620 * `lemmatize`: Whether to lemmatize words before matching. 621 * `alias`: Optional alias for the descriptor. 622 * `tests`: Optional list of tests to apply. 623 """ 624 from evidently.legacy.features.trigger_words_presence_feature import TriggerWordsPresent as TriggerWordsPresentV1 625 626 feature = TriggerWordsPresentV1( 627 column_name=column_name, words_list=words_list, lemmatize=lemmatize, display_name=alias 628 ) 629 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 630 631 632 def WordCount( 633 column_name: str, alias: Optional[str] = None, tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None 634 ): 635 """Count the number of words in text. 636 637 Args: 638 * `column_name`: Name of the text column to analyze. 639 * `alias`: Optional alias for the descriptor. 640 * `tests`: Optional list of tests to apply. 641 """ 642 from evidently.legacy.features.word_count_feature import WordCount as WordCountV1 643 644 feature = WordCountV1(column_name=column_name, display_name=alias) 645 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 646 647 648 def WordMatch( 649 columns: List[str], 650 mode: str, 651 lemmatize: bool, 652 alias: Optional[str] = None, 653 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 654 ): 655 """Check if words from one column match words in another column. 656 657 Args: 658 * `columns`: List of two column names to compare. 659 * `mode`: Matching mode: "any" or "all". 660 * `lemmatize`: Whether to lemmatize words before matching. 661 * `alias`: Optional alias for the descriptor. 662 * `tests`: Optional list of tests to apply. 663 """ 664 from evidently.legacy.features.words_feature import WordMatch as WordMatchV1 665 666 feature = WordMatchV1(columns=columns, mode=mode, lemmatize=lemmatize, display_name=alias) 667 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 668 669 670 def WordNoMatch( 671 columns: List[str], 672 mode: str, 673 lemmatize: bool, 674 alias: Optional[str] = None, 675 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 676 ): 677 """Check if words from one column do not match words in another column. 678 679 Args: 680 * `columns`: List of two column names to compare. 681 * `mode`: Matching mode: "any" or "all". 682 * `lemmatize`: Whether to lemmatize words before matching. 683 * `alias`: Optional alias for the descriptor. 684 * `tests`: Optional list of tests to apply. 685 """ 686 from evidently.legacy.features.words_feature import WordNoMatch as WordNoMatchV1 687 688 feature = WordNoMatchV1(columns=columns, mode=mode, lemmatize=lemmatize, display_name=alias) 689 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 690 691 692 def WordsPresence( 693 column_name: str, 694 words_list: List[str], 695 mode: str = "includes_any", 696 lemmatize: bool = True, 697 alias: Optional[str] = None, 698 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 699 ): 700 """Check presence of words in text with various matching modes. 701 702 Args: 703 * `column_name`: Name of the text column to check. 704 * `words_list`: List of words to search for. 705 * `mode`: Matching mode: "includes_any", "includes_all", "excludes_any", or "excludes_all". 706 * `lemmatize`: Whether to lemmatize words before matching. 707 * `alias`: Optional alias for the descriptor. 708 * `tests`: Optional list of tests to apply. 709 """ 710 from evidently.legacy.features.words_feature import WordsPresence as WordsPresenceV1 711 712 feature = WordsPresenceV1( 713 column_name=column_name, words_list=words_list, mode=mode, lemmatize=lemmatize, display_name=alias 714 ) 715 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 716 717 718 def BiasLLMEval( 719 column_name: str, 720 provider: str = "openai", 721 model: str = "gpt-4o-mini", 722 additional_columns: Optional[Dict[str, str]] = None, 723 include_category: Optional[bool] = None, 724 include_score: Optional[bool] = None, 725 include_reasoning: Optional[bool] = None, 726 uncertainty: Optional[Uncertainty] = None, 727 alias: Optional[str] = None, 728 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 729 ): 730 """Evaluate bias in text using LLM. 731 732 Args: 733 * `column_name`: Name of the text column to evaluate. 734 * `provider`: LLM provider name (e.g., "openai", "anthropic"). 735 * `model`: Model name to use (e.g., "gpt-4o-mini"). 736 * `additional_columns`: Optional mapping of prompt variables to column names. 737 * `include_category`: Whether to include category in output. 738 * `include_score`: Whether to include score in output. 739 * `include_reasoning`: Whether to include reasoning in output. 740 * `uncertainty`: Optional uncertainty handling strategy. 741 * `alias`: Optional alias for the descriptor. 742 * `tests`: Optional list of tests to apply. 743 """ 744 from evidently.legacy.descriptors.llm_judges import BiasLLMEval as BiasLLMEvalV1 745 746 feature = BiasLLMEvalV1( 747 provider=provider, 748 model=model, 749 additional_columns=additional_columns, 750 include_category=include_category, 751 include_score=include_score, 752 include_reasoning=include_reasoning, 753 uncertainty=uncertainty, 754 display_name=alias, 755 ).feature(column_name) 756 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 757 758 759 def BinaryClassificationLLMEval( 760 column_name: str, 761 provider: str, 762 model: str, 763 additional_columns: Optional[Dict[str, str]] = None, 764 include_category: Optional[bool] = None, 765 include_score: Optional[bool] = None, 766 include_reasoning: Optional[bool] = None, 767 uncertainty: Optional[Uncertainty] = None, 768 alias: Optional[str] = None, 769 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 770 ): 771 """Perform binary classification evaluation using LLM. 772 773 Args: 774 * `column_name`: Name of the text column to evaluate. 775 * `provider`: LLM provider name (e.g., "openai", "anthropic"). 776 * `model`: Model name to use (e.g., "gpt-4o-mini"). 777 * `additional_columns`: Optional mapping of prompt variables to column names. 778 * `include_category`: Whether to include category in output. 779 * `include_score`: Whether to include score in output. 780 * `include_reasoning`: Whether to include reasoning in output. 781 * `uncertainty`: Optional uncertainty handling strategy. 782 * `alias`: Optional alias for the descriptor. 783 * `tests`: Optional list of tests to apply. 784 """ 785 from evidently.legacy.descriptors.llm_judges import BinaryClassificationLLMEval as BinaryClassificationLLMEvalV1 786 787 feature = BinaryClassificationLLMEvalV1( 788 provider=provider, 789 model=model, 790 additional_columns=additional_columns, 791 include_category=include_category, 792 include_score=include_score, 793 include_reasoning=include_reasoning, 794 uncertainty=uncertainty, 795 display_name=alias, 796 ).feature(column_name) 797 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 798 799 800 def CompletenessLLMEval( 801 column_name: str, 802 context: str, 803 provider: str = "openai", 804 model: str = "gpt-4o-mini", 805 additional_columns: Optional[Dict[str, str]] = None, 806 include_category: Optional[bool] = None, 807 include_score: Optional[bool] = None, 808 include_reasoning: Optional[bool] = None, 809 uncertainty: Optional[Uncertainty] = None, 810 alias: Optional[str] = None, 811 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 812 ): 813 """Evaluate completeness of text against context using LLM. 814 815 Args: 816 * `column_name`: Name of the text column to evaluate. 817 * `context`: Column name containing context for evaluation. 818 * `provider`: LLM provider name (e.g., "openai", "anthropic"). 819 * `model`: Model name to use (e.g., "gpt-4o-mini"). 820 * `additional_columns`: Optional mapping of prompt variables to column names. 821 * `include_category`: Whether to include category in output. 822 * `include_score`: Whether to include score in output. 823 * `include_reasoning`: Whether to include reasoning in output. 824 * `uncertainty`: Optional uncertainty handling strategy. 825 * `alias`: Optional alias for the descriptor. 826 * `tests`: Optional list of tests to apply. 827 """ 828 from evidently.legacy.descriptors.llm_judges import CompletenessLLMEval as CompletenessLLMEvalV1 829 830 feature = CompletenessLLMEvalV1( 831 context=context, 832 provider=provider, 833 model=model, 834 additional_columns=additional_columns, 835 include_category=include_category, 836 include_score=include_score, 837 include_reasoning=include_reasoning, 838 uncertainty=uncertainty, 839 display_name=alias, 840 ).feature(column_name) 841 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 842 843 844 def ContextQualityLLMEval( 845 column_name: str, 846 question: str, 847 provider: str = "openai", 848 model: str = "gpt-4o-mini", 849 additional_columns: Optional[Dict[str, str]] = None, 850 include_category: Optional[bool] = None, 851 include_score: Optional[bool] = None, 852 include_reasoning: Optional[bool] = None, 853 uncertainty: Optional[Uncertainty] = None, 854 alias: Optional[str] = None, 855 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 856 ): 857 """Evaluate quality of context for answering a question using LLM. 858 859 Args: 860 * `column_name`: Name of the text column to evaluate. 861 * `question`: Column name containing question for evaluation. 862 * `provider`: LLM provider name (e.g., "openai", "anthropic"). 863 * `model`: Model name to use (e.g., "gpt-4o-mini"). 864 * `additional_columns`: Optional mapping of prompt variables to column names. 865 * `include_category`: Whether to include category in output. 866 * `include_score`: Whether to include score in output. 867 * `include_reasoning`: Whether to include reasoning in output. 868 * `uncertainty`: Optional uncertainty handling strategy. 869 * `alias`: Optional alias for the descriptor. 870 * `tests`: Optional list of tests to apply. 871 """ 872 from evidently.legacy.descriptors.llm_judges import ContextQualityLLMEval as ContextQualityLLMEvalV1 873 874 feature = ContextQualityLLMEvalV1( 875 question=question, 876 provider=provider, 877 model=model, 878 additional_columns=additional_columns, 879 include_category=include_category, 880 include_score=include_score, 881 include_reasoning=include_reasoning, 882 uncertainty=uncertainty, 883 display_name=alias, 884 ).feature(column_name) 885 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 886 887 888 def CorrectnessLLMEval( 889 column_name: str, 890 target_output: str, 891 provider: str = "openai", 892 model: str = "gpt-4o-mini", 893 additional_columns: Optional[Dict[str, str]] = None, 894 include_category: Optional[bool] = None, 895 include_score: Optional[bool] = None, 896 include_reasoning: Optional[bool] = None, 897 uncertainty: Optional[Uncertainty] = None, 898 alias: Optional[str] = None, 899 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 900 ): 901 """Evaluate correctness of text against target output using LLM. 902 903 Args: 904 * `column_name`: Name of the text column to evaluate. 905 * `target_output`: Column name containing target output for comparison. 906 * `provider`: LLM provider name (e.g., "openai", "anthropic"). 907 * `model`: Model name to use (e.g., "gpt-4o-mini"). 908 * `additional_columns`: Optional mapping of prompt variables to column names. 909 * `include_category`: Whether to include category in output. 910 * `include_score`: Whether to include score in output. 911 * `include_reasoning`: Whether to include reasoning in output. 912 * `uncertainty`: Optional uncertainty handling strategy. 913 * `alias`: Optional alias for the descriptor. 914 * `tests`: Optional list of tests to apply. 915 """ 916 from evidently.legacy.descriptors.llm_judges import CorrectnessLLMEval as CorrectnessLLMEvalV1 917 918 feature = CorrectnessLLMEvalV1( 919 target_output=target_output, 920 provider=provider, 921 model=model, 922 additional_columns=additional_columns, 923 include_category=include_category, 924 include_score=include_score, 925 include_reasoning=include_reasoning, 926 uncertainty=uncertainty, 927 display_name=alias, 928 ).feature(column_name) 929 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 930 931 932 def DeclineLLMEval( 933 column_name: str, 934 provider: str = "openai", 935 model: str = "gpt-4o-mini", 936 additional_columns: Optional[Dict[str, str]] = None, 937 include_category: Optional[bool] = None, 938 include_score: Optional[bool] = None, 939 include_reasoning: Optional[bool] = None, 940 uncertainty: Optional[Uncertainty] = None, 941 alias: Optional[str] = None, 942 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 943 ): 944 """Detect if LLM declined to answer using LLM evaluation. 945 946 Args: 947 * `column_name`: Name of the text column to evaluate. 948 * `provider`: LLM provider name (e.g., "openai", "anthropic"). 949 * `model`: Model name to use (e.g., "gpt-4o-mini"). 950 * `additional_columns`: Optional mapping of prompt variables to column names. 951 * `include_category`: Whether to include category in output. 952 * `include_score`: Whether to include score in output. 953 * `include_reasoning`: Whether to include reasoning in output. 954 * `uncertainty`: Optional uncertainty handling strategy. 955 * `alias`: Optional alias for the descriptor. 956 * `tests`: Optional list of tests to apply. 957 """ 958 from evidently.legacy.descriptors.llm_judges import DeclineLLMEval as DeclineLLMEvalV1 959 960 feature = DeclineLLMEvalV1( 961 provider=provider, 962 model=model, 963 additional_columns=additional_columns, 964 include_category=include_category, 965 include_score=include_score, 966 include_reasoning=include_reasoning, 967 uncertainty=uncertainty, 968 display_name=alias, 969 ).feature(column_name) 970 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 971 972 973 def FaithfulnessLLMEval( 974 column_name: str, 975 context: str, 976 provider: str = "openai", 977 model: str = "gpt-4o-mini", 978 additional_columns: Optional[Dict[str, str]] = None, 979 include_category: Optional[bool] = None, 980 include_score: Optional[bool] = None, 981 include_reasoning: Optional[bool] = None, 982 uncertainty: Optional[Uncertainty] = None, 983 alias: Optional[str] = None, 984 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 985 ): 986 """Evaluate faithfulness of text to context using LLM. 987 988 Args: 989 * `column_name`: Name of the text column to evaluate. 990 * `context`: Column name containing context for evaluation. 991 * `provider`: LLM provider name (e.g., "openai", "anthropic"). 992 * `model`: Model name to use (e.g., "gpt-4o-mini"). 993 * `additional_columns`: Optional mapping of prompt variables to column names. 994 * `include_category`: Whether to include category in output. 995 * `include_score`: Whether to include score in output. 996 * `include_reasoning`: Whether to include reasoning in output. 997 * `uncertainty`: Optional uncertainty handling strategy. 998 * `alias`: Optional alias for the descriptor. 999 * `tests`: Optional list of tests to apply. 1000 """ 1001 from evidently.legacy.descriptors.llm_judges import FaithfulnessLLMEval as FaithfulnessLLMEvalV1 1002 1003 feature = FaithfulnessLLMEvalV1( 1004 context=context, 1005 provider=provider, 1006 model=model, 1007 additional_columns=additional_columns, 1008 include_category=include_category, 1009 include_score=include_score, 1010 include_reasoning=include_reasoning, 1011 uncertainty=uncertainty, 1012 display_name=alias, 1013 ).feature(column_name) 1014 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 1015 1016 1017 def LLMEval( 1018 column_name: str, 1019 provider: str, 1020 model: str, 1021 template: BaseLLMPromptTemplate, 1022 additional_columns: Optional[Dict[str, str]] = None, 1023 subcolumn: Optional[str] = None, 1024 alias: Optional[str] = None, 1025 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 1026 ): 1027 """Evaluate text using LLM with a custom prompt template. 1028 1029 Args: 1030 * `column_name`: Name of the text column to evaluate. 1031 * `provider`: LLM provider name (e.g., "openai", "anthropic"). 1032 * `model`: Model name to use (e.g., "gpt-4o-mini"). 1033 * `template`: Prompt template defining the evaluation task. 1034 * `additional_columns`: Optional mapping of prompt variables to column names. 1035 * `subcolumn`: Optional subcolumn name for nested data. 1036 * `alias`: Optional alias for the descriptor. 1037 * `tests`: Optional list of tests to apply. 1038 """ 1039 from evidently.legacy.descriptors.llm_judges import LLMEval as LLMEvalV1 1040 1041 feature = LLMEvalV1( 1042 provider=provider, 1043 model=model, 1044 template=template, 1045 additional_columns=additional_columns, 1046 subcolumn=subcolumn, 1047 display_name=alias, 1048 ).feature(column_name) 1049 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 1050 1051 1052 def MulticlassClassificationLLMEval( 1053 column_name: str, 1054 provider: str, 1055 model: str, 1056 additional_columns: Optional[Dict[str, str]] = None, 1057 include_category: Optional[bool] = None, 1058 include_score: Optional[bool] = None, 1059 include_reasoning: Optional[bool] = None, 1060 uncertainty: Optional[Uncertainty] = None, 1061 alias: Optional[str] = None, 1062 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 1063 ): 1064 """Perform multiclass classification evaluation using LLM. 1065 1066 Args: 1067 * `column_name`: Name of the text column to evaluate. 1068 * `provider`: LLM provider name (e.g., "openai", "anthropic"). 1069 * `model`: Model name to use (e.g., "gpt-4o-mini"). 1070 * `additional_columns`: Optional mapping of prompt variables to column names. 1071 * `include_category`: Whether to include category in output. 1072 * `include_score`: Whether to include score in output. 1073 * `include_reasoning`: Whether to include reasoning in output. 1074 * `uncertainty`: Optional uncertainty handling strategy. 1075 * `alias`: Optional alias for the descriptor. 1076 * `tests`: Optional list of tests to apply. 1077 """ 1078 from evidently.legacy.descriptors.llm_judges import ( 1079 MulticlassClassificationLLMEval as MulticlassClassificationLLMEvalV1, 1080 ) 1081 1082 feature = MulticlassClassificationLLMEvalV1( 1083 provider=provider, 1084 model=model, 1085 additional_columns=additional_columns, 1086 include_category=include_category, 1087 include_score=include_score, 1088 include_reasoning=include_reasoning, 1089 uncertainty=uncertainty, 1090 display_name=alias, 1091 ).feature(column_name) 1092 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 1093 1094 1095 def NegativityLLMEval( 1096 column_name: str, 1097 provider: str = "openai", 1098 model: str = "gpt-4o-mini", 1099 additional_columns: Optional[Dict[str, str]] = None, 1100 include_category: Optional[bool] = None, 1101 include_score: Optional[bool] = None, 1102 include_reasoning: Optional[bool] = None, 1103 uncertainty: Optional[Uncertainty] = None, 1104 alias: Optional[str] = None, 1105 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 1106 ): 1107 """Evaluate negativity in text using LLM. 1108 1109 Args: 1110 * `column_name`: Name of the text column to evaluate. 1111 * `provider`: LLM provider name (e.g., "openai", "anthropic"). 1112 * `model`: Model name to use (e.g., "gpt-4o-mini"). 1113 * `additional_columns`: Optional mapping of prompt variables to column names. 1114 * `include_category`: Whether to include category in output. 1115 * `include_score`: Whether to include score in output. 1116 * `include_reasoning`: Whether to include reasoning in output. 1117 * `uncertainty`: Optional uncertainty handling strategy. 1118 * `alias`: Optional alias for the descriptor. 1119 * `tests`: Optional list of tests to apply. 1120 """ 1121 from evidently.legacy.descriptors.llm_judges import NegativityLLMEval as NegativityLLMEvalV1 1122 1123 feature = NegativityLLMEvalV1( 1124 provider=provider, 1125 model=model, 1126 additional_columns=additional_columns, 1127 include_category=include_category, 1128 include_score=include_score, 1129 include_reasoning=include_reasoning, 1130 uncertainty=uncertainty, 1131 display_name=alias, 1132 ).feature(column_name) 1133 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 1134 1135 1136 def PIILLMEval( 1137 column_name: str, 1138 provider: str = "openai", 1139 model: str = "gpt-4o-mini", 1140 additional_columns: Optional[Dict[str, str]] = None, 1141 include_category: Optional[bool] = None, 1142 include_score: Optional[bool] = None, 1143 include_reasoning: Optional[bool] = None, 1144 uncertainty: Optional[Uncertainty] = None, 1145 alias: Optional[str] = None, 1146 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 1147 ): 1148 """Detect personally identifiable information in text using LLM. 1149 1150 Args: 1151 * `column_name`: Name of the text column to evaluate. 1152 * `provider`: LLM provider name (e.g., "openai", "anthropic"). 1153 * `model`: Model name to use (e.g., "gpt-4o-mini"). 1154 * `additional_columns`: Optional mapping of prompt variables to column names. 1155 * `include_category`: Whether to include category in output. 1156 * `include_score`: Whether to include score in output. 1157 * `include_reasoning`: Whether to include reasoning in output. 1158 * `uncertainty`: Optional uncertainty handling strategy. 1159 * `alias`: Optional alias for the descriptor. 1160 * `tests`: Optional list of tests to apply. 1161 """ 1162 from evidently.legacy.descriptors.llm_judges import PIILLMEval as PIILLMEvalV1 1163 1164 feature = PIILLMEvalV1( 1165 provider=provider, 1166 model=model, 1167 additional_columns=additional_columns, 1168 include_category=include_category, 1169 include_score=include_score, 1170 include_reasoning=include_reasoning, 1171 uncertainty=uncertainty, 1172 display_name=alias, 1173 ).feature(column_name) 1174 return FeatureDescriptor(feature=feature, alias=alias, tests=tests) 1175 1176 1177 def ToxicityLLMEval( 1178 column_name: str, 1179 provider: str = "openai", 1180 model: str = "gpt-4o-mini", 1181 additional_columns: Optional[Dict[str, str]] = None, 1182 include_category: Optional[bool] = None, 1183 include_score: Optional[bool] = None, 1184 include_reasoning: Optional[bool] = None, 1185 uncertainty: Optional[Uncertainty] = None, 1186 alias: Optional[str] = None, 1187 tests: Optional[List[Union["DescriptorTest", "GenericTest"]]] = None, 1188 ): 1189 """Evaluate toxicity in text using LLM. 1190 1191 Args: 1192 * `column_name`: Name of the text column to evaluate. 1193 * `provider`: LLM provider name (e.g., "openai", "anthropic"). 1194 * `model`: Model name to use (e.g., "gpt-4o-mini"). 1195 * `additional_columns`: Optional mapping of prompt variables to column names. 1196 * `include_category`: Whether to include category in output. 1197 * `include_score`: Whether to include score in output. 1198 * `include_reasoning`: Whether to include reasoning in output. 1199 * `uncertainty`: Optional uncertainty handling strategy. 1200 * `alias`: Optional alias for the descriptor. 1201 * `tests`: Optional list of tests to apply. 1202 """ 1203 from evidently.legacy.descriptors.llm_judges import ToxicityLLMEval as ToxicityLLMEvalV1 1204 1205 feature = ToxicityLLMEvalV1( 1206 provider=provider, 1207 model=model, 1208 additional_columns=additional_columns, 1209 include_category=include_category, 1210 include_score=include_score, 1211 include_reasoning=include_reasoning, 1212 uncertainty=uncertainty, 1213 display_name=alias, 1214 ).feature(column_name) 1215 return FeatureDescriptor(feature=feature, alias=alias, tests=tests)