

"""simple docstring"""




import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
						import tensorflow as tf

						from transformers import (
						    TFEfficientFormerForImageClassification,
						    TFEfficientFormerForImageClassificationWithTeacher,
						    TFEfficientFormerModel,
						)
						from transformers.models.efficientformer.modeling_tf_efficientformer import (
						    TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
						)


if is_vision_available():
						from PIL import Image

						from transformers import EfficientFormerImageProcessor





class    lowerCamelCase						:

			def __init__(					self				:						int    ,				__UpperCAmelCase				:						Optional[Any]    ,				__UpperCAmelCase				:						int = 1_3    ,				__UpperCAmelCase				:						int = 6_4    ,				__UpperCAmelCase				:						int = 2    ,				__UpperCAmelCase				:						int = 3    ,				__UpperCAmelCase				:						int = 3    ,				__UpperCAmelCase				:						bool = True    ,				__UpperCAmelCase				:						bool = True    ,				__UpperCAmelCase				:						int = 1_2_8    ,				__UpperCAmelCase				:						Optional[int]=[1_6, 3_2, 6_4, 1_2_8]    ,				__UpperCAmelCase				:						int = 7    ,				__UpperCAmelCase				:						int = 4    ,				__UpperCAmelCase				:						int = 3_7    ,				__UpperCAmelCase				:						str = "gelu"    ,				__UpperCAmelCase				:						float = 0.1    ,				__UpperCAmelCase				:						float = 0.1    ,				__UpperCAmelCase				:						int = 1_0    ,				__UpperCAmelCase				:						float = 0.02    ,				__UpperCAmelCase				:						int = 2    ,				__UpperCAmelCase				:						int = 1    ,				__UpperCAmelCase				:						int = 1_2_8    ,				__UpperCAmelCase				:						List[int] = [2, 2, 2, 2]    ,				__UpperCAmelCase				:						int = 2    ,				__UpperCAmelCase				:						int = 2    ,				)   ->    Tuple:
						SCREAMING_SNAKE_CASE__								=      parent
						SCREAMING_SNAKE_CASE__								=      batch_size
						SCREAMING_SNAKE_CASE__								=      image_size
						SCREAMING_SNAKE_CASE__								=      patch_size
						SCREAMING_SNAKE_CASE__								=      num_channels
						SCREAMING_SNAKE_CASE__								=      is_training
						SCREAMING_SNAKE_CASE__								=      use_labels
						SCREAMING_SNAKE_CASE__								=      hidden_size
						SCREAMING_SNAKE_CASE__								=      num_hidden_layers
						SCREAMING_SNAKE_CASE__								=      num_attention_heads
						SCREAMING_SNAKE_CASE__								=      intermediate_size
						SCREAMING_SNAKE_CASE__								=      hidden_act
						SCREAMING_SNAKE_CASE__								=      hidden_dropout_prob
						SCREAMING_SNAKE_CASE__								=      attention_probs_dropout_prob
						SCREAMING_SNAKE_CASE__								=      type_sequence_label_size
						SCREAMING_SNAKE_CASE__								=      initializer_range
						SCREAMING_SNAKE_CASE__								=      encoder_stride
						SCREAMING_SNAKE_CASE__								=      num_attention_outputs
						SCREAMING_SNAKE_CASE__								=      embed_dim
						SCREAMING_SNAKE_CASE__								=      embed_dim + 1
						SCREAMING_SNAKE_CASE__								=      resolution
						SCREAMING_SNAKE_CASE__								=      depths
						SCREAMING_SNAKE_CASE__								=      hidden_sizes
						SCREAMING_SNAKE_CASE__								=      dim
						SCREAMING_SNAKE_CASE__								=      mlp_expansion_ratio

			def 					SCREAMING_SNAKE_CASE				(					self				:						Any       )   ->    Optional[int]:
						SCREAMING_SNAKE_CASE__								=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

						SCREAMING_SNAKE_CASE__								=      None
						if self.use_labels:
									SCREAMING_SNAKE_CASE__								=      ids_tensor([self.batch_size]    ,				self.type_sequence_label_size       )

						SCREAMING_SNAKE_CASE__								=      self.get_config()

						return config, pixel_values, labels

			def 					SCREAMING_SNAKE_CASE				(					self				:						Any       )   ->    int:
						return EfficientFormerConfig(
						    image_size=self.image_size    ,				patch_size=self.patch_size    ,				num_channels=self.num_channels    ,				hidden_size=self.hidden_size    ,				num_hidden_layers=self.num_hidden_layers    ,				num_attention_heads=self.num_attention_heads    ,				intermediate_size=self.intermediate_size    ,				hidden_act=self.hidden_act    ,				hidden_dropout_prob=self.hidden_dropout_prob    ,				attention_probs_dropout_prob=self.attention_probs_dropout_prob    ,				is_decoder=__UpperCAmelCase    ,				initializer_range=self.initializer_range    ,				encoder_stride=self.encoder_stride    ,				resolution=self.resolution    ,				depths=self.depths    ,				hidden_sizes=self.hidden_sizes    ,				dim=self.dim    ,				mlp_expansion_ratio=self.mlp_expansion_ratio    ,				)

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]    ,				__UpperCAmelCase				:						Optional[Any]    ,				__UpperCAmelCase				:						Any    ,				__UpperCAmelCase				:						str       )   ->    Tuple:
						SCREAMING_SNAKE_CASE__								=      TFEfficientFormerModel(config=__UpperCAmelCase       )
						SCREAMING_SNAKE_CASE__								=      model(__UpperCAmelCase    ,				training=__UpperCAmelCase       )
						self.parent.assertEqual(result.last_hidden_state.shape    ,				(self.batch_size, self.seq_length, self.hidden_size)       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]    ,				__UpperCAmelCase				:						List[str]    ,				__UpperCAmelCase				:						Tuple    ,				__UpperCAmelCase				:						Any       )   ->    Dict:
						SCREAMING_SNAKE_CASE__								=      self.type_sequence_label_size
						SCREAMING_SNAKE_CASE__								=      TFEfficientFormerForImageClassification(__UpperCAmelCase       )
						SCREAMING_SNAKE_CASE__								=      model(__UpperCAmelCase    ,				labels=__UpperCAmelCase    ,				training=__UpperCAmelCase       )
						self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.type_sequence_label_size)       )

						# test greyscale images
						SCREAMING_SNAKE_CASE__								=      1
						SCREAMING_SNAKE_CASE__								=      TFEfficientFormerForImageClassification(__UpperCAmelCase       )

						SCREAMING_SNAKE_CASE__								=      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
						SCREAMING_SNAKE_CASE__								=      model(__UpperCAmelCase    ,				labels=__UpperCAmelCase       )
						self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.type_sequence_label_size)       )





			def 					SCREAMING_SNAKE_CASE				(					self				:						Dict       )   ->    str:
						SCREAMING_SNAKE_CASE__								=      self.prepare_config_and_inputs()
						SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__								=      config_and_inputs
						SCREAMING_SNAKE_CASE__								=      {"""pixel_values""": pixel_values}
						return config, inputs_dict





