

'''simple docstring'''

import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


lowercase__         =      version.parse(importlib_metadata.version("nltk"))
if NLTK_VERSION >= version.Version("3.6.4"):
 from nltk import word_tokenize


lowercase__         =      "\\n@inproceedings{banarjee2005,\n  title     = {{METEOR}: An Automatic Metric for {MT} Evaluation with Improved Correlation with Human Judgments},\n  author    = {Banerjee, Satanjeev  and Lavie, Alon},\n  booktitle = {Proceedings of the {ACL} Workshop on Intrinsic and Extrinsic Evaluation Measures for Machine Translation and/or Summarization},\n  month     = jun,\n  year      = {2005},\n  address   = {Ann Arbor, Michigan},\n  publisher = {Association for Computational Linguistics},\n  url       = {https://www.aclweb.org/anthology/W05-0909},\n  pages     = {65--72},\n}\n"

lowercase__         =      "\\nMETEOR, an automatic metric for machine translation evaluation\nthat is based on a generalized concept of unigram matching between the\nmachine-produced translation and human-produced reference translations.\nUnigrams can be matched based on their surface forms, stemmed forms,\nand meanings; furthermore, METEOR can be easily extended to include more\nadvanced matching strategies. Once all generalized unigram matches\nbetween the two strings have been found, METEOR computes a score for\nthis matching using a combination of unigram-precision, unigram-recall, and\na measure of fragmentation that is designed to directly capture how\nwell-ordered the matched words in the machine translation are in relation\nto the reference.\n\nMETEOR gets an R correlation value of 0.347 with human evaluation on the Arabic\ndata and 0.331 on the Chinese data. This is shown to be an improvement on\nusing simply unigram-precision, unigram-recall and their harmonic F1\ncombination.\n"

lowercase__         =      "\nComputes METEOR score of translated segments against one or more references.\nArgs:\n    predictions: list of predictions to score. Each prediction\n        should be a string with tokens separated by spaces.\n    references: list of reference for each prediction. Each\n        reference should be a string with tokens separated by spaces.\n    alpha: Parameter for controlling relative weights of precision and recall. default: 0.9\n    beta: Parameter for controlling shape of penalty as a function of fragmentation. default: 3\n    gamma: Relative weight assigned to fragmentation penalty. default: 0.5\nReturns:\n    'meteor': meteor score.\nExamples:\n\n    >>> meteor = datasets.load_metric('meteor')\n    >>> predictions = [\"It is a guide to action which ensures that the military always obeys the commands of the party\"]\n    >>> references = [\"It is a guide to action that ensures that the military will forever heed Party commands\"]\n    >>> results = meteor.compute(predictions=predictions, references=references)\n    >>> print(round(results[\"meteor\"], 4))\n    0.6944\n"




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






     '''simple docstring'''



     def        UpperCAmelCase_	(		self			:					Dict	)						->     str:
       return datasets.MetricInfo(
           description=_DESCRIPTION					,      citation=_CITATION					,      inputs_description=_KWARGS_DESCRIPTION					,      features=datasets.Features(
               {
                   'predictions': datasets.Value('string'					,      id='sequence'	),
                   'references': datasets.Value('string'					,      id='sequence'	),
               }	)					,      codebase_urls=['https://github.com/nltk/nltk/blob/develop/nltk/translate/meteor_score.py']					,      reference_urls=[
               'https://www.nltk.org/api/nltk.translate.html#module-nltk.translate.meteor_score',
               'https://en.wikipedia.org/wiki/METEOR',
           ]					,      )


     def        UpperCAmelCase_	(		self			:					Optional[int]					,      lowercase_			:					Any	)						->     Optional[Any]:
       import nltk

       nltk.download('wordnet'	)
       if NLTK_VERSION >= version.Version('3.6.5'	):
         nltk.download('punkt'	)
       if NLTK_VERSION >= version.Version('3.6.6'	):
         nltk.download('omw-1.4'	)




     def        UpperCAmelCase_	(		self			:					List[Any]					,      lowercase_			:					Tuple					,      lowercase_			:					List[Any]					,      lowercase_			:					List[Any]=0.9					,      lowercase_			:					Tuple=3					,      lowercase_			:					Optional[Any]=0.5	)						->     Dict:
       if NLTK_VERSION >= version.Version('3.6.5'	):
         UpperCAmelCase	:     Union[str, Any]						 =			[
             meteor_score.single_meteor_score(
                 word_tokenize(lowercase_	)					,      word_tokenize(lowercase_	)					,      alpha=lowercase_					,      beta=lowercase_					,      gamma=lowercase_	)
             for ref, pred in zip(lowercase_					,      lowercase_	)
         ]
       else:
         UpperCAmelCase	:     Dict						 =			[
             meteor_score.single_meteor_score(lowercase_					,      lowercase_					,      alpha=lowercase_					,      beta=lowercase_					,      gamma=lowercase_	)
             for ref, pred in zip(lowercase_					,      lowercase_	)
         ]

       return {"meteor": np.mean(lowercase_	)}







