






import functools
from contextlib import contextmanager

import bert_score
from packaging import version

import datasets






@contextmanager
def   a      (						):






				'''simple docstring'''





				def filter_log(lowerCamelCase_    ):
								return False if "This IS expected if you are initializing" in record.msg else True

				lowercase__       			=      datasets.utils.logging.get_logger('''transformers.modeling_utils'''    )
				logger.addFilter(_UpperCAmelCase    )
				try:
								yield
				finally:
								logger.removeFilter(_UpperCAmelCase    )


A__     :      Optional[int]             =			'\\n@inproceedings{bert-score,\n  title={BERTScore: Evaluating Text Generation with BERT},\n  author={Tianyi Zhang* and Varsha Kishore* and Felix Wu* and Kilian Q. Weinberger and Yoav Artzi},\n  booktitle={International Conference on Learning Representations},\n  year={2020},\n  url={https://openreview.net/forum?id=SkeHuCVFDr}\n}\n'

A__     :      Union[str, Any]             =			'\\nBERTScore leverages the pre-trained contextual embeddings from BERT and matches words in candidate and reference\nsentences by cosine similarity.\nIt has been shown to correlate with human judgment on sentence-level and system-level evaluation.\nMoreover, BERTScore computes precision, recall, and F1 measure, which can be useful for evaluating different language\ngeneration tasks.\n\nSee the project\'s README at https://github.com/Tiiiger/bert_score#readme for more information.\n'

A__     :      List[str]             =			'\nBERTScore Metrics with the hashcode from a source against one or more references.\n\nArgs:\n    predictions (list of str): Prediction/candidate sentences.\n    references (list of str or list of list of str): Reference sentences.\n    lang (str): Language of the sentences; required (e.g. \'en\').\n    model_type (str): Bert specification, default using the suggested\n        model for the target language; has to specify at least one of\n        `model_type` or `lang`.\n    num_layers (int): The layer of representation to use,\n        default using the number of layers tuned on WMT16 correlation data.\n    verbose (bool): Turn on intermediate status update.\n    idf (bool or dict): Use idf weighting; can also be a precomputed idf_dict.\n    device (str): On which the contextual embedding model will be allocated on.\n        If this argument is None, the model lives on cuda:0 if cuda is available.\n    nthreads (int): Number of threads.\n    batch_size (int): Bert score processing batch size,\n        at least one of `model_type` or `lang`. `lang` needs to be\n        specified when `rescale_with_baseline` is True.\n    rescale_with_baseline (bool): Rescale bertscore with pre-computed baseline.\n    baseline_path (str): Customized baseline file.\n    use_fast_tokenizer (bool): `use_fast` parameter passed to HF tokenizer. New in version 0.3.10.\n\nReturns:\n    precision: Precision.\n    recall: Recall.\n    f1: F1 score.\n    hashcode: Hashcode of the library.\n\nExamples:\n\n    >>> predictions = ["hello there", "general kenobi"]\n    >>> references = ["hello there", "general kenobi"]\n    >>> bertscore = datasets.load_metric("bertscore")\n    >>> results = bertscore.compute(predictions=predictions, references=references, lang="en")\n    >>> print([round(v, 2) for v in results["f1"]])\n    [1.0, 1.0]\n'