@require_tf
class    lowerCamelCase						(A__			,A__			,unittest.TestCase			):
			lowerCamelCase__   :		Any							=							(
			    (
			        TFEfficientFormerModel,
			        TFEfficientFormerForImageClassificationWithTeacher,
			        TFEfficientFormerForImageClassification,
			    )
			    if is_tf_available()
			    else ()
			)
			lowerCamelCase__   :		List[Any]							=							(
			    {
			        'feature-extraction': TFEfficientFormerModel,
			        'image-classification': (
			            TFEfficientFormerForImageClassification,
			            TFEfficientFormerForImageClassificationWithTeacher,
			        ),
			    }
			    if is_tf_available()
			    else {}
			)

			lowerCamelCase__   :		Dict							=							False

			lowerCamelCase__   :		Dict							=							False
			lowerCamelCase__   :		Union[str, Any]							=							False
			lowerCamelCase__   :		Optional[int]							=							False
			lowerCamelCase__   :		List[Any]							=							False

			def 					SCREAMING_SNAKE_CASE				(					self				:						str       )   ->    Optional[int]:
						SCREAMING_SNAKE_CASE__								=      TFEfficientFormerModelTester(self       )
						SCREAMING_SNAKE_CASE__								=      ConfigTester(
						    self    ,				config_class=__UpperCAmelCase    ,				has_text_modality=__UpperCAmelCase    ,				hidden_size=3_7       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[Any]       )   ->    Any:
						self.config_tester.run_common_tests()

			@unittest.skip(reason="""EfficientFormer does not use inputs_embeds"""       )
			def 					SCREAMING_SNAKE_CASE				(					self				:						List[Any]       )   ->    Optional[Any]:
						pass

			@unittest.skip(reason="""EfficientFormer does not support input and output embeddings"""       )
			def 					SCREAMING_SNAKE_CASE				(					self				:						Dict       )   ->    Optional[Any]:
						pass

			def 					SCREAMING_SNAKE_CASE				(					self				:						Tuple       )   ->    Tuple:
						SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE__								=      model_class(__UpperCAmelCase       )
									SCREAMING_SNAKE_CASE__								=      inspect.signature(model.call       )
									# signature.parameters is an OrderedDict => so arg_names order is deterministic
									SCREAMING_SNAKE_CASE__								=      [*signature.parameters.keys()]

									SCREAMING_SNAKE_CASE__								=      ["""pixel_values"""]
									self.assertListEqual(arg_names[:1]    ,				__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						int       )   ->    str:
						def check_hidden_states_output(__UpperCAmelCase				:						Optional[Any]    ,				__UpperCAmelCase				:						str    ,				__UpperCAmelCase				:						int       ):
									SCREAMING_SNAKE_CASE__								=      model_class(__UpperCAmelCase       )

									SCREAMING_SNAKE_CASE__								=      model(**self._prepare_for_class(__UpperCAmelCase    ,				__UpperCAmelCase       )    ,				training=__UpperCAmelCase       )
									SCREAMING_SNAKE_CASE__								=      outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

									SCREAMING_SNAKE_CASE__								=      getattr(
									    self.model_tester    ,				"""expected_num_hidden_layers"""    ,				self.model_tester.num_hidden_layers + 1       )
									self.assertEqual(len(__UpperCAmelCase       )    ,				__UpperCAmelCase       )

									if hasattr(self.model_tester    ,				"""encoder_seq_length"""       ):
												SCREAMING_SNAKE_CASE__								=      self.model_tester.encoder_seq_length
												if hasattr(self.model_tester    ,				"""chunk_length"""       ) and self.model_tester.chunk_length > 1:
															SCREAMING_SNAKE_CASE__								=      seq_length * self.model_tester.chunk_length
									else:
												SCREAMING_SNAKE_CASE__								=      self.model_tester.seq_length

									self.assertListEqual(
									    list(hidden_states[-1].shape[-2:]       )    ,				[seq_length, self.model_tester.hidden_size]    ,				)

									if config.is_encoder_decoder:
												SCREAMING_SNAKE_CASE__								=      outputs.decoder_hidden_states

												self.asseretIsInstance(__UpperCAmelCase    ,				(list, tuple)       )
												self.assertEqual(len(__UpperCAmelCase       )    ,				__UpperCAmelCase       )
												SCREAMING_SNAKE_CASE__								=      getattr(self.model_tester    ,				"""seq_length"""    ,				__UpperCAmelCase       )
												SCREAMING_SNAKE_CASE__								=      getattr(self.model_tester    ,				"""decoder_seq_length"""    ,				__UpperCAmelCase       )

												self.assertListEqual(
												    list(hidden_states[-1].shape[-2:]       )    ,				[decoder_seq_length, self.model_tester.hidden_size]    ,				)

						SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE__								=      True
									check_hidden_states_output(__UpperCAmelCase    ,				__UpperCAmelCase    ,				__UpperCAmelCase       )

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									SCREAMING_SNAKE_CASE__								=      True

									check_hidden_states_output(__UpperCAmelCase    ,				__UpperCAmelCase    ,				__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[Any]    ,				__UpperCAmelCase				:						Any    ,				__UpperCAmelCase				:						Optional[int]    ,				__UpperCAmelCase				:						Any=False       )   ->    List[str]:
						SCREAMING_SNAKE_CASE__								=      super()._prepare_for_class(__UpperCAmelCase    ,				__UpperCAmelCase    ,				return_labels=__UpperCAmelCase       )

						if return_labels:
									if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
												del inputs_dict["labels"]

						return inputs_dict

			def 					SCREAMING_SNAKE_CASE				(					self				:						int       )   ->    List[str]:
						SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__UpperCAmelCase       )

			@unittest.skip(reason="""EfficientFormer does not implement masked image modeling yet"""       )
			def 					SCREAMING_SNAKE_CASE				(					self				:						Any       )   ->    Dict:
						SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_image_modeling(*__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						Union[str, Any]       )   ->    Tuple:
						SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase       )

			@slow
			def 					SCREAMING_SNAKE_CASE				(					self				:						int       )   ->    Optional[int]:
						for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE__								=      TFEfficientFormerModel.from_pretrained(__UpperCAmelCase       )
									self.assertIsNotNone(__UpperCAmelCase       )

			def 					SCREAMING_SNAKE_CASE				(					self				:						List[str]       )   ->    List[str]:
						SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs_for_common()
						SCREAMING_SNAKE_CASE__								=      True

						SCREAMING_SNAKE_CASE__								=      getattr(self.model_tester    ,				"""seq_length"""    ,				__UpperCAmelCase       )
						SCREAMING_SNAKE_CASE__								=      getattr(self.model_tester    ,				"""encoder_seq_length"""    ,				__UpperCAmelCase       )
						SCREAMING_SNAKE_CASE__								=      getattr(self.model_tester    ,				"""key_length"""    ,				__UpperCAmelCase       )
						SCREAMING_SNAKE_CASE__								=      getattr(self.model_tester    ,				"""chunk_length"""    ,				__UpperCAmelCase       )

						if chunk_length is not None and hasattr(self.model_tester    ,				"""num_hashes"""       ):
									SCREAMING_SNAKE_CASE__								=      encoder_seq_length * self.model_tester.num_hashes

						for model_class in self.all_model_classes:
									SCREAMING_SNAKE_CASE__								=      True
									SCREAMING_SNAKE_CASE__								=      False
									SCREAMING_SNAKE_CASE__								=      True
									SCREAMING_SNAKE_CASE__								=      model_class(__UpperCAmelCase       )

									SCREAMING_SNAKE_CASE__								=      model(**self._prepare_for_class(__UpperCAmelCase    ,				__UpperCAmelCase       )    ,				training=__UpperCAmelCase       )
									SCREAMING_SNAKE_CASE__								=      outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
									self.assertEqual(len(__UpperCAmelCase       )    ,				self.model_tester.num_attention_outputs       )

									# check that output_attentions also work using config
									del inputs_dict["output_attentions"]
									SCREAMING_SNAKE_CASE__								=      True
									SCREAMING_SNAKE_CASE__								=      model_class(__UpperCAmelCase       )
									SCREAMING_SNAKE_CASE__								=      model(**self._prepare_for_class(__UpperCAmelCase    ,				__UpperCAmelCase       )    ,				training=__UpperCAmelCase       )

									SCREAMING_SNAKE_CASE__								=      outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
									self.assertEqual(len(__UpperCAmelCase       )    ,				self.model_tester.num_attention_outputs       )

									if chunk_length is not None:
												self.assertListEqual(
												    list(attentions[0].shape[-4:]       )    ,				[self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]    ,				)
									else:
												self.assertListEqual(
												    list(attentions[0].shape[-3:]       )    ,				[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]    ,				)





			def 					SCREAMING_SNAKE_CASE				(					self				:						str       )   ->    Tuple:
						# We use a simplified version of this test for EfficientFormer because it requires training=False
						# and Keras refuses to let us force that during functional construction
						SCREAMING_SNAKE_CASE__							,		SCREAMING_SNAKE_CASE__								=      self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									# Prepare our model
									SCREAMING_SNAKE_CASE__								=      model_class(__UpperCAmelCase       )
									# These are maximally general inputs for the model, with multiple None dimensions
									# Hopefully this will catch any conditionals that fail for flexible shapes
									SCREAMING_SNAKE_CASE__								=      {
									    key: tf.keras.Input(shape=val.shape[1:]    ,				dtype=val.dtype    ,				name=__UpperCAmelCase       )
									    for key, val in model.input_signature.items()
									    if key in model.dummy_inputs
									}
									SCREAMING_SNAKE_CASE__								=      model(__UpperCAmelCase       )
									self.assertTrue(outputs_dict is not None       )



