
'''simple docstring'''







import importlib.metadata
import operator
import re
import sys
from typing import Optional

from packaging import version


lowercase					:							Optional[Any]   =      {
    "<": operator.lt,
    "<=": operator.le,
    "==": operator.eq,
    "!=": operator.ne,
    ">=": operator.ge,
    ">": operator.gt,
}







def        SCREAMING_SNAKE_CASE__			(     __A    ,       __A    ,       __A    ,       __A    ,       __A    ,       __A			) ->			Any:
	if got_ver is None or want_ver is None:
		raise ValueError(
		    F'Unable to compare versions for {requirement}: need={want_ver} found={got_ver}. This is unusual. Consider'
		    F' reinstalling {pkg}.'			)
	if not ops[op](version.parse(__A			)    ,       version.parse(__A			)			):
		raise ImportError(
		    F'{requirement} is required for a normal functioning of this module, but found {pkg}=={got_ver}.{hint}'			)







def        SCREAMING_SNAKE_CASE__			(     __A    ,       __A = None			) ->			None:
	_snake_case     		=	F'\n{hint}' if hint is not None else ''

	# non-versioned check
	if re.match(r'^[\w_\-\d]+$'    ,       __A			):
		_snake_case		,				_snake_case		,				_snake_case     		=	requirement, None, None
	else:
		_snake_case     		=	re.findall(r'^([^!=<>\s]+)([\s!=<>]{1,2}.+)'    ,       __A			)
		if not match:
			raise ValueError(
			    'requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23, but'
			    F' got {requirement}'			)
		_snake_case		,				_snake_case     		=	match[0]
		_snake_case     		=	want_full.split(','			)  # there could be multiple requirements
		_snake_case     		=	{}
		for w in want_range:
			_snake_case     		=	re.findall(r'^([\s!=<>]{1,2})(.+)'    ,       __A			)
			if not match:
				raise ValueError(
				    'requirement needs to be in the pip package format, .e.g., package_a==1.23, or package_b>=1.23,'
				    F' but got {requirement}'			)
			_snake_case		,				_snake_case     		=	match[0]
			_snake_case     		=	want_ver
			if op not in ops:
				raise ValueError(F'{requirement}: need one of {list(ops.keys()			)}, but got {op}'			)

    # special case
	if pkg == "python":
		_snake_case     		=	'.'.join([str(__A			) for x in sys.version_info[:3]]			)
		for op, want_ver in wanted.items():
			_compare_versions(__A    ,       __A    ,       __A    ,       __A    ,       __A    ,       __A			)
		return

	# check if any version is installed
	try:
		_snake_case     		=	importlib.metadata.version(__A			)
	except importlib.metadata.PackageNotFoundError:
		raise importlib.metadata.PackageNotFoundError(
		    F'The \'{requirement}\' distribution was not found and is required by this application. {hint}'			)

	# check that the right version is installed if version number or a range was provided
	if want_ver is not None:
		for op, want_ver in wanted.items():
			_compare_versions(__A    ,       __A    ,       __A    ,       __A    ,       __A    ,       __A			)







def        SCREAMING_SNAKE_CASE__			(     __A			) ->			int:
	_snake_case     		=	'Try: pip install transformers -U or pip install -e \'.[dev]\' if you\'re working with git main'
	return require_version(__A    ,       __A			)



'''simple docstring'''







import numpy as np
from nltk.translate import meteor_score

import datasets
from datasets.config import importlib_metadata, version


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


lowercase					:							int   =      "\\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					:							Any   =      "\\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					:							Optional[Any]   =      "\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 		__UpperCAmelCase   (      datasets.Metric		):


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								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 				lowerCamelCase       ( self					,     lowerCAmelCase_						):





								"""simple docstring"""






								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 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_=0.9					,     lowerCAmelCase_=3					,     lowerCAmelCase_=0.5						):





								"""simple docstring"""






								if NLTK_VERSION >= version.Version('3.6.5'						):
									_snake_case     		=	[
									    meteor_score.single_meteor_score(
									        word_tokenize(lowerCAmelCase_						)					,     word_tokenize(lowerCAmelCase_						)					,     alpha=lowerCAmelCase_					,     beta=lowerCAmelCase_					,     gamma=lowerCAmelCase_						)
									    for ref, pred in zip(lowerCAmelCase_					,     lowerCAmelCase_						)
									]
								else:
									_snake_case     		=	[
									    meteor_score.single_meteor_score(lowerCAmelCase_					,     lowerCAmelCase_					,     alpha=lowerCAmelCase_					,     beta=lowerCAmelCase_					,     gamma=lowerCAmelCase_						)
									    for ref, pred in zip(lowerCAmelCase_					,     lowerCAmelCase_						)
									]

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

