


import datasets

from .nmt_bleu import compute_bleu  # From: https://github.com/tensorflow/nmt/blob/master/nmt/scripts/bleu.py


__lowerCamelCase        =     '''\
@INPROCEEDINGS{Papineni02bleu:a,
    author = {Kishore Papineni and Salim Roukos and Todd Ward and Wei-jing Zhu},
    title = {BLEU: a Method for Automatic Evaluation of Machine Translation},
    booktitle = {},
    year = {2002},
    pages = {311--318}
}
@inproceedings{lin-och-2004-orange,
    title = \"{ORANGE}: a Method for Evaluating Automatic Evaluation Metrics for Machine Translation\",
    author = \"Lin, Chin-Yew  and
      Och, Franz Josef\",
    booktitle = \"{COLING} 2004: Proceedings of the 20th International Conference on Computational Linguistics\",
    month = \"aug 23{--}aug 27\",
    year = \"2004\",
    address = \"Geneva, Switzerland\",
    publisher = \"COLING\",
    url = \"https://www.aclweb.org/anthology/C04-1072\",
    pages = \"501--507\",
}
'''

__lowerCamelCase        =     '''\
BLEU (bilingual evaluation understudy) is an algorithm for evaluating the quality of text which has been machine-translated from one natural language to another.
Quality is considered to be the correspondence between a machine\'s output and that of a human: \"the closer a machine translation is to a professional human translation,
the better it is\" – this is the central idea behind BLEU. BLEU was one of the first metrics to claim a high correlation with human judgements of quality, and
remains one of the most popular automated and inexpensive metrics.

Scores are calculated for individual translated segments—generally sentences—by comparing them with a set of good quality reference translations.
Those scores are then averaged over the whole corpus to reach an estimate of the translation\'s overall quality. Intelligibility or grammatical correctness
are not taken into account[citation needed].

BLEU\'s output is always a number between 0 and 1. This value indicates how similar the candidate text is to the reference texts, with values closer to 1
representing more similar texts. Few human translations will attain a score of 1, since this would indicate that the candidate is identical to one of the
reference translations. For this reason, it is not necessary to attain a score of 1. Because there are more opportunities to match, adding additional
reference translations will increase the BLEU score.
'''

__lowerCamelCase        =     '''
Computes BLEU score of translated segments against one or more references.
Args:
    predictions: list of translations to score.
        Each translation should be tokenized into a list of tokens.
    references: list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
    max_order: Maximum n-gram order to use when computing BLEU score.
    smooth: Whether or not to apply Lin et al. 2004 smoothing.
Returns:
    \'bleu\': bleu score,
    \'precisions\': geometric mean of n-gram precisions,
    \'brevity_penalty\': brevity penalty,
    \'length_ratio\': ratio of lengths,
    \'translation_length\': translation_length,
    \'reference_length\': reference_length
Examples:

    >>> predictions = [
    ...     [\"hello\", \"there\", \"general\", \"kenobi\"],                             # tokenized prediction of the first sample
    ...     [\"foo\", \"bar\", \"foobar\"]                                             # tokenized prediction of the second sample
    ... ]
    >>> references = [
    ...     [[\"hello\", \"there\", \"general\", \"kenobi\"], [\"hello\", \"there\", \"!\"]],  # tokenized references for the first sample (2 references)
    ...     [[\"foo\", \"bar\", \"foobar\"]]                                           # tokenized references for the second sample (1 reference)
    ... ]
    >>> bleu = datasets.load_metric(\"bleu\")
    >>> results = bleu.compute(predictions=predictions, references=references)
    >>> print(results[\"bleu\"])
    1.0
'''


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

       def 						UpperCAmelCase(   self      :     Union[str, Any]    ):
            return datasets.MetricInfo(
                description=_DESCRIPTION      ,							citation=_CITATION      ,							inputs_description=_KWARGS_DESCRIPTION      ,							features=datasets.Features(
                    {
                        """predictions""": datasets.Sequence(datasets.Value("""string"""      ,							id="""token"""    )      ,							id="""sequence"""    ),
                        """references""": datasets.Sequence(
                            datasets.Sequence(datasets.Value("""string"""      ,							id="""token"""    )      ,							id="""sequence"""    )      ,							id="""references"""    ),
                    }    )      ,							codebase_urls=["""https://github.com/tensorflow/nmt/blob/master/nmt/scripts/bleu.py"""]      ,							reference_urls=[
                    """https://en.wikipedia.org/wiki/BLEU""",
                    """https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213""",
                ]      ,							)

       def 						UpperCAmelCase(   self      :     List[str]      ,							lowerCamelCase_      :     Any      ,							lowerCamelCase_      :     Union[str, Any]      ,							lowerCamelCase_      :     Any=4      ,							lowerCamelCase_      :     str=False    ):
            a_    :     Optional[int]										=    compute_bleu(
                reference_corpus=lowerCamelCase_      ,							translation_corpus=lowerCamelCase_      ,							max_order=lowerCamelCase_      ,							smooth=lowerCamelCase_    )
            ((a_)			,			(a_)			,			(a_)			,			(a_)			,			(a_)			,			(a_))    :     Optional[Any]										=    score
            return {
                "bleu": bleu,
                "precisions": precisions,
                "brevity_penalty": bp,
                "length_ratio": ratio,
                "translation_length": translation_length,
                "reference_length": reference_length,
            }