def 	A       (     ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__								=      Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
			return image





@require_tf
@require_vision
class    lowerCamelCase						(unittest.TestCase			):

			@cached_property
			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[Any]       )   ->    Dict:
						return (
						    EfficientFormerImageProcessor.from_pretrained("""snap-research/efficientformer-l1-300"""       )
						    if is_vision_available()
						    else None
						)

			@slow
			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]       )   ->    int:
						SCREAMING_SNAKE_CASE__								=      TFEfficientFormerForImageClassification.from_pretrained("""snap-research/efficientformer-l1-300"""       )
						SCREAMING_SNAKE_CASE__								=      self.default_image_processor
						SCREAMING_SNAKE_CASE__								=      prepare_img()
						SCREAMING_SNAKE_CASE__								=      image_processor(images=__UpperCAmelCase    ,				return_tensors="""tf"""       )
						# forward pass
						SCREAMING_SNAKE_CASE__								=      model(**__UpperCAmelCase    ,				training=__UpperCAmelCase       )
						# verify the logits
						SCREAMING_SNAKE_CASE__								=      tf.TensorShape((1, 1_0_0_0)       )
						self.assertEqual(outputs.logits.shape    ,				__UpperCAmelCase       )
						SCREAMING_SNAKE_CASE__								=      tf.constant([-0.0_555, 0.4_825, -0.0_852]       )
						self.assertTrue(np.allclose(outputs.logits[0, :3]    ,				__UpperCAmelCase    ,				atol=1e-4       )       )





			@slow
			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[Any]       )   ->    int:
						SCREAMING_SNAKE_CASE__								=      TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
						    """snap-research/efficientformer-l1-300"""       )
						SCREAMING_SNAKE_CASE__								=      self.default_image_processor
						SCREAMING_SNAKE_CASE__								=      prepare_img()
						SCREAMING_SNAKE_CASE__								=      image_processor(images=__UpperCAmelCase    ,				return_tensors="""tf"""       )
						# forward pass
						SCREAMING_SNAKE_CASE__								=      model(**__UpperCAmelCase    ,				training=__UpperCAmelCase       )
						# verify the logits
						SCREAMING_SNAKE_CASE__								=      tf.TensorShape((1, 1_0_0_0)       )
						self.assertEqual(outputs.logits.shape    ,				__UpperCAmelCase       )
						SCREAMING_SNAKE_CASE__								=      tf.constant([-0.1_312, 0.4_353, -1.0_499]       )
						self.assertTrue(np.allclose(outputs.logits[0, :3]    ,				__UpperCAmelCase    ,				atol=1e-4       )       )





