





import inspect
import unittest

from transformers import RegNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
						import jax
						import jax.numpy as jnp

						from transformers.models.regnet.modeling_flax_regnet import FlaxRegNetForImageClassification, FlaxRegNetModel

if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor
class SCREAMING_SNAKE_CASE_  (   unittest.TestCase   ):






						def __init__( self : List[str]						,				_A : List[str]						,				_A : Dict=3						,				_A : Dict=32						,				_A : List[Any]=3						,				_A : Union[str, Any]=10						,				_A : int=[10, 20, 30, 40]						,				_A : List[Any]=[1, 1, 2, 1]						,				_A : List[Any]=True						,				_A : Optional[Any]=True						,				_A : Tuple="relu"						,				_A : Optional[int]=3						,				_A : List[Any]=None						,				)							->      List[Any]:







							"""simple docstring"""


							snake_case_						:     int     =		parent
							snake_case_						:     str     =		batch_size
							snake_case_						:     Optional[Any]     =		image_size
							snake_case_						:     Any     =		num_channels
							snake_case_						:     Tuple     =		embeddings_size
							snake_case_						:     Any     =		hidden_sizes
							snake_case_						:     List[Any]     =		depths
							snake_case_						:     Dict     =		is_training
							snake_case_						:     int     =		use_labels
							snake_case_						:     Any     =		hidden_act
							snake_case_						:     str     =		num_labels
							snake_case_						:     int     =		scope
							snake_case_						:     Union[str, Any]     =		len(_A		)






						def UpperCAmelCase_			( self : Dict		)							->      Optional[Any]:







							"""simple docstring"""


							snake_case_						:     str     =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

							snake_case_						:     Tuple     =		self.get_config()

							return config, pixel_values






						def UpperCAmelCase_			( self : Dict		)							->      List[str]:







							"""simple docstring"""


							return RegNetConfig(
							    num_channels=self.num_channels						,				embeddings_size=self.embeddings_size						,				hidden_sizes=self.hidden_sizes						,				depths=self.depths						,				hidden_act=self.hidden_act						,				num_labels=self.num_labels						,				image_size=self.image_size						,				)






						def UpperCAmelCase_			( self : str						,				_A : Optional[int]						,				_A : Tuple		)							->      List[Any]:







							"""simple docstring"""


							snake_case_						:     Optional[int]     =		FlaxRegNetModel(config=_A		)
							snake_case_						:     Any     =		model(_A		)

							# Output shape (b, c, h, w)
							self.parent.assertEqual(
							    result.last_hidden_state.shape						,				(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)						,				)






						def UpperCAmelCase_			( self : int						,				_A : Tuple						,				_A : List[Any]		)							->      str:







							"""simple docstring"""


							snake_case_						:     Union[str, Any]     =		self.num_labels
							snake_case_						:     List[Any]     =		FlaxRegNetForImageClassification(config=_A		)
							snake_case_						:     Optional[int]     =		model(_A		)
							self.parent.assertEqual(result.logits.shape						,				(self.batch_size, self.num_labels)		)






						def UpperCAmelCase_			( self : Any		)							->      Tuple:







							"""simple docstring"""


							snake_case_						:     Optional[int]     =		self.prepare_config_and_inputs()
							snake_case_						:     int     =		config_and_inputs
							snake_case_						:     List[str]     =		{'pixel_values': pixel_values}
							return config, inputs_dict
