



'''simple docstring'''




import json
import os
from typing import Optional

import numpy as np

from ...feature_extraction_utils import BatchFeature
from ...processing_utils import ProcessorMixin
from ...utils import logging
from ...utils.hub import get_file_from_repo
from ..auto import AutoTokenizer


a     :    str      						=					logging.get_logger(__name__)

class     UpperCamelCase_				(							__magic_name__    ):
	lowercase    =				'AutoTokenizer'
	lowercase    =				['tokenizer']

	lowercase    =				{
	    'semantic_prompt': 1,
	    'coarse_prompt': 2,
	    'fine_prompt': 2,
	}





	def __init__(						self	,	A	,	A=None					)    ->    Tuple:
								super().__init__(A					)

								UpperCAmelCase  :	int							  =	speaker_embeddings





	@classmethod
	def 				_lowercase(						cls	,	A	,	A="speaker_embeddings_path.json"	,	**A					)    ->    int:

								if speaker_embeddings_dict_path is not None:
															UpperCAmelCase  :	List[str]							  =	get_file_from_repo(
															    A	,	A	,	subfolder=kwargs.pop("""subfolder"""	,	A					)	,	cache_dir=kwargs.pop("""cache_dir"""	,	A					)	,	force_download=kwargs.pop("""force_download"""	,	A					)	,	proxies=kwargs.pop("""proxies"""	,	A					)	,	resume_download=kwargs.pop("""resume_download"""	,	A					)	,	local_files_only=kwargs.pop("""local_files_only"""	,	A					)	,	use_auth_token=kwargs.pop("""use_auth_token"""	,	A					)	,	revision=kwargs.pop("""revision"""	,	A					)	,	)
															if speaker_embeddings_path is None:
																						logger.warning(
																						    f'''`{os.path.join(A	,	A					)}` does not exists
                    , no preloaded speaker embeddings will be used - Make sure to provide a correct path to the json
                    dictionnary if wanted, otherwise set `speaker_embeddings_dict_path=None`.'''					)
																						UpperCAmelCase  :	int							  =	None
															else:
																						with open(A					) as speaker_embeddings_json:
																													UpperCAmelCase  :	Dict							  =	json.load(A					)
								else:
															UpperCAmelCase  :	Optional[Any]							  =	None

								UpperCAmelCase  :	Optional[int]							  =	AutoTokenizer.from_pretrained(A	,	**A					)

								return cls(tokenizer=A	,	speaker_embeddings=A					)





	def 				_lowercase(						self	,	A	,	A="speaker_embeddings_path.json"	,	A="speaker_embeddings"	,	A = False	,	**A	,	)    ->    Union[str, Any]:
								if self.speaker_embeddings is not None:
															os.makedirs(os.path.join(A	,	A	,	"""v2"""					)	,	exist_ok=A					)

															UpperCAmelCase  :	Optional[Any]							  =	{}

															UpperCAmelCase  :	List[str]							  =	save_directory

															for prompt_key in self.speaker_embeddings:
																						if prompt_key != "repo_or_path":
																													UpperCAmelCase  :	Union[str, Any]							  =	self._load_voice_preset(A					)

																													UpperCAmelCase  :	Any							  =	{}
																													for key in self.speaker_embeddings[prompt_key]:
																																				np.save(
																																				    os.path.join(
																																				        embeddings_dict["""repo_or_path"""]	,	A	,	f'''{prompt_key}_{key}'''					)	,	voice_preset[key]	,	allow_pickle=A	,	)
																																				UpperCAmelCase  :	Tuple							  =	os.path.join(A	,	f'''{prompt_key}_{key}.npy'''					)

																													UpperCAmelCase  :	List[str]							  =	tmp_dict

															with open(os.path.join(A	,	A					)	,	"""w"""					) as fp:
																						json.dump(A	,	A					)

								super().save_pretrained(A	,	A	,	**A					)





	def 				_lowercase(						self	,	A = None	,	**A					)    ->    Optional[int]:
								UpperCAmelCase  :	List[str]							  =	self.speaker_embeddings[voice_preset]

								UpperCAmelCase  :	str							  =	{}
								for key in ["semantic_prompt", "coarse_prompt", "fine_prompt"]:
															if key not in voice_preset_paths:
																						raise ValueError(
																						    f'''Voice preset unrecognized, missing {key} as a key in self.speaker_embeddings[{voice_preset}].'''					)

															UpperCAmelCase  :	Optional[Any]							  =	get_file_from_repo(
															    self.speaker_embeddings.get("""repo_or_path"""	,	"""/"""					)	,	voice_preset_paths[key]	,	subfolder=kwargs.pop("""subfolder"""	,	A					)	,	cache_dir=kwargs.pop("""cache_dir"""	,	A					)	,	force_download=kwargs.pop("""force_download"""	,	A					)	,	proxies=kwargs.pop("""proxies"""	,	A					)	,	resume_download=kwargs.pop("""resume_download"""	,	A					)	,	local_files_only=kwargs.pop("""local_files_only"""	,	A					)	,	use_auth_token=kwargs.pop("""use_auth_token"""	,	A					)	,	revision=kwargs.pop("""revision"""	,	A					)	,	)
															if path is None:
																						raise ValueError(
																						    f'''`{os.path.join(self.speaker_embeddings.get('repo_or_path'	,	'/'					)	,	voice_preset_paths[key]					)}` does not exists
                    , no preloaded voice preset will be used - Make sure to provide correct paths to the {voice_preset}
                    embeddings.'''					)

															UpperCAmelCase  :	str							  =	np.load(A					)

								return voice_preset_dict





	def 				_lowercase(						self	,	A = None					)    ->    Optional[Any]:
								for key in ["semantic_prompt", "coarse_prompt", "fine_prompt"]:
															if key not in voice_preset:
																						raise ValueError(f'''Voice preset unrecognized, missing {key} as a key.'''					)

															if not isinstance(voice_preset[key]	,	np.ndarray					):
																						raise ValueError(f'''{key} voice preset must be a {str(self.preset_shape[key]					)}D ndarray.'''					)

															if len(voice_preset[key].shape					) != self.preset_shape[key]:
																						raise ValueError(f'''{key} voice preset must be a {str(self.preset_shape[key]					)}D ndarray.'''					)






	def __call__(						self	,	A=None	,	A=None	,	A="pt"	,	A=256	,	A=False	,	A=True	,	A=False	,	**A	,	)    ->    str:
								if voice_preset is not None and not isinstance(A	,	A					):
															if (
															    isinstance(A	,	A					)
															    and self.speaker_embeddings is not None
															    and voice_preset in self.speaker_embeddings
															):
																						UpperCAmelCase  :	Union[str, Any]							  =	self._load_voice_preset(A					)

															else:
																						if isinstance(A	,	A					) and not voice_preset.endswith(""".npz"""					):
																													UpperCAmelCase  :	Optional[Any]							  =	voice_preset + """.npz"""

																						UpperCAmelCase  :	Union[str, Any]							  =	np.load(A					)

								if voice_preset is not None:
															self._validate_voice_preset_dict(A	,	**A					)
															UpperCAmelCase  :	List[Any]							  =	BatchFeature(data=A	,	tensor_type=A					)

								UpperCAmelCase  :	Any							  =	self.tokenizer(
								    A	,	return_tensors=A	,	padding="""max_length"""	,	max_length=A	,	return_attention_mask=A	,	return_token_type_ids=A	,	add_special_tokens=A	,	**A	,	)

								if voice_preset is not None:
															UpperCAmelCase  :	Optional[Any]							  =	voice_preset

								return encoded_text






