"""simple docstring"""


import inspect
import unittest

from transformers import ConvNextVaConfig
from transformers.models.auto import get_values
from transformers.models.auto.modeling_auto import MODEL_FOR_BACKBONE_MAPPING_NAMES, MODEL_MAPPING_NAMES
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import ConvNextVaBackbone, ConvNextVaForImageClassification, ConvNextVaModel
	from transformers.models.convnextva.modeling_convnextva import CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor






class   __UpperCAmelCase		:

				def __init__( self      ,					_lowerCamelCase      ,					_lowerCamelCase=13      ,					_lowerCamelCase=32      ,					_lowerCamelCase=3      ,					_lowerCamelCase=4      ,					_lowerCamelCase=[10, 20, 30, 40]      ,					_lowerCamelCase=[2, 2, 3, 2]      ,					_lowerCamelCase=True      ,					_lowerCamelCase=True      ,					_lowerCamelCase=37      ,					_lowerCamelCase="gelu"      ,					_lowerCamelCase=10      ,					_lowerCamelCase=0.0_2      ,					_lowerCamelCase=["stage2", "stage3", "stage4"]      ,					_lowerCamelCase=[2, 3, 4]      ,					_lowerCamelCase=None      ,					):
										lowerCamelCase__   =parent
										lowerCamelCase__   =batch_size
										lowerCamelCase__   =image_size
										lowerCamelCase__   =num_channels
										lowerCamelCase__   =num_stages
										lowerCamelCase__   =hidden_sizes
										lowerCamelCase__   =depths
										lowerCamelCase__   =is_training
										lowerCamelCase__   =use_labels
										lowerCamelCase__   =intermediate_size
										lowerCamelCase__   =hidden_act
										lowerCamelCase__   =num_labels
										lowerCamelCase__   =initializer_range
										lowerCamelCase__   =out_features
										lowerCamelCase__   =out_indices
										lowerCamelCase__   =scope

				def 						_a      ( self ):
										lowerCamelCase__   =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

										lowerCamelCase__   =None
										if self.use_labels:
																lowerCamelCase__   =ids_tensor([self.batch_size]      ,					self.num_labels )

										lowerCamelCase__   =self.get_config()

										return config, pixel_values, labels

				def 						_a      ( self ):
										return ConvNextVaConfig(
										    num_channels=self.num_channels      ,					hidden_sizes=self.hidden_sizes      ,					depths=self.depths      ,					num_stages=self.num_stages      ,					hidden_act=self.hidden_act      ,					is_decoder=_lowerCamelCase      ,					initializer_range=self.initializer_range      ,					out_features=self.out_features      ,					out_indices=self.out_indices      ,					num_labels=self.num_labels      ,					)

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase ):
										lowerCamelCase__   =ConvNextVaModel(config=_lowerCamelCase )
										model.to(_lowerCamelCase )
										model.eval()
										lowerCamelCase__   =model(_lowerCamelCase )
										# expected last hidden states: B, C, H // 32, W // 32
										self.parent.assertEqual(
										    result.last_hidden_state.shape      ,					(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)      ,					)

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase ):
										lowerCamelCase__   =ConvNextVaForImageClassification(_lowerCamelCase )
										model.to(_lowerCamelCase )
										model.eval()
										lowerCamelCase__   =model(_lowerCamelCase      ,					labels=_lowerCamelCase )
										self.parent.assertEqual(result.logits.shape      ,					(self.batch_size, self.num_labels) )

				def 						_a      ( self      ,					_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase ):
										lowerCamelCase__   =ConvNextVaBackbone(config=_lowerCamelCase )
										model.to(_lowerCamelCase )
										model.eval()
										lowerCamelCase__   =model(_lowerCamelCase )

										# verify hidden states
										self.parent.assertEqual(len(result.feature_maps )      ,					len(config.out_features ) )
										self.parent.assertListEqual(list(result.feature_maps[0].shape )      ,					[self.batch_size, self.hidden_sizes[1], 4, 4] )

										# verify channels
										self.parent.assertEqual(len(model.channels )      ,					len(config.out_features ) )
										self.parent.assertListEqual(model.channels      ,					config.hidden_sizes[1:] )

										# verify backbone works with out_features=None
										lowerCamelCase__   =None
										lowerCamelCase__   =ConvNextVaBackbone(config=_lowerCamelCase )
										model.to(_lowerCamelCase )
										model.eval()
										lowerCamelCase__   =model(_lowerCamelCase )

										# verify feature maps
										self.parent.assertEqual(len(result.feature_maps )      ,					1 )
										self.parent.assertListEqual(list(result.feature_maps[0].shape )      ,					[self.batch_size, self.hidden_sizes[-1], 1, 1] )

										# verify channels
										self.parent.assertEqual(len(model.channels )      ,					1 )
										self.parent.assertListEqual(model.channels      ,					[config.hidden_sizes[-1]] )

				def 						_a      ( self ):
										lowerCamelCase__   =self.prepare_config_and_inputs()
										lowerCamelCase__   , lowerCamelCase__   , lowerCamelCase__   =config_and_inputs
										lowerCamelCase__   ={"pixel_values": pixel_values}
										return config, inputs_dict






				def 						_a      ( self ):
										lowerCamelCase__   =self.prepare_config_and_inputs()
										lowerCamelCase__   , lowerCamelCase__   , lowerCamelCase__   =config_and_inputs
										lowerCamelCase__   ={"pixel_values": pixel_values, "labels": labels}
										return config, inputs_dict