import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    AutoConfig,
    AutoImageProcessor,
    CLIPConfig,
    CLIPImageProcessor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER


sys.path.append(str(Path(__file__).parent.parent.parent.parent / '''utils'''))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_image_processing import CustomImageProcessor  # noqa E402


class   a__	(						unittest.TestCase    ):

       def 						UpperCAmelCase(   self      :     int    ):
            a_    :     Any										=    0

       def 						UpperCAmelCase(   self      :     Dict    ):
            a_    :     List[str]										=    AutoImageProcessor.from_pretrained("""openai/clip-vit-base-patch32"""    )
            self.assertIsInstance(lowerCamelCase_      ,							lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     int    ):
            with tempfile.TemporaryDirectory() as tmpdirname:
                 a_    :     Any										=    Path(lowerCamelCase_    ) / """preprocessor_config.json"""
                 a_    :     Tuple										=    Path(lowerCamelCase_    ) / """config.json"""
                 json.dump(
                     {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}      ,							open(lowerCamelCase_      ,							"""w"""    )      ,							)
                 json.dump({"""model_type""": """clip"""}      ,							open(lowerCamelCase_      ,							"""w"""    )    )

                 a_    :     Union[str, Any]										=    AutoImageProcessor.from_pretrained(lowerCamelCase_    )
                 self.assertIsInstance(lowerCamelCase_      ,							lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     List[Any]    ):
            # Ensure we can load the image processor from the feature extractor config
            with tempfile.TemporaryDirectory() as tmpdirname:
                 a_    :     Dict										=    Path(lowerCamelCase_    ) / """preprocessor_config.json"""
                 a_    :     List[str]										=    Path(lowerCamelCase_    ) / """config.json"""
                 json.dump(
                     {"""feature_extractor_type""": """CLIPFeatureExtractor""", """processor_class""": """CLIPProcessor"""}      ,							open(lowerCamelCase_      ,							"""w"""    )      ,							)
                 json.dump({"""model_type""": """clip"""}      ,							open(lowerCamelCase_      ,							"""w"""    )    )

                 a_    :     int										=    AutoImageProcessor.from_pretrained(lowerCamelCase_    )
                 self.assertIsInstance(lowerCamelCase_      ,							lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     Optional[Any]    ):
            with tempfile.TemporaryDirectory() as tmpdirname:
                 a_    :     int										=    CLIPConfig()

                 # Create a dummy config file with image_proceesor_type
                 a_    :     Tuple										=    Path(lowerCamelCase_    ) / """preprocessor_config.json"""
                 a_    :     Tuple										=    Path(lowerCamelCase_    ) / """config.json"""
                 json.dump(
                     {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}      ,							open(lowerCamelCase_      ,							"""w"""    )      ,							)
                 json.dump({"""model_type""": """clip"""}      ,							open(lowerCamelCase_      ,							"""w"""    )    )

                 # remove image_processor_type to make sure config.json alone is enough to load image processor locally
                 a_    :     Optional[int]										=    AutoImageProcessor.from_pretrained(lowerCamelCase_    ).to_dict()

                 config_dict.pop("""image_processor_type"""    )
                 a_    :     Tuple										=    CLIPImageProcessor(**lowerCamelCase_    )

                 # save in new folder
                 model_config.save_pretrained(lowerCamelCase_    )
                 config.save_pretrained(lowerCamelCase_    )

                 a_    :     Optional[int]										=    AutoImageProcessor.from_pretrained(lowerCamelCase_    )

                 # make sure private variable is not incorrectly saved
                 a_    :     str										=    json.loads(config.to_json_string()    )
                 self.assertTrue("""_processor_class""" not in dict_as_saved    )

            self.assertIsInstance(lowerCamelCase_      ,							lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     Dict    ):
            with tempfile.TemporaryDirectory() as tmpdirname:
                 a_    :     Union[str, Any]										=    Path(lowerCamelCase_    ) / """preprocessor_config.json"""
                 json.dump(
                     {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}      ,							open(lowerCamelCase_      ,							"""w"""    )      ,							)

                 a_    :     Optional[int]										=    AutoImageProcessor.from_pretrained(lowerCamelCase_    )
                 self.assertIsInstance(lowerCamelCase_      ,							lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     int    ):
            with self.assertRaisesRegex(
                lowerCamelCase_      ,							"""clip-base is not a local folder and is not a valid model identifier"""    ):
                 a_    :     Any										=    AutoImageProcessor.from_pretrained("""clip-base"""    )

       def 						UpperCAmelCase(   self      :     Optional[Any]    ):
            with self.assertRaisesRegex(
                lowerCamelCase_      ,							R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""    ):
                 a_    :     Dict										=    AutoImageProcessor.from_pretrained(lowerCamelCase_      ,							revision="""aaaaaa"""    )

       def 						UpperCAmelCase(   self      :     Dict    ):
            with self.assertRaisesRegex(
                lowerCamelCase_      ,							"""hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json."""      ,							):
                 a_    :     Any										=    AutoImageProcessor.from_pretrained("""hf-internal-testing/config-no-model"""    )

       def 						UpperCAmelCase(   self      :     str    ):
            # If remote code is not set, we will time out when asking whether to load the model.
            with self.assertRaises(lowerCamelCase_    ):
                 a_    :     int										=    AutoImageProcessor.from_pretrained("""hf-internal-testing/test_dynamic_image_processor"""    )
            # If remote code is disabled, we can't load this config.
            with self.assertRaises(lowerCamelCase_    ):
                 a_    :     Tuple										=    AutoImageProcessor.from_pretrained(
                     """hf-internal-testing/test_dynamic_image_processor"""      ,							trust_remote_code=lowerCamelCase_    )

            a_    :     int										=    AutoImageProcessor.from_pretrained(
                """hf-internal-testing/test_dynamic_image_processor"""      ,							trust_remote_code=lowerCamelCase_    )
            self.assertEqual(image_processor.__class__.__name__      ,							"""NewImageProcessor"""    )

            # Test image processor can be reloaded.
            with tempfile.TemporaryDirectory() as tmp_dir:
                 image_processor.save_pretrained(lowerCamelCase_    )
                 a_    :     int										=    AutoImageProcessor.from_pretrained(lowerCamelCase_      ,							trust_remote_code=lowerCamelCase_    )
            self.assertEqual(reloaded_image_processor.__class__.__name__      ,							"""NewImageProcessor"""    )

       def 						UpperCAmelCase(   self      :     List[str]    ):
            try:
                 AutoConfig.register("""custom"""      ,							lowerCamelCase_    )
                 AutoImageProcessor.register(lowerCamelCase_      ,							lowerCamelCase_    )
                 # Trying to register something existing in the Transformers library will raise an error
                 with self.assertRaises(lowerCamelCase_    ):
                      AutoImageProcessor.register(lowerCamelCase_      ,							lowerCamelCase_    )

                 with tempfile.TemporaryDirectory() as tmpdirname:
                      a_    :     Dict										=    Path(lowerCamelCase_    ) / """preprocessor_config.json"""
                      a_    :     Union[str, Any]										=    Path(lowerCamelCase_    ) / """config.json"""
                      json.dump(
                          {"""feature_extractor_type""": """CLIPFeatureExtractor""", """processor_class""": """CLIPProcessor"""}      ,							open(lowerCamelCase_      ,							"""w"""    )      ,							)
                      json.dump({"""model_type""": """clip"""}      ,							open(lowerCamelCase_      ,							"""w"""    )    )

                      a_    :     str										=    CustomImageProcessor.from_pretrained(lowerCamelCase_    )

                 # Now that the config is registered, it can be used as any other config with the auto-API
                 with tempfile.TemporaryDirectory() as tmp_dir:
                      image_processor.save_pretrained(lowerCamelCase_    )
                      a_    :     Any										=    AutoImageProcessor.from_pretrained(lowerCamelCase_    )
                      self.assertIsInstance(lowerCamelCase_      ,							lowerCamelCase_    )

            finally:
                 if "custom" in CONFIG_MAPPING._extra_content:
                      del CONFIG_MAPPING._extra_content["custom"]
                 if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
                      del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]

       def 						UpperCAmelCase(   self      :     Union[str, Any]    ):


            class   a__	(						lowerCAmelCase_    ):
                   lowerCamelCase__:     List[Any]							    =     True

            try:
                 AutoConfig.register("""custom"""      ,							lowerCamelCase_    )
                 AutoImageProcessor.register(lowerCamelCase_      ,							lowerCamelCase_    )
                 # If remote code is not set, the default is to use local
                 a_    :     Dict										=    AutoImageProcessor.from_pretrained("""hf-internal-testing/test_dynamic_image_processor"""    )
                 self.assertEqual(image_processor.__class__.__name__      ,							"""NewImageProcessor"""    )
                 self.assertTrue(image_processor.is_local    )

                 # If remote code is disabled, we load the local one.
                 a_    :     Optional[Any]										=    AutoImageProcessor.from_pretrained(
                     """hf-internal-testing/test_dynamic_image_processor"""      ,							trust_remote_code=lowerCamelCase_    )
                 self.assertEqual(image_processor.__class__.__name__      ,							"""NewImageProcessor"""    )
                 self.assertTrue(image_processor.is_local    )

                 # If remote is enabled, we load from the Hub
                 a_    :     Dict										=    AutoImageProcessor.from_pretrained(
                     """hf-internal-testing/test_dynamic_image_processor"""      ,							trust_remote_code=lowerCamelCase_    )
                 self.assertEqual(image_processor.__class__.__name__      ,							"""NewImageProcessor"""    )
                 self.assertTrue(not hasattr(lowerCamelCase_      ,							"""is_local"""    )    )

            finally:
                 if "custom" in CONFIG_MAPPING._extra_content:
                      del CONFIG_MAPPING._extra_content["custom"]
                 if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
                      del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]



