ih6dZddlmZddlmZmZmZmZmZddl m Z m Z m Z ddl mZddlmZddlmZddlmZmZdd lmZd efd ZGd d eeZGddeZGddeeZGddeeZy)z:String distance evaluators based on the RapidFuzz library.)Enum)AnyCallableDictListOptional)AsyncCallbackManagerForChainRunCallbackManagerForChainRun Callbacks)pre_init)Field)Chain)PairwiseStringEvaluatorStringEvaluator)RUN_KEYreturncT ddl}|jS#t$r tdwxYw)z Load the RapidFuzz library. Raises: ImportError: If the rapidfuzz library is not installed. Returns: Any: The rapidfuzz.distance module. rNzyPlease install the rapidfuzz library to use the FuzzyMatchStringEvaluator.Please install it with `pip install rapidfuzz`.) rapidfuzz ImportErrordistance)rs g/var/www/html/dev/engine/venv/lib/python3.12/site-packages/langchain/evaluation/string_distance/base.py_load_rapidfuzzrs;       >   s'c(eZdZdZdZdZdZdZdZdZ y) StringDistancea7Distance metric to use. Attributes: DAMERAU_LEVENSHTEIN: The Damerau-Levenshtein distance. LEVENSHTEIN: The Levenshtein distance. JARO: The Jaro distance. JARO_WINKLER: The Jaro-Winkler distance. HAMMING: The Hamming distance. INDEL: The Indel distance. damerau_levenshtein levenshteinjaro jaro_winklerhammingindelN) __name__ __module__ __qualname____doc__DAMERAU_LEVENSHTEIN LEVENSHTEINJARO JARO_WINKLERHAMMINGINDELrrr's( 0K D!LG Er,rceZdZUdZeej Zeed<edZ e ed< e de e efde e effdZedee fd Zd e e efde e effd Zedde de defd Zedefd Zde de defdZy)_RapidFuzzChainMixinz d38n  T#Y d38n c3h  #c #D #X # #D       ! ! ! !r,r.ceZdZdZedefdZedefdZedee fdZ ede fdZ dde e e fd eede e e ffd Z dde e e fd eede e e ffd Zdddddd d de dee dee dedeee dee e e fdede defdZdddddd d de dee dee dedeee dee e e fdede defdZy)StringDistanceEvalChainakCompute string distances between the prediction and the reference. Examples ---------- >>> from langchain.evaluation import StringDistanceEvalChain >>> evaluator = StringDistanceEvalChain() >>> evaluator.evaluate_strings( prediction="Mindy is the CTO", reference="Mindy is the CEO", ) Using the `load_evaluator` function: >>> from langchain.evaluation import load_evaluator >>> evaluator = load_evaluator("string_distance") >>> evaluator.evaluate_strings( prediction="The answer is three", reference="three", ) rcy)z8 This evaluator does not require input. Fr+r7s rrequires_inputz&StringDistanceEvalChain.requires_inputs r,cy)z> This evaluator does not require a reference. Tr+r7s rrequires_referencez*StringDistanceEvalChain.requires_references r,c ddgS)^ Get the input keys. Returns: List[str]: The input keys. reference predictionr+r7s r input_keysz"StringDistanceEvalChain.input_keyss\**r,c4|jjdS)b Get the evaluation name. Returns: str: The evaluation name. _distancervaluer7s revaluation_namez'StringDistanceEvalChain.evaluation_names--%%&i00r,Ninputs run_managerc6d|j|d|diS)a^ Compute the string distance between the prediction and the reference. Args: inputs (Dict[str, Any]): The input values. run_manager (Optional[CallbackManagerForChainRun]): The callback manager. Returns: Dict[str, Any]: The evaluation results containing the score. r6r`rarQr8rirjs r_callzStringDistanceEvalChain._calls& ,,VK-@&BVWXXr,c>Kd|j|d|diSw)a} Asynchronously compute the string distance between the prediction and the reference. Args: inputs (Dict[str, Any]): The input values. run_manager (Optional[AsyncCallbackManagerForChainRun]: The callback manager. Returns: Dict[str, Any]: The evaluation results containing the score. r6r`rarlrms r_acallzStringDistanceEvalChain._acalls*",,VK-@&BVWXXF)r`input callbackstagsmetadatainclude_run_inforar`rrrsrtrurvkwargsc D|||d||||} |j| S)a Evaluate the string distance between the prediction and the reference. Args: prediction (str): The prediction string. reference (Optional[str], optional): The reference string. input (Optional[str], optional): The input string. callbacks (Callbacks, optional): The callbacks to use. kwargs: Additional keyword arguments. Returns: dict: The evaluation results containing the score. rar`rirsrtrurvr= r8rar`rrrsrtrurvrwr:s r_evaluate_stringsz)StringDistanceEvalChain._evaluate_stringss52",9E-  ##F++r,crK|j||d||||d{} |j| S7w)a Asynchronously evaluate the string distance between the prediction and the reference. Args: prediction (str): The prediction string. reference (Optional[str], optional): The reference string. input (Optional[str], optional): The input string. callbacks (Callbacks, optional): The callbacks to use. kwargs: Additional keyword arguments. Returns: dict: The evaluation results containing the score. ryrzNacallr=r|s r_aevaluate_stringsz*StringDistanceEvalChain._aevaluate_strings(sL4zz",9E- "  ##F++ 757N)r!r"r#r$rUrSr[r]rrTrbrhrrrr rnr rpr r<r}rr+r,rrYrYs, D +DI++111=AYS#XY89Y c3h Y*BFYS#XY=>Y c3h Y.$(##$(-1!&!,!,C= !, } !,  !,tCy!!,4S>*!,!,!, !,N$(##$(-1!&!,!,C= !, } !,  !,tCy!!,4S>*!,!,!, !,r,rYcFeZdZdZedeefdZedefdZ dde ee fde e de ee ffdZ dde ee fde ede ee ffd Zdddd d d ed edede eede e ee fdede defdZdddd d d ed edede eede e ee fdede defdZy)PairwiseStringDistanceEvalChainz6Compute string edit distances between two predictions.rc ddgS)r_ra prediction_br+r7s rrbz*PairwiseStringDistanceEvalChain.input_keysOsn--r,c6d|jjdS)rd pairwise_rerfr7s rrhz/PairwiseStringDistanceEvalChain.evaluation_nameYs4==../y99r,Nrirjc6d|j|d|diS)aN Compute the string distance between two predictions. Args: inputs (Dict[str, Any]): The input values. run_manager (CallbackManagerForChainRun , optional): The callback manager. Returns: Dict[str, Any]: The evaluation results containing the score. r6rarrlrms rrnz%PairwiseStringDistanceEvalChain._callcs*" T(( )=vn?UV  r,c>Kd|j|d|diSw)ab Asynchronously compute the string distance between two predictions. Args: inputs (Dict[str, Any]): The input values. run_manager (AsyncCallbackManagerForChainRun , optional): The callback manager. Returns: Dict[str, Any]: The evaluation results containing the score. r6rarrlrms rrpz&PairwiseStringDistanceEvalChain._acallws." T(( )=vn?UV  rqF)rsrtrurvrarrsrtrurvrwc D|||d||||}|j|S)a$ Evaluate the string distance between two predictions. Args: prediction (str): The first prediction string. prediction_b (str): The second prediction string. callbacks (Callbacks, optional): The callbacks to use. tags (List[str], optional): Tags to apply to traces. metadata (Dict[str, Any], optional): Metadata to apply to traces. kwargs: Additional keyword arguments. Returns: dict: The evaluation results containing the score. rarrzr{ r8rarrsrtrurvrwr:s r_evaluate_string_pairsz6PairwiseStringDistanceEvalChain._evaluate_string_pairss52",lK-  ##F++r,crK|j||d||||d{}|j|S7w)a3 Asynchronously evaluate the string distance between two predictions. Args: prediction (str): The first prediction string. prediction_b (str): The second prediction string. callbacks (Callbacks, optional): The callbacks to use. tags (List[str], optional): Tags to apply to traces. metadata (Dict[str, Any], optional): Metadata to apply to traces. kwargs: Additional keyword arguments. Returns: dict: The evaluation results containing the score. rrzNrrs r_aevaluate_string_pairsz7PairwiseStringDistanceEvalChain._aevaluate_string_pairssL2zz",lK- "  ##F++ rr)r!r"r#r$rUrrTrbrhrrrr rnr rpr rSr<rrr+r,rrrLs@ .DI..:::=A S#X 89  c3h  .BF S#X =>  c3h  2 $$(-1!& , , ,  , tCy! ,4S>* , , ,  ,N $$(-1!& , , ,  , tCy! ,4S>* , , ,  ,r,rN)r$enumrtypingrrrrr langchain_core.callbacks.managerr r r langchain_core.utilsr pydanticr langchain.chains.baserlangchain.evaluation.schemarrlangchain.schemarrrTrr.rYrr+r,rrsy@66 *'P$(S$(i!5i!Xb,o/Cb,JA,&=?SA,r,