@require_flax
class SCREAMING_SNAKE_CASE_  (   snake_case_    ,			unittest.TestCase   ):
						__magic_name__:     Tuple	 =    (FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

						__magic_name__:     List[Any]	 =    False
						__magic_name__:     Any	 =    False
						__magic_name__:     Dict	 =    False






						def UpperCAmelCase_			( self : str		)							->      None:







							"""simple docstring"""


							snake_case_						:     int     =		FlaxRegNetModelTester(self		)
							snake_case_						:     Union[str, Any]     =		ConfigTester(self						,				config_class=_A						,				has_text_modality=_A		)






						def UpperCAmelCase_			( self : Optional[int]		)							->      Union[str, Any]:







							"""simple docstring"""


							self.create_and_test_config_common_properties()
							self.config_tester.create_and_test_config_to_json_string()
							self.config_tester.create_and_test_config_to_json_file()
							self.config_tester.create_and_test_config_from_and_save_pretrained()
							self.config_tester.create_and_test_config_with_num_labels()
							self.config_tester.check_config_can_be_init_without_params()
							self.config_tester.check_config_arguments_init()






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







							"""simple docstring"""


							return






						def UpperCAmelCase_			( self : Dict		)							->      Optional[Any]:







							"""simple docstring"""


							snake_case_						:     Tuple     =		self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_A		)






						def UpperCAmelCase_			( self : Any		)							->      List[str]:







							"""simple docstring"""


							snake_case_						:     Optional[int]     =		self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*_A		)






						@unittest.skip(reason='RegNet does not use inputs_embeds'		)
						def UpperCAmelCase_			( self : Optional[Any]		)							->      int:







							"""simple docstring"""


							pass






						@unittest.skip(reason='RegNet does not support input and output embeddings'		)
						def UpperCAmelCase_			( self : Union[str, Any]		)							->      Dict:







							"""simple docstring"""


							pass






						def UpperCAmelCase_			( self : str		)							->      str:







							"""simple docstring"""


							snake_case_						:     Optional[Any]     =		self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								snake_case_						:     Any     =		model_class(_A		)
								snake_case_						:     Optional[Any]     =		inspect.signature(model.__call__		)
								# signature.parameters is an OrderedDict => so arg_names order is deterministic
								snake_case_						:     List[str]     =		[*signature.parameters.keys()]

								snake_case_						:     List[Any]     =		['pixel_values']
								self.assertListEqual(arg_names[:1]						,				_A		)






						def UpperCAmelCase_			( self : str		)							->      List[Any]:







							"""simple docstring"""


							def check_hidden_states_output(_A : List[Any]						,				_A : Any						,				_A : int		):
								snake_case_						:     Optional[int]     =		model_class(_A		)

								snake_case_						:     Dict     =		model(**self._prepare_for_class(_A						,				_A		)		)

								snake_case_						:     Union[str, Any]     =		outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

								snake_case_						:     Optional[Any]     =		self.model_tester.num_stages
								self.assertEqual(len(_A		)						,				expected_num_stages + 1		)

							snake_case_						:     List[str]     =		self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								snake_case_						:     Tuple     =		True
								check_hidden_states_output(_A						,				_A						,				_A		)

								# check that output_hidden_states also work using config
								del inputs_dict["output_hidden_states"]
								snake_case_						:     Tuple     =		True

								check_hidden_states_output(_A						,				_A						,				_A		)






						def UpperCAmelCase_			( self : List[str]		)							->      Tuple:







							"""simple docstring"""


							snake_case_						:     List[str]     =		self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
								with self.subTest(model_class.__name__		):
									snake_case_						:     List[str]     =		self._prepare_for_class(_A						,				_A		)
									snake_case_						:     List[str]     =		model_class(_A		)

									@jax.jit
									def model_jitted(_A : Optional[int]						,				**_A : List[str]		):
										return model(pixel_values=_A						,				**_A		)

									with self.subTest('JIT Enabled'		):
										snake_case_						:     Tuple     =		model_jitted(**_A		).to_tuple()

									with self.subTest('JIT Disabled'		):
										with jax.disable_jit():
											snake_case_						:     Union[str, Any]     =		model_jitted(**_A		).to_tuple()

									self.assertEqual(len(_A		)						,				len(_A		)		)
									for jitted_output, output in zip(_A						,				_A		):
										self.assertEqual(jitted_output.shape						,				output.shape		)


def 							SCREAMING_SNAKE_CASE__  (      ):
	snake_case_						:     Tuple     =		Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
	return image


@require_flax
class SCREAMING_SNAKE_CASE_  (   unittest.TestCase   ):






						@cached_property
						def UpperCAmelCase_			( self : List[str]		)							->      List[str]:







							"""simple docstring"""


							return AutoImageProcessor.from_pretrained('facebook/regnet-y-040'		) if is_vision_available() else None






						@slow
						def UpperCAmelCase_			( self : Tuple		)							->      List[Any]:







							"""simple docstring"""


							snake_case_						:     Tuple     =		FlaxRegNetForImageClassification.from_pretrained('facebook/regnet-y-040'		)

							snake_case_						:     Any     =		self.default_image_processor
							snake_case_						:     List[str]     =		prepare_img()
							snake_case_						:     Any     =		image_processor(images=_A						,				return_tensors='np'		)

							snake_case_						:     Dict     =		model(**_A		)

							# verify the logits
							snake_case_						:     Union[str, Any]     =		(1, 1000)
							self.assertEqual(outputs.logits.shape						,				_A		)

							snake_case_						:     Tuple     =		jnp.array([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]		)

							self.assertTrue(jnp.allclose(outputs.logits[0, :3]						,				_A						,				atol=1E-4		)		)








# this script reports modified .py files under the desired list of top-level sub-dirs passed as a list of arguments, e.g.:
#   python ./utils/get_modified_files.py utils src tests examples
#
# it uses git to find the forking point and which files were modified - i.e. files not under git won't be considered
# since the output of this script is fed into Makefile commands it doesn't print a newline after the results

import re
import subprocess
import sys


_SCREAMING_SNAKE_CASE 		=						subprocess.check_output("""git merge-base main HEAD""".split()).decode("""utf-8""")
_SCREAMING_SNAKE_CASE 		=						(
    subprocess.check_output(F'''git diff --diff-filter=d --name-only {fork_point_sha}'''.split()).decode("""utf-8""").split()
)

_SCREAMING_SNAKE_CASE 		=						"""|""".join(sys.argv[1:])
_SCREAMING_SNAKE_CASE 		=						re.compile(RF'''^({joined_dirs}).*?\.py$''')

_SCREAMING_SNAKE_CASE 		=						[x for x in modified_files if regex.match(x)]
print(""" """.join(relevant_modified_files), end="""""")