"""simple docstring"""




import doctest
import glob
import importlib
import inspect
import os
import re
from contextlib import contextmanager
from functools import wraps
from unittest.mock import patch

import numpy as np
import pytest
from absl.testing import parameterized

import datasets
from datasets import load_metric

from .utils import for_all_test_methods, local, slow


# mark all tests as integration
A_							:			Optional[Any]											= pytest.mark.integration


A_							:			Union[str, Any]											= {"comet"}
A_							:			str											= importlib.util.find_spec("fairseq") is not None

A_							:			Any											= {"code_eval"}
A_							:			Tuple											= os.name == "nt"

A_							:			List[Any]											= {"bertscore", "frugalscore", "perplexity"}
A_							:			Any											= importlib.util.find_spec("transformers") is not None

def 	A       (     snake_case__    ):




			'''simple docstring'''


			@wraps(snake_case__    )
			def wrapper(self		,				snake_case__    ):
						if not _has_fairseq and metric_name in REQUIRE_FAIRSEQ:
									self.skipTest("""\"test requires Fairseq\""""    )
						else:
									test_case(self		,				snake_case__    )

			return wrapper

def 	A       (     snake_case__    ):




			'''simple docstring'''


			@wraps(snake_case__    )
			def wrapper(self		,				snake_case__    ):
						if not _has_transformers and metric_name in REQUIRE_TRANSFORMERS:
									self.skipTest("""\"test requires transformers\""""    )
						else:
									test_case(self		,				snake_case__    )

			return wrapper

