





"""simple docstring"""





import argparse
import json
import os
import sys
import tempfile
import unittest
from argparse import Namespace
from dataclasses import dataclass, field
from enum import Enum
from pathlib import Path
from typing import List, Literal, Optional

import yaml

from transformers import HfArgumentParser, TrainingArguments
from transformers.hf_argparser import make_choice_type_function, string_to_bool


# Since Python 3.10, we can use the builtin `|` operator for Union types
# See PEP 604: https://peps.python.org/pep-0604
SCREAMING_SNAKE_CASE__					=   sys.version_info >= (3, 10)


def 			UpperCAmelCase__							(  SCREAMING_SNAKE_CASE     :						Dict=None							,						SCREAMING_SNAKE_CASE     :						Any=None			):







      '''simple docstring'''




      return field(default_factory=lambda: default							,						metadata=SCREAMING_SNAKE_CASE			)

@dataclass
class 		lowercase					:
      _SCREAMING_SNAKE_CASE					=      42
      _SCREAMING_SNAKE_CASE					=      42
      _SCREAMING_SNAKE_CASE					=      42
      _SCREAMING_SNAKE_CASE					=      42







@dataclass
class 		lowercase					:
      _SCREAMING_SNAKE_CASE					=      42
      _SCREAMING_SNAKE_CASE					=      field(default='toto'     ,  metadata={'help': 'help message'}					)







@dataclass
class 		lowercase					:
      _SCREAMING_SNAKE_CASE					=      False
      _SCREAMING_SNAKE_CASE					=      True
      _SCREAMING_SNAKE_CASE					=      None







class 		lowercase					(					_UpperCAmelCase					):
      _SCREAMING_SNAKE_CASE					=      'titi'
      _SCREAMING_SNAKE_CASE					=      'toto'







class 		lowercase					(					_UpperCAmelCase					):
      _SCREAMING_SNAKE_CASE					=      'titi'
      _SCREAMING_SNAKE_CASE					=      'toto'
      _SCREAMING_SNAKE_CASE					=      42







@dataclass
class 		lowercase					:
      _SCREAMING_SNAKE_CASE					=      "toto"





      def     _snake_case			(       self )		->     Any:
            lowerCAmelCase  						=       BasicEnum(self.foo )







@dataclass
class 		lowercase					:
      _SCREAMING_SNAKE_CASE					=      "toto"





      def     _snake_case			(       self )		->     Tuple:
            lowerCAmelCase  						=       MixedTypeEnum(self.foo )







@dataclass
class 		lowercase					:
      _SCREAMING_SNAKE_CASE					=      None
      _SCREAMING_SNAKE_CASE					=      field(default=_UpperCAmelCase     ,  metadata={'help': 'help message'}					)
      _SCREAMING_SNAKE_CASE					=      None
      _SCREAMING_SNAKE_CASE					=      list_field(default=[]					)
      _SCREAMING_SNAKE_CASE					=      list_field(default=[]					)







@dataclass
class 		lowercase					:
      _SCREAMING_SNAKE_CASE					=      list_field(default=[]					)
      _SCREAMING_SNAKE_CASE					=      list_field(default=[1, 2, 3]					)
      _SCREAMING_SNAKE_CASE					=      list_field(default=['Hallo', 'Bonjour', 'Hello']					)
      _SCREAMING_SNAKE_CASE					=      list_field(default=[0.1, 0.2, 0.3]					)







@dataclass
class 		lowercase					:
      _SCREAMING_SNAKE_CASE					=      field()
      _SCREAMING_SNAKE_CASE					=      field()
      _SCREAMING_SNAKE_CASE					=      field()





      def     _snake_case			(       self )		->     Optional[int]:
            lowerCAmelCase  						=       BasicEnum(self.required_enum )