'''simple docstring'''

import pytest

from datasets import Dataset, DatasetDict, Features, NamedSplit, Value
from datasets.io.text import TextDatasetReader

from ..utils import assert_arrow_memory_doesnt_increase, assert_arrow_memory_increases




def 				UpperCamelCase(					UpperCAmelCase_  ,	UpperCAmelCase_     ):
 assert isinstance(UpperCAmelCase_  ,	UpperCAmelCase_     )
 assert dataset.num_rows == 4
 assert dataset.num_columns == 1
 assert dataset.column_names == ["text"]
 for feature, expected_dtype in expected_features.items():
  assert dataset.features[feature].dtype == expected_dtype




@pytest.mark.parametrize('keep_in_memory'  ,	[False, True]     )
def 				UpperCamelCase(					UpperCAmelCase_  ,	UpperCAmelCase_  ,	UpperCAmelCase_     ):
 UpperCAmelCase	:     int						 =			tmp_path / 'cache'
 UpperCAmelCase	:     List[str]						 =			{'text': 'string'}
 with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
  UpperCAmelCase	:     Tuple						 =			TextDatasetReader(UpperCAmelCase_  ,	cache_dir=UpperCAmelCase_  ,	keep_in_memory=UpperCAmelCase_     ).read()
 _check_text_dataset(UpperCAmelCase_  ,	UpperCAmelCase_     )




@pytest.mark.parametrize(
    'features'  ,	[
        None,
        {'text': 'string'},
        {'text': 'int32'},
        {'text': 'float32'},
    ]  ,	)
def 				UpperCamelCase(					UpperCAmelCase_  ,	UpperCAmelCase_  ,	UpperCAmelCase_     ):
 UpperCAmelCase	:     Optional[int]						 =			tmp_path / 'cache'
 UpperCAmelCase	:     List[str]						 =			{'text': 'string'}
 UpperCAmelCase	:     Optional[int]						 =			features.copy() if features else default_expected_features
 UpperCAmelCase	:     int						 =			(
     Features({feature: Value(UpperCAmelCase_     ) for feature, dtype in features.items()}     ) if features is not None else None
 )
 UpperCAmelCase	:     Union[str, Any]						 =			TextDatasetReader(UpperCAmelCase_  ,	features=UpperCAmelCase_  ,	cache_dir=UpperCAmelCase_     ).read()
 _check_text_dataset(UpperCAmelCase_  ,	UpperCAmelCase_     )




@pytest.mark.parametrize('split'  ,	[None, NamedSplit('train'     ), 'train', 'test']     )
def 				UpperCamelCase(					UpperCAmelCase_  ,	UpperCAmelCase_  ,	UpperCAmelCase_     ):
 UpperCAmelCase	:     Optional[int]						 =			tmp_path / 'cache'
 UpperCAmelCase	:     Tuple						 =			{'text': 'string'}
 UpperCAmelCase	:     List[str]						 =			TextDatasetReader(UpperCAmelCase_  ,	cache_dir=UpperCAmelCase_  ,	split=UpperCAmelCase_     ).read()
 _check_text_dataset(UpperCAmelCase_  ,	UpperCAmelCase_     )
 assert dataset.split == split if split else "train"