def 	A       (     snake_case__    ):




			'''simple docstring'''


			@wraps(snake_case__    )
			def wrapper(self		,				snake_case__    ):
						if _on_windows and metric_name in UNSUPPORTED_ON_WINDOWS:
									self.skipTest("""\"test not supported on Windows\""""    )
						else:
									test_case(self		,				snake_case__    )

			return wrapper

def 	A       (     ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__								=      [metric_dir.split(os.sep    )[-2] for metric_dir in glob.glob("""./metrics/*/"""    )]
			return [{"testcase_name": x, "metric_name": x} for x in metrics if x != "gleu"]  # gleu is unfinished





@parameterized.named_parameters(get_local_metric_names()			)
@for_all_test_methods(
    A__			,A__			,A__			)
@local
class    lowerCamelCase						(parameterized.TestCase			):
			lowerCamelCase__   :		int							=							{}
			lowerCamelCase__   :		Dict							=							None

			@pytest.mark.filterwarnings("""ignore:metric_module_factory is deprecated:FutureWarning"""       )
			@pytest.mark.filterwarnings("""ignore:load_metric is deprecated:FutureWarning"""       )
			def 					SCREAMING_SNAKE_CASE				(					self				:						str    ,				__UpperCAmelCase				:						str       )   ->    Union[str, Any]:
						SCREAMING_SNAKE_CASE__								=      """[...]"""
						SCREAMING_SNAKE_CASE__								=      importlib.import_module(
						    datasets.load.metric_module_factory(os.path.join("""metrics"""    ,				__UpperCAmelCase       )       ).module_path       )
						SCREAMING_SNAKE_CASE__								=      datasets.load.import_main_class(metric_module.__name__    ,				dataset=__UpperCAmelCase       )
						# check parameters
						SCREAMING_SNAKE_CASE__								=      inspect.signature(metric._compute       ).parameters
						self.assertTrue(all(p.kind != p.VAR_KEYWORD for p in parameters.values()       )       )  # no **kwargs
						# run doctest
						with self.patch_intensive_calls(__UpperCAmelCase    ,				metric_module.__name__       ):
									with self.use_local_metrics():
												try:
															SCREAMING_SNAKE_CASE__								=      doctest.testmod(__UpperCAmelCase    ,				verbose=__UpperCAmelCase    ,				raise_on_error=__UpperCAmelCase       )
												except doctest.UnexpectedException as e:
															raise e.exc_info[1]  # raise the exception that doctest caught
						self.assertEqual(results.failed    ,				0       )
						self.assertGreater(results.attempted    ,				1       )

			@slow
			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[Any]    ,				__UpperCAmelCase				:						Optional[Any]       )   ->    str:
						SCREAMING_SNAKE_CASE__								=      """[...]"""
						SCREAMING_SNAKE_CASE__								=      importlib.import_module(
						    datasets.load.metric_module_factory(os.path.join("""metrics"""    ,				__UpperCAmelCase       )       ).module_path       )
						# run doctest
						with self.use_local_metrics():
									SCREAMING_SNAKE_CASE__								=      doctest.testmod(__UpperCAmelCase    ,				verbose=__UpperCAmelCase    ,				raise_on_error=__UpperCAmelCase       )
						self.assertEqual(results.failed    ,				0       )
						self.assertGreater(results.attempted    ,				1       )

			@contextmanager
			def 					SCREAMING_SNAKE_CASE				(					self				:						Any    ,				__UpperCAmelCase				:						List[str]    ,				__UpperCAmelCase				:						Optional[Any]       )   ->    str:
						if metric_name in self.INTENSIVE_CALLS_PATCHER:
									with self.INTENSIVE_CALLS_PATCHER[metric_name](__UpperCAmelCase       ):
												yield
						else:
									yield

			@contextmanager
			def 					SCREAMING_SNAKE_CASE				(					self				:						Optional[int]       )   ->    Union[str, Any]:
						def load_local_metric(__UpperCAmelCase				:						int    ,				*__UpperCAmelCase				:						int    ,				**__UpperCAmelCase				:						Optional[int]       ):
									return load_metric(os.path.join("""metrics"""    ,				__UpperCAmelCase       )    ,				*__UpperCAmelCase    ,				**__UpperCAmelCase       )

						with patch("""datasets.load_metric"""       ) as mock_load_metric:
									SCREAMING_SNAKE_CASE__								=      load_local_metric
									yield





			@classmethod
			def 					SCREAMING_SNAKE_CASE				(					cls				:						Dict    ,				__UpperCAmelCase				:						int       )   ->    Optional[Any]:
						def wrapper(__UpperCAmelCase				:						List[str]       ):
									SCREAMING_SNAKE_CASE__								=      contextmanager(__UpperCAmelCase       )
									SCREAMING_SNAKE_CASE__								=      patcher
									return patcher

						return wrapper