@require_torch
class   __UpperCAmelCase		(      __lowerCAmelCase , __lowerCAmelCase , unittest.TestCase      ):
				A__ :  Dict    				=			(
				    (
				        ConvNextVaModel,
				        ConvNextVaForImageClassification,
				        ConvNextVaBackbone,
				    )
				    if is_torch_available()
				    else ()
				)
				A__ :  Dict    				=			(
				    {'''feature-extraction''': ConvNextVaModel, '''image-classification''': ConvNextVaForImageClassification}
				    if is_torch_available()
				    else {}
				)

				A__ :  str    				=			False
				A__ :  Dict    				=			False
				A__ :  int    				=			False
				A__ :  str    				=			False
				A__ :  Tuple    				=			False

				def 						_a      ( self ):
										lowerCamelCase__   =ConvNextVaModelTester(self )
										lowerCamelCase__   =ConfigTester(self      ,					config_class=_lowerCamelCase      ,					has_text_modality=_lowerCamelCase      ,					hidden_size=37 )

				def 						_a      ( self ):
										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 						_a      ( self ):
										return

				@unittest.skip(reason="ConvNextV2 does not use inputs_embeds" )
				def 						_a      ( self ):
										pass

				@unittest.skip(reason="ConvNextV2 does not support input and output embeddings" )
				def 						_a      ( self ):
										pass

				@unittest.skip(reason="ConvNextV2 does not use feedforward chunking" )
				def 						_a      ( self ):
										pass

				def 						_a      ( self ):
										if not self.model_tester.is_training:
																return

										for model_class in self.all_model_classes:
																lowerCamelCase__   , lowerCamelCase__   =self.model_tester.prepare_config_and_inputs_with_labels()
																lowerCamelCase__   =True

																if model_class.__name__ in [
																    *get_values(_lowerCamelCase ),
																    *get_values(_lowerCamelCase ),
																]:
																						continue

																lowerCamelCase__   =model_class(_lowerCamelCase )
																model.to(_lowerCamelCase )
																model.train()
																lowerCamelCase__   =self._prepare_for_class(_lowerCamelCase      ,					_lowerCamelCase      ,					return_labels=_lowerCamelCase )
																lowerCamelCase__   =model(**_lowerCamelCase ).loss
																loss.backward()

				def 						_a      ( self ):
										if not self.model_tester.is_training:
																return

										for model_class in self.all_model_classes:
																lowerCamelCase__   , lowerCamelCase__   =self.model_tester.prepare_config_and_inputs_with_labels()
																lowerCamelCase__   =False
																lowerCamelCase__   =True

																if (
																    model_class.__name__
																    in [*get_values(_lowerCamelCase ), *get_values(_lowerCamelCase )]
																    or not model_class.supports_gradient_checkpointing
																):
																						continue

																lowerCamelCase__   =model_class(_lowerCamelCase )
																model.to(_lowerCamelCase )
																model.gradient_checkpointing_enable()
																model.train()
																lowerCamelCase__   =self._prepare_for_class(_lowerCamelCase      ,					_lowerCamelCase      ,					return_labels=_lowerCamelCase )
																lowerCamelCase__   =model(**_lowerCamelCase ).loss
																loss.backward()

				def 						_a      ( self ):
										lowerCamelCase__   , lowerCamelCase__   =self.model_tester.prepare_config_and_inputs_for_common()

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

																lowerCamelCase__   =["pixel_values"]
																self.assertListEqual(arg_names[:1]      ,					_lowerCamelCase )

				def 						_a      ( self ):
										lowerCamelCase__   =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_lowerCamelCase )

				def 						_a      ( self ):
										def check_hidden_states_output(_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase ):
																lowerCamelCase__   =model_class(_lowerCamelCase )
																model.to(_lowerCamelCase )
																model.eval()

																with torch.no_grad():
																						lowerCamelCase__   =model(**self._prepare_for_class(_lowerCamelCase      ,					_lowerCamelCase ) )

																lowerCamelCase__   =outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																lowerCamelCase__   =self.model_tester.num_stages
																self.assertEqual(len(_lowerCamelCase )      ,					expected_num_stages + 1 )

																# ConvNextV2's feature maps are of shape (batch_size, num_channels, height, width)
																self.assertListEqual(
																    list(hidden_states[0].shape[-2:] )      ,					[self.model_tester.image_size // 4, self.model_tester.image_size // 4]      ,					)

										lowerCamelCase__   , lowerCamelCase__   =self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																lowerCamelCase__   =True
																check_hidden_states_output(_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase )

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

																check_hidden_states_output(_lowerCamelCase      ,					_lowerCamelCase      ,					_lowerCamelCase )

				def 						_a      ( self ):
										lowerCamelCase__   =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase )






				@slow
				def 						_a      ( self ):
										for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																lowerCamelCase__   =ConvNextVaModel.from_pretrained(_lowerCamelCase )
																self.assertIsNotNone(_lowerCamelCase )





def      lowerCamelCase_					(   )				->   Tuple:




						'''simple docstring'''



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






@require_torch
@require_vision
class   __UpperCAmelCase		(      unittest.TestCase      ):

				@cached_property
				def 						_a      ( self ):
										return AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224" ) if is_vision_available() else None






				@slow
				def 						_a      ( self ):
										lowerCamelCase__   =ConvNextVaForImageClassification.from_pretrained("facebook/convnextv2-tiny-1k-224" ).to(_lowerCamelCase )

										lowerCamelCase__   =self.default_image_processor
										lowerCamelCase__   =prepare_img()
										lowerCamelCase__   =preprocessor(images=_lowerCamelCase      ,					return_tensors="pt" ).to(_lowerCamelCase )

										# forward pass
										with torch.no_grad():
																lowerCamelCase__   =model(**_lowerCamelCase )

										# verify the logits
										lowerCamelCase__   =torch.Size((1, 1000) )
										self.assertEqual(outputs.logits.shape      ,					_lowerCamelCase )

										lowerCamelCase__   =torch.tensor([0.9_9_9_6, 0.1_9_6_6, -0.4_3_8_6] ).to(_lowerCamelCase )
										self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,					_lowerCamelCase      ,					atol=1E-4 ) )