'''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	,	A	,	A=13	,	A=32	,	A=3	,	A=4	,	A=[10, 20, 30, 40]	,	A=[2, 2, 3, 2]	,	A=True	,	A=True	,	A=37	,	A="gelu"	,	A=10	,	A=0.0_2	,	A=["stage2", "stage3", "stage4"]	,	A=[2, 3, 4]	,	A=None	,	)    ->    int:
								UpperCAmelCase  :	str							  =	parent
								UpperCAmelCase  :	List[Any]							  =	batch_size
								UpperCAmelCase  :	Dict							  =	image_size
								UpperCAmelCase  :	Tuple							  =	num_channels
								UpperCAmelCase  :	Union[str, Any]							  =	num_stages
								UpperCAmelCase  :	Any							  =	hidden_sizes
								UpperCAmelCase  :	str							  =	depths
								UpperCAmelCase  :	Optional[int]							  =	is_training
								UpperCAmelCase  :	Union[str, Any]							  =	use_labels
								UpperCAmelCase  :	Any							  =	intermediate_size
								UpperCAmelCase  :	str							  =	hidden_act
								UpperCAmelCase  :	List[str]							  =	num_labels
								UpperCAmelCase  :	Tuple							  =	initializer_range
								UpperCAmelCase  :	Optional[Any]							  =	out_features
								UpperCAmelCase  :	List[str]							  =	out_indices
								UpperCAmelCase  :	Any							  =	scope





	def 				_lowercase(						self					)    ->    Union[str, Any]:
								UpperCAmelCase  :	Tuple							  =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

								UpperCAmelCase  :	List[Any]							  =	None
								if self.use_labels:
															UpperCAmelCase  :	Dict							  =	ids_tensor([self.batch_size]	,	self.num_labels					)

								UpperCAmelCase  :	List[str]							  =	self.get_config()

								return config, pixel_values, labels





	def 				_lowercase(						self					)    ->    Optional[Any]:
								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=A	,	initializer_range=self.initializer_range	,	out_features=self.out_features	,	out_indices=self.out_indices	,	num_labels=self.num_labels	,	)





	def 				_lowercase(						self	,	A	,	A	,	A					)    ->    Optional[Any]:
								UpperCAmelCase  :	int							  =	ConvNextVaModel(config=A					)
								model.to(A					)
								model.eval()
								UpperCAmelCase  :	List[Any]							  =	model(A					)
								# 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 				_lowercase(						self	,	A	,	A	,	A					)    ->    Any:
								UpperCAmelCase  :	List[str]							  =	ConvNextVaForImageClassification(A					)
								model.to(A					)
								model.eval()
								UpperCAmelCase  :	int							  =	model(A	,	labels=A					)
								self.parent.assertEqual(result.logits.shape	,	(self.batch_size, self.num_labels)					)





	def 				_lowercase(						self	,	A	,	A	,	A					)    ->    Any:
								UpperCAmelCase  :	Optional[Any]							  =	ConvNextVaBackbone(config=A					)
								model.to(A					)
								model.eval()
								UpperCAmelCase  :	Any							  =	model(A					)

								# 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
								UpperCAmelCase  :	Any							  =	None
								UpperCAmelCase  :	Optional[int]							  =	ConvNextVaBackbone(config=A					)
								model.to(A					)
								model.eval()
								UpperCAmelCase  :	int							  =	model(A					)

								# 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 				_lowercase(						self					)    ->    List[str]:
								UpperCAmelCase  :	Dict							  =	self.prepare_config_and_inputs()
								UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  :	List[Any]							  =	config_and_inputs
								UpperCAmelCase  :	str							  =	{"""pixel_values""": pixel_values}
								return config, inputs_dict






	def 				_lowercase(						self					)    ->    List[Any]:
								UpperCAmelCase  :	List[str]							  =	self.prepare_config_and_inputs()
								UpperCAmelCase  ,  UpperCAmelCase  ,  UpperCAmelCase  :	Optional[Any]							  =	config_and_inputs
								UpperCAmelCase  :	List[str]							  =	{"""pixel_values""": pixel_values, """labels""": labels}
								return config, inputs_dict




@require_torch
class     UpperCamelCase_				(							__magic_name__   ,  __magic_name__   ,  unittest.TestCase    ):
	lowercase    =				(
	    (
	        ConvNextVaModel,
	        ConvNextVaForImageClassification,
	        ConvNextVaBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	lowercase    =				(
	    {'feature-extraction': ConvNextVaModel, 'image-classification': ConvNextVaForImageClassification}
	    if is_torch_available()
	    else {}
	)

	lowercase    =				False
	lowercase    =				False
	lowercase    =				False
	lowercase    =				False
	lowercase    =				False





	def 				_lowercase(						self					)    ->    Optional[int]:
								UpperCAmelCase  :	Dict							  =	ConvNextVaModelTester(self					)
								UpperCAmelCase  :	List[str]							  =	ConfigTester(self	,	config_class=A	,	has_text_modality=A	,	hidden_size=37					)





	def 				_lowercase(						self					)    ->    int:
								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 				_lowercase(						self					)    ->    List[str]:
								return





	@unittest.skip(reason="""ConvNextV2 does not use inputs_embeds"""					)
	def 				_lowercase(						self					)    ->    Dict:
								pass





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





	@unittest.skip(reason="""ConvNextV2 does not use feedforward chunking"""					)
	def 				_lowercase(						self					)    ->    int:
								pass





	def 				_lowercase(						self					)    ->    Dict:
								if not self.model_tester.is_training:
															return

								for model_class in self.all_model_classes:
															UpperCAmelCase  ,  UpperCAmelCase  :	Optional[Any]							  =	self.model_tester.prepare_config_and_inputs_with_labels()
															UpperCAmelCase  :	Optional[int]							  =	True

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

															UpperCAmelCase  :	Any							  =	model_class(A					)
															model.to(A					)
															model.train()
															UpperCAmelCase  :	List[str]							  =	self._prepare_for_class(A	,	A	,	return_labels=A					)
															UpperCAmelCase  :	List[str]							  =	model(**A					).loss
															loss.backward()





	def 				_lowercase(						self					)    ->    Tuple:
								if not self.model_tester.is_training:
															return

								for model_class in self.all_model_classes:
															UpperCAmelCase  ,  UpperCAmelCase  :	Any							  =	self.model_tester.prepare_config_and_inputs_with_labels()
															UpperCAmelCase  :	List[str]							  =	False
															UpperCAmelCase  :	int							  =	True

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

															UpperCAmelCase  :	Dict							  =	model_class(A					)
															model.to(A					)
															model.gradient_checkpointing_enable()
															model.train()
															UpperCAmelCase  :	Any							  =	self._prepare_for_class(A	,	A	,	return_labels=A					)
															UpperCAmelCase  :	Any							  =	model(**A					).loss
															loss.backward()





	def 				_lowercase(						self					)    ->    Tuple:
								UpperCAmelCase  ,  UpperCAmelCase  :	List[Any]							  =	self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
															UpperCAmelCase  :	int							  =	model_class(A					)
															UpperCAmelCase  :	List[str]							  =	inspect.signature(model.forward					)
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															UpperCAmelCase  :	Tuple							  =	[*signature.parameters.keys()]

															UpperCAmelCase  :	Optional[Any]							  =	["""pixel_values"""]
															self.assertListEqual(arg_names[:1]	,	A					)





	def 				_lowercase(						self					)    ->    Optional[Any]:
								UpperCAmelCase  :	Tuple							  =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*A					)





	def 				_lowercase(						self					)    ->    List[str]:
								def check_hidden_states_output(A	,	A	,	A					):
															UpperCAmelCase  :	Optional[Any]							  =	model_class(A					)
															model.to(A					)
															model.eval()

															with torch.no_grad():
																						UpperCAmelCase  :	Dict							  =	model(**self._prepare_for_class(A	,	A					)					)

															UpperCAmelCase  :	Tuple							  =	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

															UpperCAmelCase  :	Optional[Any]							  =	self.model_tester.num_stages
															self.assertEqual(len(A					)	,	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]	,	)

								UpperCAmelCase  ,  UpperCAmelCase  :	str							  =	self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
															UpperCAmelCase  :	str							  =	True
															check_hidden_states_output(A	,	A	,	A					)

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

															check_hidden_states_output(A	,	A	,	A					)





	def 				_lowercase(						self					)    ->    Tuple:
								UpperCAmelCase  :	Dict							  =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*A					)






	@slow
	def 				_lowercase(						self					)    ->    Any:
								for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															UpperCAmelCase  :	Tuple							  =	ConvNextVaModel.from_pretrained(A					)
															self.assertIsNotNone(A					)




def    __lowerCamelCase						(      )   ->    Optional[int]:
							UpperCAmelCase  :	Optional[int]							  =	Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""	)
							return image


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





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






	@slow
	def 				_lowercase(						self					)    ->    List[Any]:
								UpperCAmelCase  :	Any							  =	ConvNextVaForImageClassification.from_pretrained("""facebook/convnextv2-tiny-1k-224"""					).to(A					)

								UpperCAmelCase  :	List[Any]							  =	self.default_image_processor
								UpperCAmelCase  :	Any							  =	prepare_img()
								UpperCAmelCase  :	Tuple							  =	preprocessor(images=A	,	return_tensors="""pt"""					).to(A					)

								# forward pass
								with torch.no_grad():
															UpperCAmelCase  :	Optional[Any]							  =	model(**A					)

								# verify the logits
								UpperCAmelCase  :	Dict							  =	torch.Size((1, 1000)					)
								self.assertEqual(outputs.logits.shape	,	A					)

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

