'''simple docstring'''







from typing import List, Optional, Union

import torch
from transformers import (
    XLMRobertaTokenizer,
)

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDIMScheduler, DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)
from .text_encoder import MultilingualCLIP


UpperCamelCase_      	=	logging.get_logger(__name__)  # pylint: disable=invalid-name

UpperCamelCase_      	=	'\n    Examples:\n        ```py\n        >>> from diffusers import KandinskyPipeline, KandinskyPriorPipeline\n        >>> import torch\n\n        >>> pipe_prior = KandinskyPriorPipeline.from_pretrained("kandinsky-community/Kandinsky-2-1-prior")\n        >>> pipe_prior.to("cuda")\n\n        >>> prompt = "red cat, 4k photo"\n        >>> out = pipe_prior(prompt)\n        >>> image_emb = out.image_embeds\n        >>> negative_image_emb = out.negative_image_embeds\n\n        >>> pipe = KandinskyPipeline.from_pretrained("kandinsky-community/kandinsky-2-1")\n        >>> pipe.to("cuda")\n\n        >>> image = pipe(\n        ...     prompt,\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=negative_image_emb,\n        ...     height=768,\n        ...     width=768,\n        ...     num_inference_steps=100,\n        ... ).images\n\n        >>> image[0].save("cat.png")\n        ```\n'


def    lowerCamelCase       (			UpperCAmelCase__				:  Union[str, Any]				,						UpperCAmelCase__				:  Optional[Any]				,						UpperCAmelCase__				:  Optional[int]=8		)			->	int:


							'''simple docstring'''






							SCREAMING_SNAKE_CASE__     :List[str]						    = h // scale_factor**2
							if h % scale_factor**2 != 0:
														new_h += 1
							SCREAMING_SNAKE_CASE__     :Optional[int]						    = w // scale_factor**2
							if w % scale_factor**2 != 0:
														new_w += 1
							return new_h * scale_factor, new_w * scale_factor