@LocalMetricTest.register_intensive_calls_patcher("""bleurt"""    )
def 	A       (     snake_case__    ):




			'''simple docstring'''


			import tensorflow.compat.va as tf
			from bleurt.score import Predictor

			tf.flags.DEFINE_string("""sv"""		,				""""""		,				""""""    )  # handle pytest cli flags





			class    lowerCamelCase						(A__			):

						def 					SCREAMING_SNAKE_CASE				(					self				:						Any    ,				__UpperCAmelCase				:						Union[str, Any]       )   ->    List[str]:
									assert len(input_dict["""input_ids"""]       ) == 2
									return np.array([1.03, 1.04]       )

    # mock predict_fn which is supposed to do a forward pass with a bleurt model
			with patch("""bleurt.score._create_predictor"""    ) as mock_create_predictor:
						SCREAMING_SNAKE_CASE__								=      MockedPredictor()
						yield

@LocalMetricTest.register_intensive_calls_patcher("""bertscore"""    )
def 	A       (     snake_case__    ):




			'''simple docstring'''


			import torch

			def bert_cos_score_idf(snake_case__		,				snake_case__		,				*snake_case__		,				**snake_case__    ):
						return torch.tensor([[1.0, 1.0, 1.0]] * len(snake_case__    )    )

			# mock get_model which is supposed to do download a bert model
			# mock bert_cos_score_idf which is supposed to do a forward pass with a bert model
			with patch("""bert_score.scorer.get_model"""    ), patch(
			    """bert_score.scorer.bert_cos_score_idf"""    ) as mock_bert_cos_score_idf:
						SCREAMING_SNAKE_CASE__								=      bert_cos_score_idf
						yield

