




import logging
import os
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

from tqdm import auto as tqdm_lib


_lowerCamelCase      :  Dict      						=						{
    "debug": logging.DEBUG,
    "info": logging.INFO,
    "warning": logging.WARNING,
    "error": logging.ERROR,
    "critical": logging.CRITICAL,
}

_lowerCamelCase      :  Tuple      						=						logging.WARNING




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				_lowerCAmelCase    :    str										=      os.getenv("""DATASETS_VERBOSITY"""      ,    UpperCamelCase_       )
				if env_level_str:
								if env_level_str in log_levels:
												return log_levels[env_level_str]
								else:
												logging.getLogger().warning(
												    F"Unknown option DATASETS_VERBOSITY={env_level_str}, "
												    F"has to be one of: { ', '.join(log_levels.keys()       ) }"       )
				return _default_log_level




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				return __name__.split("""."""       )[0]




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				return logging.getLogger(_get_library_name()       )




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				# Apply our default configuration to the library root logger.
				_lowerCAmelCase    :    str										=      _get_library_root_logger()
				library_root_logger.setLevel(_get_default_logging_level()       )




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				_lowerCAmelCase    :    List[Any]										=      _get_library_root_logger()
				library_root_logger.setLevel(logging.NOTSET       )




def 							_UpperCAmelCase  (UpperCamelCase_ : Optional[str] = None       ):
				'''simple docstring'''
				if name is None:
								_lowerCAmelCase    :    Optional[int]										=      _get_library_name()
				return logging.getLogger(UpperCamelCase_       )




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				return _get_library_root_logger().getEffectiveLevel()




def 							_UpperCAmelCase  (UpperCamelCase_ : int       ):
				'''simple docstring'''
				_get_library_root_logger().setLevel(UpperCamelCase_       )




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				return set_verbosity(UpperCamelCase_       )




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				return set_verbosity(UpperCamelCase_       )




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				return set_verbosity(UpperCamelCase_       )




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				return set_verbosity(UpperCamelCase_       )




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				_lowerCAmelCase    :    Tuple										=      False




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				_lowerCAmelCase    :    List[Any]										=      True


# Configure the library root logger at the module level (singleton-like)
_configure_library_root_logger()
class        __snake_case  :



				def __init__(      self      :		List[Any]		,	*_UpperCAmelCase      :		Dict		,	**_UpperCAmelCase      :		Any      )  ->    Tuple:  # pylint: disable=unused-argument





								'''simple docstring'''




								_lowerCAmelCase    :    Dict										=      args[0] if args else None



				def __iter__(      self      :		List[str]      )  ->    Union[str, Any]:





								'''simple docstring'''




								return iter(self._iterator      )



				def __getattr__(      self      :		Dict		,	_UpperCAmelCase      :		str      )  ->    Dict:





								'''simple docstring'''




								def empty_fn(*_UpperCAmelCase      :		str		,	**_UpperCAmelCase      :		Tuple      ):  # pylint: disable=unused-argument
												return

								return empty_fn



				def __enter__(      self      :		Dict      )  ->    Tuple:





								'''simple docstring'''




								return self



				def __exit__(      self      :		Tuple		,	_UpperCAmelCase      :		int		,	_UpperCAmelCase      :		Any		,	_UpperCAmelCase      :		Any      )  ->    List[Any]:





								'''simple docstring'''




								return






_lowerCamelCase      :  Any      						=						True
class        __snake_case  :



				def __call__(      self      :		Any		,	*_UpperCAmelCase      :		Optional[int]		,	_UpperCAmelCase      :		str=False		,	**_UpperCAmelCase      :		Dict      )  ->    List[str]:





								'''simple docstring'''




								if _tqdm_active and not disable:
												return tqdm_lib.tqdm(*_UpperCAmelCase		,	**_UpperCAmelCase      )
								else:
												return EmptyTqdm(*_UpperCAmelCase		,	**_UpperCAmelCase      )



				def       SCREAMING_SNAKE_CASE       (      self      :		Dict		,	*_UpperCAmelCase      :		Dict		,	**_UpperCAmelCase      :		List[Any]      )  ->    List[str]:





								'''simple docstring'''




								_lowerCAmelCase    :    List[str]										=      None
								if _tqdm_active:
												return tqdm_lib.tqdm.set_lock(*_UpperCAmelCase		,	**_UpperCAmelCase      )



				def       SCREAMING_SNAKE_CASE       (      self      :		List[Any]      )  ->    Any:





								'''simple docstring'''




								if _tqdm_active:
												return tqdm_lib.tqdm.get_lock()






_lowerCamelCase      :  Any      						=						_tqdm_cls()




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				global _tqdm_active
				return bool(_tqdm_active       )




def 							_UpperCAmelCase  ():
				'''simple docstring'''
				global _tqdm_active
				_lowerCAmelCase    :    List[Any]										=      True





def 							_UpperCAmelCase  ():
				'''simple docstring'''
				global _tqdm_active
				_lowerCAmelCase    :    List[Any]										=      False







import comet  # From: unbabel-comet
import torch

import datasets


_lowerCamelCase      :  List[Any]      						=						datasets.logging.get_logger(__name__)