"""simple docstring"""


def      lowerCamelCase_					(   __lowerCAmelCase							)				->   "list[int]":




						'''simple docstring'''



						if upper_limit < 0:
												raise ValueError("Limit for the Catalan sequence must be ≥ 0"							)

						lowerCamelCase__   =[0] * (upper_limit + 1)

						# Base case: C(0) = C(1) = 1
						lowerCamelCase__   =1
						if upper_limit > 0:
												lowerCamelCase__   =1

						# Recurrence relation: C(i) = sum(C(j).C(i-j-1)), from j = 0 to i
						for i in range(2  ,       upper_limit + 1							):
												for j in range(__lowerCAmelCase							):
																		catalan_list[i] += catalan_list[j] * catalan_list[i - j - 1]

						return catalan_list


if __name__ == "__main__":
	print('\n********* Catalan Numbers Using Dynamic Programming ************\n')
	print('\n*** Enter -1 at any time to quit ***')
	print('\nEnter the upper limit (≥ 0) for the Catalan number sequence: ', end='')
	try:
		while True:
			a				=int(input().strip())
			if N < 0:
				print('\n********* Goodbye!! ************')
				break
			else:
				print(F'''The Catalan numbers from 0 through {N} are:''')
				print(catalan_numbers(N))
				print('Try another upper limit for the sequence: ', end='')
	except (NameError, ValueError):
		print('\n********* Invalid input, goodbye! ************\n')

	import doctest

	doctest.testmod()