@LocalMetricTest.register_intensive_calls_patcher("""comet"""    )
def 	A       (     snake_case__    ):




			'''simple docstring'''


			def load_from_checkpoint(snake_case__    ):





						class    lowerCamelCase						:

									def 					SCREAMING_SNAKE_CASE				(					self				:						List[str]    ,				__UpperCAmelCase				:						Any    ,				*__UpperCAmelCase				:						str    ,				**__UpperCAmelCase				:						List[Any]       )   ->    Optional[int]:
												assert len(__UpperCAmelCase       ) == 2
												SCREAMING_SNAKE_CASE__								=      [0.19, 0.92]
												return scores, sum(__UpperCAmelCase       ) / len(__UpperCAmelCase       )
						return Model()

			# mock load_from_checkpoint which is supposed to do download a bert model
			# mock load_from_checkpoint which is supposed to do download a bert model
			with patch("""comet.download_model"""    ) as mock_download_model:
						SCREAMING_SNAKE_CASE__								=      None
						with patch("""comet.load_from_checkpoint"""    ) as mock_load_from_checkpoint:
									SCREAMING_SNAKE_CASE__								=      load_from_checkpoint
									yield




def 	A       (     ):




			'''simple docstring'''


			SCREAMING_SNAKE_CASE__								=      load_metric(os.path.join("""metrics"""		,				"""seqeval"""    )    )
			SCREAMING_SNAKE_CASE__								=      """ERROR"""
			SCREAMING_SNAKE_CASE__								=      f"""Scheme should be one of [IOB1, IOB2, IOE1, IOE2, IOBES, BILOU], got {wrong_scheme}"""
			with pytest.raises(snake_case__		,				match=re.escape(snake_case__    )    ):
						metric.compute(predictions=[]		,				references=[]		,				scheme=snake_case__    )