class _SCREAMING_SNAKE_CASE(							_lowerCamelCase					):




						def __init__(    self :       Dict							,							UpperCamelCase_ :       MultilingualCLIP							,							UpperCamelCase_ :       XLMRobertaTokenizer							,							UpperCamelCase_ :       UNetaDConditionModel							,							UpperCamelCase_ :       Union[DDIMScheduler, DDPMScheduler]							,							UpperCamelCase_ :       VQModel							,							)     ->				Dict:
													super().__init__()

													self.register_modules(
													    text_encoder=_SCREAMING_SNAKE_CASE							,							tokenizer=_SCREAMING_SNAKE_CASE							,							unet=_SCREAMING_SNAKE_CASE							,							scheduler=_SCREAMING_SNAKE_CASE							,							movq=_SCREAMING_SNAKE_CASE							,							)
													SCREAMING_SNAKE_CASE__     :Optional[int]						    = 2 ** (len(self.movq.config.block_out_channels      ) - 1)




						def      __lowerCamelCase       (    self :       Optional[Any]							,							UpperCamelCase_ :       Dict							,							UpperCamelCase_ :       List[str]							,							UpperCamelCase_ :       Any							,							UpperCamelCase_ :       int							,							UpperCamelCase_ :       List[str]							,							UpperCamelCase_ :       Optional[Any]      )     ->				Optional[Any]:


													if latents is None:
																				SCREAMING_SNAKE_CASE__     :Tuple						    = randn_tensor(_SCREAMING_SNAKE_CASE							,							generator=_SCREAMING_SNAKE_CASE							,							device=_SCREAMING_SNAKE_CASE							,							dtype=_SCREAMING_SNAKE_CASE      )
													else:
																				if latents.shape != shape:
																											raise ValueError(f'''Unexpected latents shape, got {latents.shape}, expected {shape}'''      )
																				SCREAMING_SNAKE_CASE__     :Optional[Any]						    = latents.to(_SCREAMING_SNAKE_CASE      )

													SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = latents * scheduler.init_noise_sigma
													return latents




						def      __lowerCamelCase       (    self :       Optional[int]							,							UpperCamelCase_ :       int							,							UpperCamelCase_ :       Tuple							,							UpperCamelCase_ :       str							,							UpperCamelCase_ :       Union[str, Any]							,							UpperCamelCase_ :       Optional[Any]=None							,							)     ->				Tuple:
													SCREAMING_SNAKE_CASE__     :Optional[int]						    = len(_SCREAMING_SNAKE_CASE      ) if isinstance(_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE      ) else 1
													# get prompt text embeddings
													SCREAMING_SNAKE_CASE__     :List[str]						    = self.tokenizer(
													    _SCREAMING_SNAKE_CASE							,							padding='max_length'							,							truncation=_SCREAMING_SNAKE_CASE							,							max_length=77							,							return_attention_mask=_SCREAMING_SNAKE_CASE							,							add_special_tokens=_SCREAMING_SNAKE_CASE							,							return_tensors='pt'							,							)

													SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = text_inputs.input_ids
													SCREAMING_SNAKE_CASE__     :List[str]						    = self.tokenizer(_SCREAMING_SNAKE_CASE							,							padding='longest'							,							return_tensors='pt'      ).input_ids

													if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE      ):
																				SCREAMING_SNAKE_CASE__     :Tuple						    = self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]      )
																				logger.warning(
																				    'The following part of your input was truncated because CLIP can only handle sequences up to'
																				    f''' {self.tokenizer.model_max_length} tokens: {removed_text}'''      )

													SCREAMING_SNAKE_CASE__     :Optional[Any]						    = text_input_ids.to(_SCREAMING_SNAKE_CASE      )
													SCREAMING_SNAKE_CASE__     :Any						    = text_inputs.attention_mask.to(_SCREAMING_SNAKE_CASE      )

													SCREAMING_SNAKE_CASE__     :Dict						    = self.text_encoder(
													    input_ids=_SCREAMING_SNAKE_CASE							,							attention_mask=_SCREAMING_SNAKE_CASE      )

													SCREAMING_SNAKE_CASE__     :Dict						    = prompt_embeds.repeat_interleave(_SCREAMING_SNAKE_CASE							,							dim=0      )
													SCREAMING_SNAKE_CASE__     :Optional[int]						    = text_encoder_hidden_states.repeat_interleave(_SCREAMING_SNAKE_CASE							,							dim=0      )
													SCREAMING_SNAKE_CASE__     :Tuple						    = text_mask.repeat_interleave(_SCREAMING_SNAKE_CASE							,							dim=0      )

													if do_classifier_free_guidance:
																				SCREAMING_SNAKE_CASE__     :List[str]
																				if negative_prompt is None:
																											SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = [''] * batch_size
																				elif type(_SCREAMING_SNAKE_CASE      ) is not type(_SCREAMING_SNAKE_CASE      ):
																											raise TypeError(
																											    f'''`negative_prompt` should be the same type to `prompt`, but got {type(_SCREAMING_SNAKE_CASE      )} !='''
																											    f''' {type(_SCREAMING_SNAKE_CASE      )}.'''      )
																				elif isinstance(_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE      ):
																											SCREAMING_SNAKE_CASE__     :Any						    = [negative_prompt]
																				elif batch_size != len(_SCREAMING_SNAKE_CASE      ):
																											raise ValueError(
																											    f'''`negative_prompt`: {negative_prompt} has batch size {len(_SCREAMING_SNAKE_CASE      )}, but `prompt`:'''
																											    f''' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'''
																											    ' the batch size of `prompt`.'      )
																				else:
																											SCREAMING_SNAKE_CASE__     :List[Any]						    = negative_prompt

																				SCREAMING_SNAKE_CASE__     :Optional[Any]						    = self.tokenizer(
																				    _SCREAMING_SNAKE_CASE							,							padding='max_length'							,							max_length=77							,							truncation=_SCREAMING_SNAKE_CASE							,							return_attention_mask=_SCREAMING_SNAKE_CASE							,							add_special_tokens=_SCREAMING_SNAKE_CASE							,							return_tensors='pt'							,							)
																				SCREAMING_SNAKE_CASE__     :Dict						    = uncond_input.input_ids.to(_SCREAMING_SNAKE_CASE      )
																				SCREAMING_SNAKE_CASE__     :List[Any]						    = uncond_input.attention_mask.to(_SCREAMING_SNAKE_CASE      )

																				SCREAMING_SNAKE_CASE__     :Any						    = self.text_encoder(
																				    input_ids=_SCREAMING_SNAKE_CASE							,							attention_mask=_SCREAMING_SNAKE_CASE      )

																				# duplicate unconditional embeddings for each generation per prompt, using mps friendly method

																				SCREAMING_SNAKE_CASE__     :List[Any]						    = negative_prompt_embeds.shape[1]
																				SCREAMING_SNAKE_CASE__     :Optional[Any]						    = negative_prompt_embeds.repeat(1							,							_SCREAMING_SNAKE_CASE      )
																				SCREAMING_SNAKE_CASE__     :Tuple						    = negative_prompt_embeds.view(batch_size * num_images_per_prompt							,							_SCREAMING_SNAKE_CASE      )

																				SCREAMING_SNAKE_CASE__     :Optional[Any]						    = uncond_text_encoder_hidden_states.shape[1]
																				SCREAMING_SNAKE_CASE__     :int						    = uncond_text_encoder_hidden_states.repeat(1							,							_SCREAMING_SNAKE_CASE							,							1      )
																				SCREAMING_SNAKE_CASE__     :Tuple						    = uncond_text_encoder_hidden_states.view(
																				    batch_size * num_images_per_prompt							,							_SCREAMING_SNAKE_CASE							,							-1      )
																				SCREAMING_SNAKE_CASE__     :str						    = uncond_text_mask.repeat_interleave(_SCREAMING_SNAKE_CASE							,							dim=0      )

																				# done duplicates

																				# For classifier free guidance, we need to do two forward passes.
																				# Here we concatenate the unconditional and text embeddings into a single batch
																				# to avoid doing two forward passes
																				SCREAMING_SNAKE_CASE__     :List[str]						    = torch.cat([negative_prompt_embeds, prompt_embeds]      )
																				SCREAMING_SNAKE_CASE__     :Tuple						    = torch.cat([uncond_text_encoder_hidden_states, text_encoder_hidden_states]      )

																				SCREAMING_SNAKE_CASE__     :Dict						    = torch.cat([uncond_text_mask, text_mask]      )

													return prompt_embeds, text_encoder_hidden_states, text_mask




						def      __lowerCamelCase       (    self :       List[Any]							,							UpperCamelCase_ :       Any=0      )     ->				Any:


													if is_accelerate_available():
																				from accelerate import cpu_offload
													else:
																				raise ImportError('Please install accelerate via `pip install accelerate`'      )

													SCREAMING_SNAKE_CASE__     :Dict						    = torch.device(f'''cuda:{gpu_id}'''      )

													SCREAMING_SNAKE_CASE__     :Dict						    = [
													    self.unet,
													    self.text_encoder,
													    self.movq,
													]
													for cpu_offloaded_model in models:
																				if cpu_offloaded_model is not None:
																											cpu_offload(_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE      )




						def      __lowerCamelCase       (    self :       Optional[int]							,							UpperCamelCase_ :       Optional[int]=0      )     ->				Optional[Any]:


													if is_accelerate_available() and is_accelerate_version('>='							,							'0.17.0.dev0'      ):
																				from accelerate import cpu_offload_with_hook
													else:
																				raise ImportError('`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.'      )

													SCREAMING_SNAKE_CASE__     :List[Any]						    = torch.device(f'''cuda:{gpu_id}'''      )

													if self.device.type != "cpu":
																				self.to('cpu'							,							silence_dtype_warnings=_SCREAMING_SNAKE_CASE      )
																				torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

													SCREAMING_SNAKE_CASE__     :List[str]						    = None
													for cpu_offloaded_model in [self.text_encoder, self.unet, self.movq]:
																				SCREAMING_SNAKE_CASE__     :Dict						    = cpu_offload_with_hook(_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE							,							prev_module_hook=_SCREAMING_SNAKE_CASE      )

													if self.safety_checker is not None:
																				SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = cpu_offload_with_hook(self.safety_checker							,							_SCREAMING_SNAKE_CASE							,							prev_module_hook=_SCREAMING_SNAKE_CASE      )

													# We'll offload the last model manually.
													SCREAMING_SNAKE_CASE__     :List[Any]						    = hook




						@property
						# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
						def      __lowerCamelCase       (    self :       str      )     ->				Any:


													if not hasattr(self.unet							,							'_hf_hook'      ):
																				return self.device
													for module in self.unet.modules():
																				if (
																				    hasattr(_SCREAMING_SNAKE_CASE							,							'_hf_hook'      )
																				    and hasattr(module._hf_hook							,							'execution_device'      )
																				    and module._hf_hook.execution_device is not None
																				):
																											return torch.device(module._hf_hook.execution_device      )
													return self.device




						@torch.no_grad()
						@replace_example_docstring(_SCREAMING_SNAKE_CASE      )
						def __call__(    self :       Dict							,							UpperCamelCase_ :       Union[str, List[str]]							,							UpperCamelCase_ :       Union[torch.FloatTensor, List[torch.FloatTensor]]							,							UpperCamelCase_ :       Union[torch.FloatTensor, List[torch.FloatTensor]]							,							UpperCamelCase_ :       Optional[Union[str, List[str]]] = None							,							UpperCamelCase_ :       int = 5_12							,							UpperCamelCase_ :       int = 5_12							,							UpperCamelCase_ :       int = 1_00							,							UpperCamelCase_ :       float = 4.0							,							UpperCamelCase_ :       int = 1							,							UpperCamelCase_ :       Optional[Union[torch.Generator, List[torch.Generator]]] = None							,							UpperCamelCase_ :       Optional[torch.FloatTensor] = None							,							UpperCamelCase_ :       Optional[str] = "pil"							,							UpperCamelCase_ :       bool = True							,							)     ->				Any:


													if isinstance(_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE      ):
																				SCREAMING_SNAKE_CASE__     :List[str]						    = 1
													elif isinstance(_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE      ):
																				SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = len(_SCREAMING_SNAKE_CASE      )
													else:
																				raise ValueError(f'''`prompt` has to be of type `str` or `list` but is {type(_SCREAMING_SNAKE_CASE      )}'''      )

													SCREAMING_SNAKE_CASE__     :Optional[int]						    = self._execution_device

													SCREAMING_SNAKE_CASE__     :str						    = batch_size * num_images_per_prompt
													SCREAMING_SNAKE_CASE__     :str						    = guidance_scale > 1.0

													SCREAMING_SNAKE_CASE__     :Optional[int]						    = self._encode_prompt(
													    _SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE      )

													if isinstance(_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE      ):
																				SCREAMING_SNAKE_CASE__     :str						    = torch.cat(_SCREAMING_SNAKE_CASE							,							dim=0      )
													if isinstance(_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE      ):
																				SCREAMING_SNAKE_CASE__     :Tuple						    = torch.cat(_SCREAMING_SNAKE_CASE							,							dim=0      )

													if do_classifier_free_guidance:
																				SCREAMING_SNAKE_CASE__     :int						    = image_embeds.repeat_interleave(_SCREAMING_SNAKE_CASE							,							dim=0      )
																				SCREAMING_SNAKE_CASE__     :str						    = negative_image_embeds.repeat_interleave(_SCREAMING_SNAKE_CASE							,							dim=0      )

													SCREAMING_SNAKE_CASE__     :Tuple						    = torch.cat([negative_image_embeds, image_embeds]							,							dim=0      ).to(
													    dtype=prompt_embeds.dtype							,							device=_SCREAMING_SNAKE_CASE      )

													self.scheduler.set_timesteps(_SCREAMING_SNAKE_CASE							,							device=_SCREAMING_SNAKE_CASE      )
													SCREAMING_SNAKE_CASE__     :List[Any]						    = self.scheduler.timesteps

													SCREAMING_SNAKE_CASE__     :str						    = self.unet.config.in_channels

													SCREAMING_SNAKE_CASE__     :int						    = get_new_h_w(_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE							,							self.movq_scale_factor      )

													# create initial latent
													SCREAMING_SNAKE_CASE__     :List[Any]						    = self.prepare_latents(
													    (batch_size, num_channels_latents, height, width)							,							text_encoder_hidden_states.dtype							,							_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE							,							self.scheduler							,							)

													for i, t in enumerate(self.progress_bar(_SCREAMING_SNAKE_CASE      )      ):
																				# expand the latents if we are doing classifier free guidance
																				SCREAMING_SNAKE_CASE__     :str						    = torch.cat([latents] * 2      ) if do_classifier_free_guidance else latents

																				SCREAMING_SNAKE_CASE__     :str						    = {'text_embeds': prompt_embeds, 'image_embeds': image_embeds}
																				SCREAMING_SNAKE_CASE__     :Optional[int]						    = self.unet(
																				    sample=_SCREAMING_SNAKE_CASE							,							timestep=_SCREAMING_SNAKE_CASE							,							encoder_hidden_states=_SCREAMING_SNAKE_CASE							,							added_cond_kwargs=_SCREAMING_SNAKE_CASE							,							return_dict=_SCREAMING_SNAKE_CASE							,							)[0]

																				if do_classifier_free_guidance:
																											SCREAMING_SNAKE_CASE__     :Optional[int]						    = noise_pred.split(latents.shape[1]							,							dim=1      )
																											SCREAMING_SNAKE_CASE__     :int						    = noise_pred.chunk(2      )
																											SCREAMING_SNAKE_CASE__     :Optional[Any]						    = variance_pred.chunk(2      )
																											SCREAMING_SNAKE_CASE__     :Union[str, Any]						    = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
																											SCREAMING_SNAKE_CASE__     :List[Any]						    = torch.cat([noise_pred, variance_pred_text]							,							dim=1      )

																				if not (
																				    hasattr(self.scheduler.config							,							'variance_type'      )
																				    and self.scheduler.config.variance_type in ["learned", "learned_range"]
																				):
																											SCREAMING_SNAKE_CASE__     :Optional[int]						    = noise_pred.split(latents.shape[1]							,							dim=1      )

																				# compute the previous noisy sample x_t -> x_t-1
																				SCREAMING_SNAKE_CASE__     :int						    = self.scheduler.step(
																				    _SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE							,							generator=_SCREAMING_SNAKE_CASE							,							).prev_sample
													# post-processing
													SCREAMING_SNAKE_CASE__     :List[Any]						    = self.movq.decode(_SCREAMING_SNAKE_CASE							,							force_not_quantize=_SCREAMING_SNAKE_CASE      )['sample']

													if output_type not in ["pt", "np", "pil"]:
																				raise ValueError(f'''Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}'''      )

													if output_type in ["np", "pil"]:
																				SCREAMING_SNAKE_CASE__     :List[str]						    = image * 0.5 + 0.5
																				SCREAMING_SNAKE_CASE__     :List[str]						    = image.clamp(0							,							1      )
																				SCREAMING_SNAKE_CASE__     :Optional[Any]						    = image.cpu().permute(0							,							2							,							3							,							1      ).float().numpy()

													if output_type == "pil":
																				SCREAMING_SNAKE_CASE__     :Dict						    = self.numpy_to_pil(_SCREAMING_SNAKE_CASE      )

													if not return_dict:
																				return (image,)

													return ImagePipelineOutput(images=_SCREAMING_SNAKE_CASE      )