@dataclass
class 		lowercase					:
      _SCREAMING_SNAKE_CASE					=      42
      _SCREAMING_SNAKE_CASE					=      field()
      _SCREAMING_SNAKE_CASE					=      None
      _SCREAMING_SNAKE_CASE					=      field(default='toto'     ,  metadata={'help': 'help message'}					)
      _SCREAMING_SNAKE_CASE					=      list_field(default=['Hallo', 'Bonjour', 'Hello']					)


if is_python_no_less_than_3_10:

       @dataclass
       class 		lowercase					:
             _SCREAMING_SNAKE_CASE					=      False
             _SCREAMING_SNAKE_CASE					=      True
             _SCREAMING_SNAKE_CASE					=      None







       @dataclass
       class 		lowercase					:
             _SCREAMING_SNAKE_CASE					=      None
             _SCREAMING_SNAKE_CASE					=      field(default=_UpperCAmelCase     ,  metadata={'help': 'help message'}					)
             _SCREAMING_SNAKE_CASE					=      None
             _SCREAMING_SNAKE_CASE					=      list_field(default=[]					)
             _SCREAMING_SNAKE_CASE					=      list_field(default=[]					)






class 		lowercase					(					unittest.TestCase					):





      def     _snake_case			(       self      ,						lowercase      ,						lowercase )		->     Tuple:
            self.assertEqual(len(a._actions )      ,						len(b._actions ) )
            for x, y in zip(a._actions      ,						b._actions ):
                  lowerCAmelCase  						=       {k: v for k, v in vars(lowercase ).items() if k != """container"""}
                  lowerCAmelCase  						=       {k: v for k, v in vars(lowercase ).items() if k != """container"""}

                  # Choices with mixed type have custom function as "type"
                  # So we need to compare results directly for equality
                  if xx.get("""choices"""      ,						lowercase ) and yy.get("""choices"""      ,						lowercase ):
                        for expected_choice in yy["choices"] + xx["choices"]:
                              self.assertEqual(xx["""type"""](lowercase )      ,						yy["""type"""](lowercase ) )
                        del xx["type"], yy["type"]

                  self.assertEqual(lowercase      ,						lowercase )





      def     _snake_case			(       self )		->     str:
            lowerCAmelCase  						=       HfArgumentParser(lowercase )

            lowerCAmelCase  						=       argparse.ArgumentParser()
            expected.add_argument("""--foo"""      ,						type=lowercase      ,						required=lowercase )
            expected.add_argument("""--bar"""      ,						type=lowercase      ,						required=lowercase )
            expected.add_argument("""--baz"""      ,						type=lowercase      ,						required=lowercase )
            expected.add_argument("""--flag"""      ,						type=lowercase      ,						default=lowercase      ,						const=lowercase      ,						nargs="""?""" )
            self.argparsersEqual(lowercase      ,						lowercase )

            lowerCAmelCase  						=       ["""--foo""", """1""", """--baz""", """quux""", """--bar""", """0.5"""]
            ((lowerCAmelCase)						,		)  						=       parser.parse_args_into_dataclasses(lowercase      ,						look_for_args_file=lowercase )
            self.assertFalse(example.flag )





      def     _snake_case			(       self )		->     str:
            lowerCAmelCase  						=       HfArgumentParser(lowercase )

            lowerCAmelCase  						=       argparse.ArgumentParser()
            expected.add_argument("""--foo"""      ,						default=42      ,						type=lowercase )
            expected.add_argument("""--baz"""      ,						default="""toto"""      ,						type=lowercase      ,						help="""help message""" )
            self.argparsersEqual(lowercase      ,						lowercase )





      def     _snake_case			(       self )		->     List[Any]:
            lowerCAmelCase  						=       argparse.ArgumentParser()
            expected.add_argument("""--foo"""      ,						type=lowercase      ,						default=lowercase      ,						const=lowercase      ,						nargs="""?""" )
            expected.add_argument("""--baz"""      ,						type=lowercase      ,						default=lowercase      ,						const=lowercase      ,						nargs="""?""" )
            # A boolean no_* argument always has to come after its "default: True" regular counter-part
            # and its default must be set to False
            expected.add_argument("""--no_baz"""      ,						action="""store_false"""      ,						default=lowercase      ,						dest="""baz""" )
            expected.add_argument("""--opt"""      ,						type=lowercase      ,						default=lowercase )

            lowerCAmelCase  						=       [WithDefaultBoolExample]
            if is_python_no_less_than_3_10:
                  dataclass_types.append(lowercase )

            for dataclass_type in dataclass_types:
                  lowerCAmelCase  						=       HfArgumentParser(lowercase )
                  self.argparsersEqual(lowercase      ,						lowercase )

                  lowerCAmelCase  						=       parser.parse_args([] )
                  self.assertEqual(lowercase      ,						Namespace(foo=lowercase      ,						baz=lowercase      ,						opt=lowercase ) )

                  lowerCAmelCase  						=       parser.parse_args(["""--foo""", """--no_baz"""] )
                  self.assertEqual(lowercase      ,						Namespace(foo=lowercase      ,						baz=lowercase      ,						opt=lowercase ) )

                  lowerCAmelCase  						=       parser.parse_args(["""--foo""", """--baz"""] )
                  self.assertEqual(lowercase      ,						Namespace(foo=lowercase      ,						baz=lowercase      ,						opt=lowercase ) )

                  lowerCAmelCase  						=       parser.parse_args(["""--foo""", """True""", """--baz""", """True""", """--opt""", """True"""] )
                  self.assertEqual(lowercase      ,						Namespace(foo=lowercase      ,						baz=lowercase      ,						opt=lowercase ) )

                  lowerCAmelCase  						=       parser.parse_args(["""--foo""", """False""", """--baz""", """False""", """--opt""", """False"""] )
                  self.assertEqual(lowercase      ,						Namespace(foo=lowercase      ,						baz=lowercase      ,						opt=lowercase ) )





      def     _snake_case			(       self )		->     List[Any]:
            lowerCAmelCase  						=       HfArgumentParser(lowercase )

            lowerCAmelCase  						=       argparse.ArgumentParser()
            expected.add_argument(
                """--foo"""      ,						default="""toto"""      ,						choices=["""titi""", """toto""", 42]      ,						type=make_choice_type_function(["""titi""", """toto""", 42] )      ,						)
            self.argparsersEqual(lowercase      ,						lowercase )

            lowerCAmelCase  						=       parser.parse_args([] )
            self.assertEqual(args.foo      ,						"""toto""" )
            lowerCAmelCase  						=       parser.parse_args_into_dataclasses([] )[0]
            self.assertEqual(enum_ex.foo      ,						MixedTypeEnum.toto )

            lowerCAmelCase  						=       parser.parse_args(["""--foo""", """titi"""] )
            self.assertEqual(args.foo      ,						"""titi""" )
            lowerCAmelCase  						=       parser.parse_args_into_dataclasses(["""--foo""", """titi"""] )[0]
            self.assertEqual(enum_ex.foo      ,						MixedTypeEnum.titi )

            lowerCAmelCase  						=       parser.parse_args(["""--foo""", """42"""] )
            self.assertEqual(args.foo      ,						42 )
            lowerCAmelCase  						=       parser.parse_args_into_dataclasses(["""--foo""", """42"""] )[0]
            self.assertEqual(enum_ex.foo      ,						MixedTypeEnum.fourtytwo )





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

            @dataclass
            class 		lowercase					:
                  _SCREAMING_SNAKE_CASE					=      "toto"







            lowerCAmelCase  						=       HfArgumentParser(lowercase )

            lowerCAmelCase  						=       argparse.ArgumentParser()
            expected.add_argument(
                """--foo"""      ,						default="""toto"""      ,						choices=("""titi""", """toto""", 42)      ,						type=make_choice_type_function(["""titi""", """toto""", 42] )      ,						)
            self.argparsersEqual(lowercase      ,						lowercase )

            lowerCAmelCase  						=       parser.parse_args([] )
            self.assertEqual(args.foo      ,						"""toto""" )

            lowerCAmelCase  						=       parser.parse_args(["""--foo""", """titi"""] )
            self.assertEqual(args.foo      ,						"""titi""" )

            lowerCAmelCase  						=       parser.parse_args(["""--foo""", """42"""] )
            self.assertEqual(args.foo      ,						42 )





      def     _snake_case			(       self )		->     str:
            lowerCAmelCase  						=       HfArgumentParser(lowercase )

            lowerCAmelCase  						=       argparse.ArgumentParser()
            expected.add_argument("""--foo_int"""      ,						nargs="""+"""      ,						default=[]      ,						type=lowercase )
            expected.add_argument("""--bar_int"""      ,						nargs="""+"""      ,						default=[1, 2, 3]      ,						type=lowercase )
            expected.add_argument("""--foo_str"""      ,						nargs="""+"""      ,						default=["""Hallo""", """Bonjour""", """Hello"""]      ,						type=lowercase )
            expected.add_argument("""--foo_float"""      ,						nargs="""+"""      ,						default=[0.1, 0.2, 0.3]      ,						type=lowercase )

            self.argparsersEqual(lowercase      ,						lowercase )

            lowerCAmelCase  						=       parser.parse_args([] )
            self.assertEqual(
                lowercase      ,						Namespace(foo_int=[]      ,						bar_int=[1, 2, 3]      ,						foo_str=["""Hallo""", """Bonjour""", """Hello"""]      ,						foo_float=[0.1, 0.2, 0.3] )      ,						)

            lowerCAmelCase  						=       parser.parse_args("""--foo_int 1 --bar_int 2 3 --foo_str a b c --foo_float 0.1 0.7""".split() )
            self.assertEqual(lowercase      ,						Namespace(foo_int=[1]      ,						bar_int=[2, 3]      ,						foo_str=["""a""", """b""", """c"""]      ,						foo_float=[0.1, 0.7] ) )





      def     _snake_case			(       self )		->     str:
            lowerCAmelCase  						=       argparse.ArgumentParser()
            expected.add_argument("""--foo"""      ,						default=lowercase      ,						type=lowercase )
            expected.add_argument("""--bar"""      ,						default=lowercase      ,						type=lowercase      ,						help="""help message""" )
            expected.add_argument("""--baz"""      ,						default=lowercase      ,						type=lowercase )
            expected.add_argument("""--ces"""      ,						nargs="""+"""      ,						default=[]      ,						type=lowercase )
            expected.add_argument("""--des"""      ,						nargs="""+"""      ,						default=[]      ,						type=lowercase )

            lowerCAmelCase  						=       [OptionalExample]
            if is_python_no_less_than_3_10:
                  dataclass_types.append(lowercase )

            for dataclass_type in dataclass_types:
                  lowerCAmelCase  						=       HfArgumentParser(lowercase )

                  self.argparsersEqual(lowercase      ,						lowercase )

                  lowerCAmelCase  						=       parser.parse_args([] )
                  self.assertEqual(lowercase      ,						Namespace(foo=lowercase      ,						bar=lowercase      ,						baz=lowercase      ,						ces=[]      ,						des=[] ) )

                  lowerCAmelCase  						=       parser.parse_args("""--foo 12 --bar 3.14 --baz 42 --ces a b c --des 1 2 3""".split() )
                  self.assertEqual(lowercase      ,						Namespace(foo=12      ,						bar=3.14      ,						baz="""42"""      ,						ces=["""a""", """b""", """c"""]      ,						des=[1, 2, 3] ) )





      def     _snake_case			(       self )		->     Optional[Any]:
            lowerCAmelCase  						=       HfArgumentParser(lowercase )

            lowerCAmelCase  						=       argparse.ArgumentParser()
            expected.add_argument("""--required_list"""      ,						nargs="""+"""      ,						type=lowercase      ,						required=lowercase )
            expected.add_argument("""--required_str"""      ,						type=lowercase      ,						required=lowercase )
            expected.add_argument(
                """--required_enum"""      ,						type=make_choice_type_function(["""titi""", """toto"""] )      ,						choices=["""titi""", """toto"""]      ,						required=lowercase      ,						)
            self.argparsersEqual(lowercase      ,						lowercase )





      def     _snake_case			(       self )		->     Union[str, Any]:
            lowerCAmelCase  						=       HfArgumentParser(lowercase )

            lowerCAmelCase  						=       argparse.ArgumentParser()
            expected.add_argument("""--foo"""      ,						type=lowercase      ,						required=lowercase )
            expected.add_argument(
                """--required_enum"""      ,						type=make_choice_type_function(["""titi""", """toto"""] )      ,						choices=["""titi""", """toto"""]      ,						required=lowercase      ,						)
            expected.add_argument("""--opt"""      ,						type=lowercase      ,						default=lowercase )
            expected.add_argument("""--baz"""      ,						default="""toto"""      ,						type=lowercase      ,						help="""help message""" )
            expected.add_argument("""--foo_str"""      ,						nargs="""+"""      ,						default=["""Hallo""", """Bonjour""", """Hello"""]      ,						type=lowercase )
            self.argparsersEqual(lowercase      ,						lowercase )





      def     _snake_case			(       self )		->     str:
            lowerCAmelCase  						=       HfArgumentParser(lowercase )

            lowerCAmelCase  						=       {
                """foo""": 12,
                """bar""": 3.14,
                """baz""": """42""",
                """flag""": True,
            }

            lowerCAmelCase  						=       parser.parse_dict(lowercase )[0]
            lowerCAmelCase  						=       BasicExample(**lowercase )
            self.assertEqual(lowercase      ,						lowercase )





      def     _snake_case			(       self )		->     str:
            lowerCAmelCase  						=       HfArgumentParser(lowercase )

            lowerCAmelCase  						=       {
                """foo""": 12,
                """bar""": 3.14,
                """baz""": """42""",
                """flag""": True,
                """extra""": 42,
            }

            self.assertRaises(lowercase      ,						parser.parse_dict      ,						lowercase      ,						allow_extra_keys=lowercase )





      def     _snake_case			(       self )		->     Dict:
            lowerCAmelCase  						=       HfArgumentParser(lowercase )

            lowerCAmelCase  						=       {
                """foo""": 12,
                """bar""": 3.14,
                """baz""": """42""",
                """flag""": True,
            }
            with tempfile.TemporaryDirectory() as tmp_dir:
                  lowerCAmelCase  						=       os.path.join(lowercase      ,						"""temp_json""" )
                  os.mkdir(lowercase )
                  with open(temp_local_path + """.json"""      ,						"""w+""" ) as f:
                        json.dump(lowercase      ,						lowercase )
                  lowerCAmelCase  						=       parser.parse_yaml_file(Path(temp_local_path + """.json""" ) )[0]

            lowerCAmelCase  						=       BasicExample(**lowercase )
            self.assertEqual(lowercase      ,						lowercase )





      def     _snake_case			(       self )		->     List[str]:
            lowerCAmelCase  						=       HfArgumentParser(lowercase )

            lowerCAmelCase  						=       {
                """foo""": 12,
                """bar""": 3.14,
                """baz""": """42""",
                """flag""": True,
            }
            with tempfile.TemporaryDirectory() as tmp_dir:
                  lowerCAmelCase  						=       os.path.join(lowercase      ,						"""temp_yaml""" )
                  os.mkdir(lowercase )
                  with open(temp_local_path + """.yaml"""      ,						"""w+""" ) as f:
                        yaml.dump(lowercase      ,						lowercase )
                  lowerCAmelCase  						=       parser.parse_yaml_file(Path(temp_local_path + """.yaml""" ) )[0]
            lowerCAmelCase  						=       BasicExample(**lowercase )
            self.assertEqual(lowercase      ,						lowercase )





      def     _snake_case			(       self )		->     Any:
            lowerCAmelCase  						=       HfArgumentParser(lowercase )
            self.assertIsNotNone(lowercase )