@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION		,_KWARGS_DESCRIPTION     )
class 				_UpperCAmelCase (	datasets.Metric     ):

				"""simple docstring"""




				def     lowercase__       (					self						:   Any  ):

								'''simple docstring'''
								return datasets.MetricInfo(
								    description=_DESCRIPTION,  citation=_CITATION,  homepage='''https://github.com/Tiiiger/bert_score''',  inputs_description=_KWARGS_DESCRIPTION,  features=datasets.Features(
								        {
								            '''predictions''': datasets.Value('''string''',  id='''sequence'''  ),
								            '''references''': datasets.Sequence(datasets.Value('''string''',  id='''sequence'''  ),  id='''references'''  ),
								        }  ),  codebase_urls=['''https://github.com/Tiiiger/bert_score'''],  reference_urls=[
								        '''https://github.com/Tiiiger/bert_score''',
								        '''https://arxiv.org/abs/1904.09675''',
								    ],  )




				def     lowercase__       (					self						:   str,  lowerCamelCase						:   List[str],  lowerCamelCase						:   Tuple,  lowerCamelCase						:   str=None,  lowerCamelCase						:   List[str]=None,  lowerCamelCase						:   Tuple=None,  lowerCamelCase						:   List[Any]=False,  lowerCamelCase						:   int=False,  lowerCamelCase						:   Tuple=None,  lowerCamelCase						:   Dict=64,  lowerCamelCase						:   Optional[int]=4,  lowerCamelCase						:   Dict=False,  lowerCamelCase						:   Optional[Any]=False,  lowerCamelCase						:   Optional[Any]=None,  lowerCamelCase						:   Any=False,  ):

								'''simple docstring'''
								lowercase__       			=      bert_score.utils.get_hash
								lowercase__       			=      bert_score.BERTScorer

								if version.parse(bert_score.__version__  ) >= version.parse('''0.3.10'''  ):
												lowercase__       			=      functools.partial(snake_case_,  use_fast_tokenizer=snake_case_  )
												lowercase__       			=      functools.partial(snake_case_,  use_fast_tokenizer=snake_case_  )
								elif use_fast_tokenizer:
												raise ImportWarning(
												    '''To use a fast tokenizer, the module `bert-score>=0.3.10` is required, and the current version of `bert-score` doesn\'t match this condition.\n'''
												    '''You can install it with `pip install "bert-score>=0.3.10"`.'''  )

								if model_type is None:
												assert lang is not None, "either lang or model_type should be specified"
												lowercase__       			=      bert_score.utils.langamodel[lang.lower()]

								if num_layers is None:
												lowercase__       			=      bert_score.utils.modelalayers[model_type]

								lowercase__       			=      get_hash(
								    model=snake_case_,  num_layers=snake_case_,  idf=snake_case_,  rescale_with_baseline=snake_case_,  use_custom_baseline=baseline_path is not None,  )

								with filter_logging_context():
												if not hasattr(self,  '''cached_bertscorer'''  ) or self.cached_bertscorer.hash != hashcode:
																lowercase__       			=      scorer(
																    model_type=snake_case_,  num_layers=snake_case_,  batch_size=snake_case_,  nthreads=snake_case_,  all_layers=snake_case_,  idf=snake_case_,  device=snake_case_,  lang=snake_case_,  rescale_with_baseline=snake_case_,  baseline_path=snake_case_,  )

								(lowercase__)       			=      self.cached_bertscorer.score(
								    cands=snake_case_,  refs=snake_case_,  verbose=snake_case_,  batch_size=snake_case_,  )
								lowercase__       			=      {
								    'precision': P.tolist(),
								    'recall': R.tolist(),
								    'f1': F.tolist(),
								    'hashcode': hashcode,
								}
								return output_dict




				def     lowercase__       (					self						:   List[str],  lowerCamelCase						:   int=None,  lowerCamelCase						:   Tuple=None,  **lowerCamelCase						:   List[str]  ):

								'''simple docstring'''

								if references is not None:
												lowercase__       			=      [[ref] if isinstance(snake_case_,  snake_case_  ) else ref for ref in references]
								super().add_batch(predictions=snake_case_,  references=snake_case_,  **snake_case_  )




				def     lowercase__       (					self						:   Optional[int],  lowerCamelCase						:   Optional[int]=None,  lowerCamelCase						:   Optional[Any]=None,  **lowerCamelCase						:   Optional[int]  ):

								'''simple docstring'''

								if isinstance(snake_case_,  snake_case_  ):
												lowercase__       			=      [reference]
								super().add(prediction=snake_case_,  reference=snake_case_,  **snake_case_  )










import unittest

from datasets import load_dataset

from transformers import load_tool

from .test_tools_common import ToolTesterMixin
class 				_UpperCAmelCase (	unittest.TestCase		,A__     ):

				"""simple docstring"""




				def     lowercase__       (					self						:   str  ):

								'''simple docstring'''
								lowercase__       			=      load_tool('''document-question-answering'''  )
								self.tool.setup()
								lowercase__       			=      load_tool('''document-question-answering''',  remote=lowerCamelCase  )




				def     lowercase__       (					self						:   List[Any]  ):

								'''simple docstring'''
								lowercase__       			=      load_dataset('''hf-internal-testing/example-documents''',  split='''test'''  )
								lowercase__       			=      dataset[0]['''image''']

								lowercase__       			=      self.tool(lowerCamelCase,  '''When is the coffee break?'''  )
								self.assertEqual(lowerCamelCase,  '''11-14 to 11:39 a.m.'''  )




				def     lowercase__       (					self						:   Optional[Any]  ):

								'''simple docstring'''
								lowercase__       			=      load_dataset('''hf-internal-testing/example-documents''',  split='''test'''  )
								lowercase__       			=      dataset[0]['''image''']

								lowercase__       			=      self.remote_tool(lowerCamelCase,  '''When is the coffee break?'''  )
								self.assertEqual(lowerCamelCase,  '''11-14 to 11:39 a.m.'''  )




				def     lowercase__       (					self						:   Any  ):

								'''simple docstring'''
								lowercase__       			=      load_dataset('''hf-internal-testing/example-documents''',  split='''test'''  )
								lowercase__       			=      dataset[0]['''image''']

								self.tool(document=lowerCamelCase,  question='''When is the coffee break?'''  )




				def     lowercase__       (					self						:   Tuple  ):

								'''simple docstring'''
								lowercase__       			=      load_dataset('''hf-internal-testing/example-documents''',  split='''test'''  )
								lowercase__       			=      dataset[0]['''image''']

								lowercase__       			=      self.remote_tool(document=lowerCamelCase,  question='''When is the coffee break?'''  )
								self.assertEqual(lowerCamelCase,  '''11-14 to 11:39 a.m.'''  )