"""simple docstring"""

import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir


sys.path.append(str(Path(__file__).parent.parent.parent.parent / 'utils'))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


A_						:    int				=      get_tests_dir('fixtures')
A_						:    int				=      get_tests_dir('fixtures/dummy_feature_extractor_config.json')
A_						:    Dict				=      get_tests_dir('fixtures/dummy-config.json')
class     lowerCAmelCase__						(	unittest.TestCase ):


	'''simple docstring'''







	def 			_lowerCAmelCase     (      self				:       int    )						->	Tuple:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							Tuple							=     0





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





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							Any							=     AutoFeatureExtractor.from_pretrained('facebook/wav2vec2-base-960h'    )
					self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )





	def 			_lowerCAmelCase     (      self				:       Dict    )						->	Dict:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							str							=     AutoFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE    )
					self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )





	def 			_lowerCAmelCase     (      self				:       Optional[Any]    )						->	Optional[int]:





					"""simple docstring"""


					with tempfile.TemporaryDirectory() as tmpdirname:
									SCREAMING_SNAKE_CASE						:							List[Any]							=     WavaVecaConfig()

									# remove feature_extractor_type to make sure config.json alone is enough to load feature processor locally
									SCREAMING_SNAKE_CASE						:							Optional[Any]							=     AutoFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE    ).to_dict()

									config_dict.pop('feature_extractor_type'    )
									SCREAMING_SNAKE_CASE						:							int							=     WavaVecaFeatureExtractor(**_SCREAMING_SNAKE_CASE    )

									# save in new folder
									model_config.save_pretrained(_SCREAMING_SNAKE_CASE    )
									config.save_pretrained(_SCREAMING_SNAKE_CASE    )

									SCREAMING_SNAKE_CASE						:							List[Any]							=     AutoFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE    )

									# make sure private variable is not incorrectly saved
									SCREAMING_SNAKE_CASE						:							Optional[int]							=     json.loads(config.to_json_string()    )
									self.assertTrue('_processor_class' not in dict_as_saved    )

					self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )





	def 			_lowerCAmelCase     (      self				:       List[str]    )						->	int:





					"""simple docstring"""


					SCREAMING_SNAKE_CASE						:							List[Any]							=     AutoFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE    )
					self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )





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





					"""simple docstring"""


					with self.assertRaisesRegex(
					    _SCREAMING_SNAKE_CASE     ,       'bert-base is not a local folder and is not a valid model identifier'    ):
									SCREAMING_SNAKE_CASE						:							str							=     AutoFeatureExtractor.from_pretrained('bert-base'    )





	def 			_lowerCAmelCase     (      self				:       str    )						->	str:





					"""simple docstring"""


					with self.assertRaisesRegex(
					    _SCREAMING_SNAKE_CASE     ,       R'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'    ):
									SCREAMING_SNAKE_CASE						:							List[str]							=     AutoFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE     ,       revision='aaaaaa'    )





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





					"""simple docstring"""


					with self.assertRaisesRegex(
					    _SCREAMING_SNAKE_CASE     ,       'hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json.'     ,       ):
									SCREAMING_SNAKE_CASE						:							int							=     AutoFeatureExtractor.from_pretrained('hf-internal-testing/config-no-model'    )





	def 			_lowerCAmelCase     (      self				:       Optional[Any]    )						->	str:





					"""simple docstring"""


					with self.assertRaises(_SCREAMING_SNAKE_CASE    ):
									SCREAMING_SNAKE_CASE						:							Union[str, Any]							=     AutoFeatureExtractor.from_pretrained(
									    'hf-internal-testing/test_dynamic_feature_extractor'    )
					# If remote code is disabled, we can't load this config.
					with self.assertRaises(_SCREAMING_SNAKE_CASE    ):
									SCREAMING_SNAKE_CASE						:							int							=     AutoFeatureExtractor.from_pretrained(
									    'hf-internal-testing/test_dynamic_feature_extractor'     ,       trust_remote_code=_SCREAMING_SNAKE_CASE    )

					SCREAMING_SNAKE_CASE						:							Optional[int]							=     AutoFeatureExtractor.from_pretrained(
					    'hf-internal-testing/test_dynamic_feature_extractor'     ,       trust_remote_code=_SCREAMING_SNAKE_CASE    )
					self.assertEqual(feature_extractor.__class__.__name__     ,       'NewFeatureExtractor'    )

					# Test feature extractor can be reloaded.
					with tempfile.TemporaryDirectory() as tmp_dir:
									feature_extractor.save_pretrained(_SCREAMING_SNAKE_CASE    )
									SCREAMING_SNAKE_CASE						:							List[str]							=     AutoFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE     ,       trust_remote_code=_SCREAMING_SNAKE_CASE    )
					self.assertEqual(reloaded_feature_extractor.__class__.__name__     ,       'NewFeatureExtractor'    )





	def 			_lowerCAmelCase     (      self				:       Any    )						->	Optional[int]:





					"""simple docstring"""


					try:
									AutoConfig.register('custom'     ,       _SCREAMING_SNAKE_CASE    )
									AutoFeatureExtractor.register(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )
									# Trying to register something existing in the Transformers library will raise an error
									with self.assertRaises(_SCREAMING_SNAKE_CASE    ):
													AutoFeatureExtractor.register(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )

									# Now that the config is registered, it can be used as any other config with the auto-API
									SCREAMING_SNAKE_CASE						:							Union[str, Any]							=     CustomFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE    )
									with tempfile.TemporaryDirectory() as tmp_dir:
													feature_extractor.save_pretrained(_SCREAMING_SNAKE_CASE    )
													SCREAMING_SNAKE_CASE						:							Dict							=     AutoFeatureExtractor.from_pretrained(_SCREAMING_SNAKE_CASE    )
													self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )

					finally:
									if "custom" in CONFIG_MAPPING._extra_content:
													del CONFIG_MAPPING._extra_content["custom"]
									if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
													del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]







	def 			_lowerCAmelCase     (      self				:       Tuple    )						->	str:





					"""simple docstring"""


					class     lowerCAmelCase__						(	_lowerCamelCase ):


						'''simple docstring'''







						_SCREAMING_SNAKE_CASE	:		str  						= True

					try:
									AutoConfig.register('custom'     ,       _SCREAMING_SNAKE_CASE    )
									AutoFeatureExtractor.register(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE    )
									# If remote code is not set, the default is to use local
									SCREAMING_SNAKE_CASE						:							str							=     AutoFeatureExtractor.from_pretrained(
									    'hf-internal-testing/test_dynamic_feature_extractor'    )
									self.assertEqual(feature_extractor.__class__.__name__     ,       'NewFeatureExtractor'    )
									self.assertTrue(feature_extractor.is_local    )

									# If remote code is disabled, we load the local one.
									SCREAMING_SNAKE_CASE						:							List[Any]							=     AutoFeatureExtractor.from_pretrained(
									    'hf-internal-testing/test_dynamic_feature_extractor'     ,       trust_remote_code=_SCREAMING_SNAKE_CASE    )
									self.assertEqual(feature_extractor.__class__.__name__     ,       'NewFeatureExtractor'    )
									self.assertTrue(feature_extractor.is_local    )

									# If remote is enabled, we load from the Hub
									SCREAMING_SNAKE_CASE						:							Optional[int]							=     AutoFeatureExtractor.from_pretrained(
									    'hf-internal-testing/test_dynamic_feature_extractor'     ,       trust_remote_code=_SCREAMING_SNAKE_CASE    )
									self.assertEqual(feature_extractor.__class__.__name__     ,       'NewFeatureExtractor'    )
									self.assertTrue(not hasattr(_SCREAMING_SNAKE_CASE     ,       'is_local'    )    )

					finally:
									if "custom" in CONFIG_MAPPING._extra_content:
													del CONFIG_MAPPING._extra_content["custom"]
									if CustomConfig in FEATURE_EXTRACTOR_MAPPING._extra_content:
													del FEATURE_EXTRACTOR_MAPPING._extra_content[CustomConfig]