"""simple docstring"""





import re
import string

import numpy as np

import datasets


SCREAMING_SNAKE_CASE__					=   "\nReturns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.\n"

SCREAMING_SNAKE_CASE__					=   "\nArgs:\n    predictions: List of predicted texts.\n    references: List of reference texts.\n    regexes_to_ignore: List, defaults to None. Regex expressions of characters to\n        ignore when calculating the exact matches. Note: these regexes are removed\n        from the input data before the changes based on the options below (e.g. ignore_case,\n        ignore_punctuation, ignore_numbers) are applied.\n    ignore_case: Boolean, defaults to False. If true, turns everything\n        to lowercase so that capitalization differences are ignored.\n    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\n    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\nReturns:\n    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.\nExamples:\n    >>> exact_match = datasets.load_metric(\"exact_match\")\n    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]\n    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results[\"exact_match\"], 1))\n    25.0\n\n    >>> exact_match = datasets.load_metric(\"exact_match\")\n    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]\n    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=[\"the \", \"yell\"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results[\"exact_match\"], 1))\n    50.0\n\n\n    >>> exact_match = datasets.load_metric(\"exact_match\")\n    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]\n    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=[\"the \", \"yell\", \"YELL\"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results[\"exact_match\"], 1))\n    75.0\n\n    >>> exact_match = datasets.load_metric(\"exact_match\")\n    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]\n    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=[\"the \", \"yell\", \"YELL\"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)\n    >>> print(round(results[\"exact_match\"], 1))\n    100.0\n\n    >>> exact_match = datasets.load_metric(\"exact_match\")\n    >>> refs = [\"The cat sat on the mat.\", \"Theaters are great.\", \"It's like comparing oranges and apples.\"]\n    >>> preds = [\"The cat sat on the mat?\", \"Theaters are great.\", \"It's like comparing apples and oranges.\"]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results[\"exact_match\"], 1))\n    33.3\n\n"

