蘺h6dZddlmZddlmZmZmZmZmZddl m Z m Z ddl m Z mZmZddlmZddlmZmZddlmZd efd ZGd d eeZGd deZGddeeZGddeeZdS)z:String distance evaluators based on the RapidFuzz library.)Enum)AnyCallableDictListOptional)Fieldroot_validator)AsyncCallbackManagerForChainRunCallbackManagerForChainRun Callbacks)Chain)PairwiseStringEvaluatorStringEvaluator)RUN_KEYreturncV ddl}n#t$rtdwxYw|jS)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 q/var/www/html/services/rag-service/venv/lib/python3.11/site-packages/langchain/evaluation/string_distance/base.py_load_rapidfuzzrsS      >     s!c*eZdZdZdZdZdZdZdZdZ dS) 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&s9  0K D!LG EEEr,rcReZdZUdZeejZeed<edZ e ed< e de e efde e effdZedee fd Zd e e efde e effd Zedde de defd ZedefdZde de defdZdS)_RapidFuzzChainMixinz d38n   ^ T#YX d38n c3h     # #c #D #X # # #\ #D      X   ! ! ! ! ! ! ! ! !r,r.c&eZdZdZedefdZedefdZedee 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 defdZdS)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", ) rcdS)z8 This evaluator does not require input. Fr+r7s rrequires_inputz&StringDistanceEvalChain.requires_inputs ur,cdS)z> This evaluator does not require a reference. Tr+r7s rrequires_referencez*StringDistanceEvalChain.requires_references tr,c ddgS)^ Get the input keys. Returns: List[str]: The input keys. reference predictionr+r7s r input_keysz"StringDistanceEvalChain.input_keyss\**r,c |jjdS)b Get the evaluation name. Returns: str: The evaluation name. _distancervaluer7s revaluation_namez'StringDistanceEvalChain.evaluation_names-%0000r,Ninputs run_managercJd||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-@&BVWWXXr,cNKd||d|diS)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-@&BVWWXXr,F)r`input callbackstagsmetadatainclude_run_inforar`rqrrrsrtrukwargsc R|||d||||} || 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`rirrrsrtrur= r8rar`rqrrrsrtrurvr:s r_evaluate_stringsz)StringDistanceEvalChain._evaluate_stringssG2",9EE-    ##F+++r,cvK|||d||||d{V} || S)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. rxryNacallr=r{s r_aevaluate_stringsz*StringDistanceEvalChain._aevaluate_strings'sk4zz",9EE- "        ##F+++r,N)r!r"r#r$rUrSr[r]rrTrbrhrrrr rnr rpr r<r|rr+r,rrYrYs,X DX +DI+++X+1111X1=AYYS#XY89Y c3h YYYY*BFYYS#XY=>Y c3h YYYY.$(##$(-1!&!,!,!,!,C= !, } !,  !,tCy!!,4S>*!,!,!, !,!,!,!,N$(##$(-1!&!,!,!,!,C= !, } !,  !,tCy!!,4S>*!,!,!, !,!,!,!,!,!,r,rYceZdZdZedeefdZedefdZ 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 defdZdS)PairwiseStringDistanceEvalChainz6Compute string edit distances between two predictions.rc ddgS)r_ra prediction_br+r7s rrbz*PairwiseStringDistanceEvalChain.input_keysNsn--r,c"d|jjdS)rd pairwise_rerfr7s rrhz/PairwiseStringDistanceEvalChain.evaluation_nameXs:4=.9999r,NrirjcJd||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._callbs-" T(( )=vn?UVV  r,cNKd||d|diS)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._acallvs1" T(( )=vn?UVV  r,F)rrrsrtrurarrrrsrtrurvc R|||d||||}||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. rarryrz r8rarrrrsrtrurvr:s r_evaluate_string_pairsz6PairwiseStringDistanceEvalChain._evaluate_string_pairssG2",lKK-    ##F+++r,cvK|||d||||d{V}||S)a5 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. rryNr~rs r_aevaluate_string_pairsz7PairwiseStringDistanceEvalChain._aevaluate_string_pairssk2zz",lKK- "        ##F+++r,r)r!r"r#r$rUrrTrbrhrrrr rnr rpr rSr<rrr+r,rrrKs2@@ .DI...X.::::X:=A  S#X 89  c3h     .BF  S#X =>  c3h     2 $$(-1!& , , , , ,  , tCy! ,4S>* , , ,  , , , ,N $$(-1!& , , , , ,  , tCy! ,4S>* , , ,  , , , , , ,r,rN)r$enumrtypingrrrrrlangchain_core.pydantic_v1r r langchain.callbacks.managerr r r langchain.chains.baserlangchain.evaluation.schemarrlangchain.schemarrrTrr.rYrr+r,rrs@@66666666666666<<<<<<<< ('''''PPPPPPPP$$$$$$(S$(i!i!i!i!i!5i!i!i!Xb,b,b,b,b,o/Cb,b,b,JA,A,A,A,A,&=?SA,A,A,A,A,r,