@pytest.mark.parametrize('path_type'  ,	[str, list]     )
def 				UpperCamelCase(					UpperCAmelCase_  ,	UpperCAmelCase_  ,	UpperCAmelCase_     ):
 if issubclass(UpperCAmelCase_  ,	UpperCAmelCase_     ):
  UpperCAmelCase	:     Tuple						 =			text_path
 elif issubclass(UpperCAmelCase_  ,	UpperCAmelCase_     ):
  UpperCAmelCase	:     Optional[Any]						 =			[text_path]
 UpperCAmelCase	:     List[Any]						 =			tmp_path / 'cache'
 UpperCAmelCase	:     Union[str, Any]						 =			{'text': 'string'}
 UpperCAmelCase	:     List[Any]						 =			TextDatasetReader(UpperCAmelCase_  ,	cache_dir=UpperCAmelCase_     ).read()
 _check_text_dataset(UpperCAmelCase_  ,	UpperCAmelCase_     )




def 				UpperCamelCase(					UpperCAmelCase_  ,	UpperCAmelCase_  ,	UpperCAmelCase_=("train",)     ):
 assert isinstance(UpperCAmelCase_  ,	UpperCAmelCase_     )
 for split in splits:
  UpperCAmelCase	:     Union[str, Any]						 =			dataset_dict[split]
  assert dataset.num_rows == 4
  assert dataset.num_columns == 1
  assert dataset.column_names == ["text"]
  for feature, expected_dtype in expected_features.items():
   assert dataset.features[feature].dtype == expected_dtype




@pytest.mark.parametrize('keep_in_memory'  ,	[False, True]     )
def 				UpperCamelCase(					UpperCAmelCase_  ,	UpperCAmelCase_  ,	UpperCAmelCase_     ):
 UpperCAmelCase	:     Any						 =			tmp_path / 'cache'
 UpperCAmelCase	:     List[str]						 =			{'text': 'string'}
 with assert_arrow_memory_increases() if keep_in_memory else assert_arrow_memory_doesnt_increase():
  UpperCAmelCase	:     int						 =			TextDatasetReader({'train': text_path}  ,	cache_dir=UpperCAmelCase_  ,	keep_in_memory=UpperCAmelCase_     ).read()
 _check_text_datasetdict(UpperCAmelCase_  ,	UpperCAmelCase_     )




@pytest.mark.parametrize(
    'features'  ,	[
        None,
        {'text': 'string'},
        {'text': 'int32'},
        {'text': 'float32'},
    ]  ,	)
def 				UpperCamelCase(					UpperCAmelCase_  ,	UpperCAmelCase_  ,	UpperCAmelCase_     ):
 UpperCAmelCase	:     Union[str, Any]						 =			tmp_path / 'cache'
 # CSV file loses col_1 string dtype information: default now is "int64" instead of "string"
 UpperCAmelCase	:     Tuple						 =			{'text': 'string'}
 UpperCAmelCase	:     Union[str, Any]						 =			features.copy() if features else default_expected_features
 UpperCAmelCase	:     int						 =			(
     Features({feature: Value(UpperCAmelCase_     ) for feature, dtype in features.items()}     ) if features is not None else None
 )
 UpperCAmelCase	:     List[Any]						 =			TextDatasetReader({'train': text_path}  ,	features=UpperCAmelCase_  ,	cache_dir=UpperCAmelCase_     ).read()
 _check_text_datasetdict(UpperCAmelCase_  ,	UpperCAmelCase_     )




@pytest.mark.parametrize('split'  ,	[None, NamedSplit('train'     ), 'train', 'test']     )
def 				UpperCamelCase(					UpperCAmelCase_  ,	UpperCAmelCase_  ,	UpperCAmelCase_     ):
 if split:
  UpperCAmelCase	:     int						 =			{split: text_path}
 else:
  UpperCAmelCase	:     int						 =			'train'
  UpperCAmelCase	:     Any						 =			{'train': text_path, 'test': text_path}
 UpperCAmelCase	:     Dict						 =			tmp_path / 'cache'
 UpperCAmelCase	:     Any						 =			{'text': 'string'}
 UpperCAmelCase	:     List[str]						 =			TextDatasetReader(UpperCAmelCase_  ,	cache_dir=UpperCAmelCase_     ).read()
 _check_text_datasetdict(UpperCAmelCase_  ,	UpperCAmelCase_  ,	splits=list(path.keys()     )     )
 assert all(dataset[split].split == split for split in path.keys()     )