SCREAMING_SNAKE_CASE__					=   "\n"

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





      def     _snake_case			(       self )		->     Optional[int]:
            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""" ),
                    } )      ,						reference_urls=[]      ,						)





      def     _snake_case			(       self      ,						lowercase      ,						lowercase      ,						lowercase=None      ,						lowercase=False      ,						lowercase=False      ,						lowercase=False      ,						)		->     Optional[Any]:
            if regexes_to_ignore is not None:
                  for s in regexes_to_ignore:
                        lowerCAmelCase  						=       np.array([re.sub(lowercase      ,						""""""      ,						lowercase ) for x in predictions] )
                        lowerCAmelCase  						=       np.array([re.sub(lowercase      ,						""""""      ,						lowercase ) for x in references] )
            else:
                  lowerCAmelCase  						=       np.asarray(lowercase )
                  lowerCAmelCase  						=       np.asarray(lowercase )

            if ignore_case:
                  lowerCAmelCase  						=       np.char.lower(lowercase )
                  lowerCAmelCase  						=       np.char.lower(lowercase )

            if ignore_punctuation:
                  lowerCAmelCase  						=       string.punctuation.maketrans(""""""      ,						""""""      ,						string.punctuation )
                  lowerCAmelCase  						=       np.char.translate(lowercase      ,						table=lowercase )
                  lowerCAmelCase  						=       np.char.translate(lowercase      ,						table=lowercase )

            if ignore_numbers:
                  lowerCAmelCase  						=       string.digits.maketrans(""""""      ,						""""""      ,						string.digits )
                  lowerCAmelCase  						=       np.char.translate(lowercase      ,						table=lowercase )
                  lowerCAmelCase  						=       np.char.translate(lowercase      ,						table=lowercase )

            lowerCAmelCase  						=       predictions == references

            return {"exact_match": np.mean(lowercase ) * 100}