_lowerCamelCase      :  Optional[Any]      						=						"\\n@inproceedings{rei-EtAl:2020:WMT,\n   author    = {Rei, Ricardo  and  Stewart, Craig  and  Farinha, Ana C  and  Lavie, Alon},\n   title     = {Unbabel's Participation in the WMT20 Metrics Shared Task},\n   booktitle      = {Proceedings of the Fifth Conference on Machine Translation},\n   month          = {November},\n   year           = {2020},\n   address        = {Online},\n   publisher      = {Association for Computational Linguistics},\n   pages     = {909--918},\n}\n@inproceedings{rei-etal-2020-comet,\n   title = \"{COMET}: A Neural Framework for {MT} Evaluation\",\n   author = \"Rei, Ricardo  and\n      Stewart, Craig  and\n      Farinha, Ana C  and\n      Lavie, Alon\",\n   booktitle = \"Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)\",\n   month = nov,\n   year = \"2020\",\n   address = \"Online\",\n   publisher = \"Association for Computational Linguistics\",\n   url = \"https://www.aclweb.org/anthology/2020.emnlp-main.213\",\n   pages = \"2685--2702\",\n}\n"

_lowerCamelCase      :  Union[str, Any]      						=						"\\nCrosslingual Optimized Metric for Evaluation of Translation (COMET) is an open-source framework used to train Machine Translation metrics that achieve high levels of correlation with different types of human judgments (HTER, DA's or MQM).\nWith the release of the framework the authors also released fully trained models that were used to compete in the WMT20 Metrics Shared Task achieving SOTA in that years competition.\n\nSee the [README.md] file at https://unbabel.github.io/COMET/html/models.html for more information.\n"

_lowerCamelCase      :  Optional[int]      						=						"\nCOMET score.\n\nArgs:\n\n`sources` (list of str): Source sentences\n`predictions` (list of str): candidate translations\n`references` (list of str): reference translations\n`cuda` (bool): If set to True, runs COMET using GPU\n`show_progress` (bool): Shows progress\n`model`: COMET model to be used. Will default to `wmt-large-da-estimator-1719` if None.\n\nReturns:\n    `samples`: List of dictionaries with `src`, `mt`, `ref` and `score`.\n    `scores`: List of scores.\n\nExamples:\n\n    >>> comet_metric = datasets.load_metric('comet')\n    >>> # comet_metric = load_metric('comet', 'wmt20-comet-da')  # you can also choose which model to use\n    >>> source = [\"Dem Feuer konnte Einhalt geboten werden\", \"Schulen und Kindergärten wurden eröffnet.\"]\n    >>> hypothesis = [\"The fire could be stopped\", \"Schools and kindergartens were open\"]\n    >>> reference = [\"They were able to control the fire.\", \"Schools and kindergartens opened\"]\n    >>> results = comet_metric.compute(predictions=hypothesis, references=reference, sources=source)\n    >>> print([round(v, 2) for v in results[\"scores\"]])\n    [0.19, 0.92]\n"
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION						,	_KWARGS_DESCRIPTION		)
class        __snake_case  (datasets.Metric		):



				def       SCREAMING_SNAKE_CASE       (      self      :		List[Any]      )  ->    Tuple:





								'''simple docstring'''




								return datasets.MetricInfo(
								    description=_DESCRIPTION		,	citation=_CITATION		,	homepage="""https://unbabel.github.io/COMET/html/index.html"""		,	inputs_description=_KWARGS_DESCRIPTION		,	features=datasets.Features(
								        {
								            """sources""": datasets.Value("""string"""		,	id="""sequence"""      ),
								            """predictions""": datasets.Value("""string"""		,	id="""sequence"""      ),
								            """references""": datasets.Value("""string"""		,	id="""sequence"""      ),
								        }      )		,	codebase_urls=["""https://github.com/Unbabel/COMET"""]		,	reference_urls=[
								        """https://github.com/Unbabel/COMET""",
								        """https://www.aclweb.org/anthology/2020.emnlp-main.213/""",
								        """http://www.statmt.org/wmt20/pdf/2020.wmt-1.101.pdf6""",
								    ]		,	)



				def       SCREAMING_SNAKE_CASE       (      self      :		Dict		,	_UpperCAmelCase      :		List[str]      )  ->    Dict:





								'''simple docstring'''




								if self.config_name == "default":
												_lowerCAmelCase    :    Union[str, Any]										=      comet.load_from_checkpoint(comet.download_model("""wmt20-comet-da"""      )      )
								else:
												_lowerCAmelCase    :    Dict										=      comet.load_from_checkpoint(comet.download_model(self.config_name      )      )



				def       SCREAMING_SNAKE_CASE       (      self      :		Tuple		,	_UpperCAmelCase      :		Dict		,	_UpperCAmelCase      :		int		,	_UpperCAmelCase      :		Union[str, Any]		,	_UpperCAmelCase      :		Dict=None		,	_UpperCAmelCase      :		Tuple=False      )  ->    int:





								'''simple docstring'''




								if gpus is None:
												_lowerCAmelCase    :    Tuple										=      1 if torch.cuda.is_available() else 0
								_lowerCAmelCase    :    Optional[int]										=      {"""src""": sources, """mt""": predictions, """ref""": references}
								_lowerCAmelCase    :    List[Any]										=      [dict(zip(_UpperCAmelCase		,	_UpperCAmelCase      )      ) for t in zip(*data.values()      )]
								_lowerCAmelCase					,    _lowerCAmelCase    :    Optional[Any]										=      self.scorer.predict(_UpperCAmelCase		,	gpus=_UpperCAmelCase		,	progress_bar=_UpperCAmelCase      )
								return {"mean_score": mean_score, "scores": scores}

