
import inspect
import os
from argparse import ArgumentParser, Namespace
from importlib import import_module

import huggingface_hub
import numpy as np
from packaging import version

from .. import (
    FEATURE_EXTRACTOR_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoImageProcessor,
    AutoProcessor,
    AutoTokenizer,
    is_datasets_available,
    is_tf_available,
    is_torch_available,
)
from ..utils import TF2_WEIGHTS_INDEX_NAME, TF2_WEIGHTS_NAME, logging
from . import BaseTransformersCLICommand


if is_tf_available():
					import tensorflow as tf

					tf.config.experimental.enable_tensor_float_aa_execution(False)

if is_torch_available():
					import torch

if is_datasets_available():
					from datasets import load_dataset


_UpperCAmelCase   :					Dict    =			5e-5  # larger error tolerance than in our internal tests, to avoid flaky user-facing errors


def  A			(   lowercase					)  ->    List[str]:
		'''simple docstring'''

		return PTtoTFCommand(
		    args.model_name       ,			args.local_dir       ,			args.max_error       ,			args.new_weights       ,			args.no_pr       ,			args.push       ,			args.extra_commit_description       ,			args.override_model_class       ,			)


class 							lowercase   (						SCREAMING_SNAKE_CASE_  ):



		@staticmethod
		def __UpperCamelCase					(					A_			)    ->   Optional[int]:
				"""simple docstring"""
				UpperCamelCase            =	parser.add_parser(
				    'pt-to-tf'							, help=(
				        'CLI tool to run convert a transformers model from a PyTorch checkpoint to a TensorFlow checkpoint.'
				        ' Can also be used to validate existing weights without opening PRs, with --no-pr.'
				    )							, )
				train_parser.add_argument(
				    '--model-name'							, type=SCREAMING_SNAKE_CASE_							, required=SCREAMING_SNAKE_CASE_							, help='The model name, including owner/organization, as seen on the hub.'							, )
				train_parser.add_argument(
				    '--local-dir'							, type=SCREAMING_SNAKE_CASE_							, default=''							, help='Optional local directory of the model repository. Defaults to /tmp/{model_name}'							, )
				train_parser.add_argument(
				    '--max-error'							, type=SCREAMING_SNAKE_CASE_							, default=SCREAMING_SNAKE_CASE_							, help=(
				        F'''Maximum error tolerance. Defaults to {MAX_ERROR}. This flag should be avoided, use at your own risk.'''
				    )							, )
				train_parser.add_argument(
				    '--new-weights'							, action='store_true'							, help='Optional flag to create new TensorFlow weights, even if they already exist.'							, )
				train_parser.add_argument(
				    '--no-pr'							, action='store_true'							, help='Optional flag to NOT open a PR with converted weights.'			)
				train_parser.add_argument(
				    '--push'							, action='store_true'							, help='Optional flag to push the weights directly to `main` (requires permissions)'							, )
				train_parser.add_argument(
				    '--extra-commit-description'							, type=SCREAMING_SNAKE_CASE_							, default=''							, help='Optional additional commit description to use when opening a PR (e.g. to tag the owner).'							, )
				train_parser.add_argument(
				    '--override-model-class'							, type=SCREAMING_SNAKE_CASE_							, default=SCREAMING_SNAKE_CASE_							, help='If you think you know better than the auto-detector, you can specify the model class here. '
				    'Can be either an AutoModel class or a specific model class like BertForSequenceClassification.'							, )
				train_parser.set_defaults(func=SCREAMING_SNAKE_CASE_			)



		@staticmethod
		def __UpperCamelCase					(					A_							, A_			)    ->   str:
				"""simple docstring"""
				UpperCamelCase            =	set(pt_outputs.keys()			)
				UpperCamelCase            =	set(tf_outputs.keys()			)
				if pt_out_attrs != tf_out_attrs:
						raise ValueError(
						    F'''The model outputs have different attributes, aborting. (Pytorch: {pt_out_attrs}, TensorFlow:'''
						    F''' {tf_out_attrs})'''			)

				# 2. For each output attribute, computes the difference
				def _find_pt_tf_differences(A_							, A_							, A_							, A_=""			):
						# If the current attribute is a tensor, it is a leaf and we make the comparison. Otherwise, we will dig in
						# recursivelly, keeping the name of the attribute.
						if isinstance(SCREAMING_SNAKE_CASE_							, torch.Tensor			):
								UpperCamelCase            =	np.max(np.abs(pt_out.numpy() - tf_out.numpy()			)			)
								UpperCamelCase            =	tensor_difference
						else:
								UpperCamelCase            =	attr_name
								for i, pt_item in enumerate(SCREAMING_SNAKE_CASE_			):
										# If it is a named attribute, we keep the name. Otherwise, just its index.
										if isinstance(SCREAMING_SNAKE_CASE_							, SCREAMING_SNAKE_CASE_			):
												UpperCamelCase            =	root_name + pt_item
												UpperCamelCase            =	tf_out[pt_item]
												UpperCamelCase            =	pt_out[pt_item]
										else:
												UpperCamelCase            =	root_name + F'''[{i}]'''
												UpperCamelCase            =	tf_out[i]
										UpperCamelCase            =	_find_pt_tf_differences(SCREAMING_SNAKE_CASE_							, SCREAMING_SNAKE_CASE_							, SCREAMING_SNAKE_CASE_							, SCREAMING_SNAKE_CASE_			)

						return differences

				return _find_pt_tf_differences(SCREAMING_SNAKE_CASE_							, SCREAMING_SNAKE_CASE_							, {}			)



		def __init__(					self							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, A_							, *A_							, )    ->   str:
				"""simple docstring"""
				UpperCamelCase            =	logging.get_logger('transformers-cli/pt_to_tf'			)
				UpperCamelCase            =	model_name
				UpperCamelCase            =	local_dir if local_dir else os.path.join('/tmp'							, SCREAMING_SNAKE_CASE_			)
				UpperCamelCase            =	max_error
				UpperCamelCase            =	new_weights
				UpperCamelCase            =	no_pr
				UpperCamelCase            =	push
				UpperCamelCase            =	extra_commit_description
				UpperCamelCase            =	override_model_class



		def __UpperCamelCase					(					self							, A_							, A_							, A_			)    ->   str:
				"""simple docstring"""






				def _get_audio_input():
						UpperCamelCase            =	load_dataset('hf-internal-testing/librispeech_asr_dummy'							, 'clean'							, split='validation'			)
						UpperCamelCase            =	ds.sort('id'			).select(range(2			)			)[:2]['audio']
						UpperCamelCase            =	[x['array'] for x in speech_samples]
						return raw_samples

				UpperCamelCase            =	type(pt_model.config			)
				if model_config_class in PROCESSOR_MAPPING:
						UpperCamelCase            =	AutoProcessor.from_pretrained(self._local_dir			)
						if model_config_class in TOKENIZER_MAPPING and processor.tokenizer.pad_token is None:
								UpperCamelCase            =	processor.tokenizer.eos_token
				elif model_config_class in IMAGE_PROCESSOR_MAPPING:
						UpperCamelCase            =	AutoImageProcessor.from_pretrained(self._local_dir			)
				elif model_config_class in FEATURE_EXTRACTOR_MAPPING:
						UpperCamelCase            =	AutoFeatureExtractor.from_pretrained(self._local_dir			)
				elif model_config_class in TOKENIZER_MAPPING:
						UpperCamelCase            =	AutoTokenizer.from_pretrained(self._local_dir			)
						if processor.pad_token is None:
								UpperCamelCase            =	processor.eos_token
				else:
						raise ValueError(F'''Unknown data processing type (model config type: {model_config_class})'''			)

				UpperCamelCase            =	set(inspect.signature(pt_model.forward			).parameters.keys()			)
				UpperCamelCase            =	{}
				if "input_ids" in model_forward_signature:
						processor_inputs.update(
						    {
						        'text': ['Hi there!', 'I am a batch with more than one row and different input lengths.'],
						        'padding': True,
						        'truncation': True,
						    }			)
				if "pixel_values" in model_forward_signature:
						UpperCamelCase            =	load_dataset('cifar10'							, 'plain_text'							, split='test'			)[:2]['img']
						processor_inputs.update({'images': sample_images}			)
				if "input_features" in model_forward_signature:
						UpperCamelCase            =	inspect.signature(processor.feature_extractor			).parameters
						# Pad to the largest input length by default but take feature extractor default
						# padding value if it exists e.g. "max_length" and is not False or None
						if "padding" in feature_extractor_signature:
								UpperCamelCase            =	feature_extractor_signature['padding'].default
								if default_strategy is not False and default_strategy is not None:
										UpperCamelCase            =	default_strategy
								else:
										UpperCamelCase            =	True
						else:
								UpperCamelCase            =	True
						processor_inputs.update({'audio': _get_audio_input(), 'padding': padding_strategy}			)
				if "input_values" in model_forward_signature:  # Wav2Vec2 audio input
						processor_inputs.update({'audio': _get_audio_input(), 'padding': True}			)
				UpperCamelCase            =	processor(**SCREAMING_SNAKE_CASE_							, return_tensors='pt'			)
				UpperCamelCase            =	processor(**SCREAMING_SNAKE_CASE_							, return_tensors='tf'			)

				# Extra input requirements, in addition to the input modality
				if (
				    config.is_encoder_decoder
				    or (hasattr(SCREAMING_SNAKE_CASE_							, 'encoder'			) and hasattr(SCREAMING_SNAKE_CASE_							, 'decoder'			))
				    or "decoder_input_ids" in tf_dummy_inputs
				):
						UpperCamelCase            =	np.asarray([[1], [1]]							, dtype=SCREAMING_SNAKE_CASE_			) * (pt_model.config.decoder_start_token_id or 0)
						pt_input.update({'decoder_input_ids': torch.tensor(SCREAMING_SNAKE_CASE_			)}			)
						tf_input.update({'decoder_input_ids': tf.convert_to_tensor(SCREAMING_SNAKE_CASE_			)}			)

				return pt_input, tf_input



		def __UpperCamelCase					(					self			)    ->   int:
				"""simple docstring"""






				if version.parse(huggingface_hub.__version__			) < version.parse('0.9.0'			):
						raise ImportError(
						    'The huggingface_hub version must be >= 0.9.0 to use this command. Please update your huggingface_hub'
						    ' installation.'			)
				else:
						from huggingface_hub import Repository, create_commit
						from huggingface_hub._commit_api import CommitOperationAdd

				# Fetch remote data
				UpperCamelCase            =	Repository(local_dir=self._local_dir							, clone_from=self._model_name			)

				# Load config and get the appropriate architecture -- the latter is needed to convert the head's weights
				UpperCamelCase            =	AutoConfig.from_pretrained(self._local_dir			)
				UpperCamelCase            =	config.architectures
				if self._override_model_class is not None:
						if self._override_model_class.startswith('TF'			):
								UpperCamelCase            =	[self._override_model_class[2:]]
						else:
								UpperCamelCase            =	[self._override_model_class]
						try:
								UpperCamelCase            =	getattr(import_module('transformers'			)							, architectures[0]			)
						except AttributeError:
								raise ValueError(F'''Model class {self._override_model_class} not found in transformers.'''			)
						try:
								UpperCamelCase            =	getattr(import_module('transformers'			)							, 'TF' + architectures[0]			)
						except AttributeError:
								raise ValueError(F'''TF model class TF{self._override_model_class} not found in transformers.'''			)
				elif architectures is None:  # No architecture defined -- use auto classes
						UpperCamelCase            =	getattr(import_module('transformers'			)							, 'AutoModel'			)
						UpperCamelCase            =	getattr(import_module('transformers'			)							, 'TFAutoModel'			)
						self._logger.warning('No detected architecture, using AutoModel/TFAutoModel'			)
				else:  # Architecture defined -- use it
						if len(SCREAMING_SNAKE_CASE_			) > 1:
								raise ValueError(F'''More than one architecture was found, aborting. (architectures = {architectures})'''			)
						self._logger.warning(F'''Detected architecture: {architectures[0]}'''			)
						UpperCamelCase            =	getattr(import_module('transformers'			)							, architectures[0]			)
						try:
								UpperCamelCase            =	getattr(import_module('transformers'			)							, 'TF' + architectures[0]			)
						except AttributeError:
								raise AttributeError(F'''The TensorFlow equivalent of {architectures[0]} doesn\'t exist in transformers.'''			)

        # Check the TF dummy inputs to see what keys we need in the forward pass
				UpperCamelCase            =	tf_class.from_config(SCREAMING_SNAKE_CASE_			)
				UpperCamelCase            =	tf_from_pt_model.dummy_inputs

				del tf_from_pt_model  # Try to keep only one model in memory at a time

				# Load the model and get some basic inputs
				UpperCamelCase            =	pt_class.from_pretrained(self._local_dir			)
				pt_model.eval()

				UpperCamelCase      ,    UpperCamelCase            =	self.get_inputs(SCREAMING_SNAKE_CASE_							, SCREAMING_SNAKE_CASE_							, SCREAMING_SNAKE_CASE_			)

				with torch.no_grad():
						UpperCamelCase            =	pt_model(**SCREAMING_SNAKE_CASE_							, output_hidden_states=SCREAMING_SNAKE_CASE_			)
				del pt_model  # will no longer be used, and may have a large memory footprint

				UpperCamelCase            =	tf_class.from_pretrained(self._local_dir							, from_pt=SCREAMING_SNAKE_CASE_			)
				UpperCamelCase            =	tf_from_pt_model(**SCREAMING_SNAKE_CASE_							, output_hidden_states=SCREAMING_SNAKE_CASE_							, training=SCREAMING_SNAKE_CASE_			)

				# Confirms that cross loading PT weights into TF worked.
				UpperCamelCase            =	self.find_pt_tf_differences(SCREAMING_SNAKE_CASE_							, SCREAMING_SNAKE_CASE_			)
				UpperCamelCase            =	{k: v for k, v in crossload_differences.items() if 'hidden' not in k}
				UpperCamelCase            =	{k: v for k, v in crossload_differences.items() if 'hidden' in k}
				if len(SCREAMING_SNAKE_CASE_			) == 0 and architectures is not None:
						raise ValueError(
						    F'''Something went wrong -- the config file has architectures ({architectures}), but no model head'''
						    ' output was found. All outputs start with \'hidden\''			)
				UpperCamelCase            =	max(output_differences.values()			) if output_differences else 0.0
				UpperCamelCase            =	max(hidden_differences.values()			)
				if max_crossload_output_diff > self._max_error or max_crossload_hidden_diff > self._max_error:
						raise ValueError(
						    'The cross-loaded TensorFlow model has different outputs, something went wrong!\n'
						    + F'''\nList of maximum output differences above the threshold ({self._max_error}):\n'''
						    + '\n'.join([F'''{k}: {v:.3e}''' for k, v in output_differences.items() if v > self._max_error]			)
						    + F'''\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n'''
						    + '\n'.join([F'''{k}: {v:.3e}''' for k, v in hidden_differences.items() if v > self._max_error]			)			)

				# Save the weights in a TF format (if needed) and confirms that the results are still good
				UpperCamelCase            =	os.path.join(self._local_dir							, SCREAMING_SNAKE_CASE_			)
				UpperCamelCase            =	os.path.join(self._local_dir							, SCREAMING_SNAKE_CASE_			)
				if (not os.path.exists(SCREAMING_SNAKE_CASE_			) and not os.path.exists(SCREAMING_SNAKE_CASE_			)) or self._new_weights:
						tf_from_pt_model.save_pretrained(self._local_dir			)
				del tf_from_pt_model  # will no longer be used, and may have a large memory footprint

				UpperCamelCase            =	tf_class.from_pretrained(self._local_dir			)
				UpperCamelCase            =	tf_model(**SCREAMING_SNAKE_CASE_							, output_hidden_states=SCREAMING_SNAKE_CASE_			)

				UpperCamelCase            =	self.find_pt_tf_differences(SCREAMING_SNAKE_CASE_							, SCREAMING_SNAKE_CASE_			)
				UpperCamelCase            =	{k: v for k, v in conversion_differences.items() if 'hidden' not in k}
				UpperCamelCase            =	{k: v for k, v in conversion_differences.items() if 'hidden' in k}
				if len(SCREAMING_SNAKE_CASE_			) == 0 and architectures is not None:
						raise ValueError(
						    F'''Something went wrong -- the config file has architectures ({architectures}), but no model head'''
						    ' output was found. All outputs start with \'hidden\''			)
				UpperCamelCase            =	max(output_differences.values()			) if output_differences else 0.0
				UpperCamelCase            =	max(hidden_differences.values()			)
				if max_conversion_output_diff > self._max_error or max_conversion_hidden_diff > self._max_error:
						raise ValueError(
						    'The converted TensorFlow model has different outputs, something went wrong!\n'
						    + F'''\nList of maximum output differences above the threshold ({self._max_error}):\n'''
						    + '\n'.join([F'''{k}: {v:.3e}''' for k, v in output_differences.items() if v > self._max_error]			)
						    + F'''\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n'''
						    + '\n'.join([F'''{k}: {v:.3e}''' for k, v in hidden_differences.items() if v > self._max_error]			)			)

				UpperCamelCase            =	'Update TF weights' if self._new_weights else 'Add TF weights'
				if self._push:
						repo.git_add(auto_lfs_track=SCREAMING_SNAKE_CASE_			)
						repo.git_commit(SCREAMING_SNAKE_CASE_			)
						repo.git_push(blocking=SCREAMING_SNAKE_CASE_			)  # this prints a progress bar with the upload
						self._logger.warning(F'''TF weights pushed into {self._model_name}'''			)
				elif not self._no_pr:
						self._logger.warning('Uploading the weights into a new PR...'			)
						UpperCamelCase            =	(
						    'Model converted by the [`transformers`\' `pt_to_tf`'
						    ' CLI](https://github.com/huggingface/transformers/blob/main/src/transformers/commands/pt_to_tf.py). '
						    'All converted model outputs and hidden layers were validated against its PyTorch counterpart.\n\n'
						    F'''Maximum crossload output difference={max_crossload_output_diff:.3e}; '''
						    F'''Maximum crossload hidden layer difference={max_crossload_hidden_diff:.3e};\n'''
						    F'''Maximum conversion output difference={max_conversion_output_diff:.3e}; '''
						    F'''Maximum conversion hidden layer difference={max_conversion_hidden_diff:.3e};\n'''
						)
						if self._max_error > MAX_ERROR:
								commit_descrition += (
								    F'''\n\nCAUTION: The maximum admissible error was manually increased to {self._max_error}!'''
								)
						if self._extra_commit_description:
								commit_descrition += "\n\n" + self._extra_commit_description

						# sharded model -> adds all related files (index and .h5 shards)
						if os.path.exists(SCREAMING_SNAKE_CASE_			):
								UpperCamelCase            =	[
								    CommitOperationAdd(path_in_repo=SCREAMING_SNAKE_CASE_							, path_or_fileobj=SCREAMING_SNAKE_CASE_			)
								]
								for shard_path in tf.io.gfile.glob(self._local_dir + '/tf_model-*.h5'			):
										operations += [
										    CommitOperationAdd(path_in_repo=os.path.basename(SCREAMING_SNAKE_CASE_			)							, path_or_fileobj=SCREAMING_SNAKE_CASE_			)
										]
						else:
								UpperCamelCase            =	[CommitOperationAdd(path_in_repo=SCREAMING_SNAKE_CASE_							, path_or_fileobj=SCREAMING_SNAKE_CASE_			)]

						UpperCamelCase            =	create_commit(
						    repo_id=self._model_name							, operations=SCREAMING_SNAKE_CASE_							, commit_message=SCREAMING_SNAKE_CASE_							, commit_description=SCREAMING_SNAKE_CASE_							, repo_type='model'							, create_pr=SCREAMING_SNAKE_CASE_							, ).pr_url
						self._logger.warning(F'''PR open in {hub_pr_url}'''			)


import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
				import torch

if is_vision_available():
				from PIL import Image

				from transformers import DeiTImageProcessor






class 							SCREAMING_SNAKE_CASE__     (				unittest.TestCase     ):

							"""simple docstring"""






							def __init__(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_=7  ,						SCREAMING_SNAKE_CASE_=3  ,						SCREAMING_SNAKE_CASE_=18  ,						SCREAMING_SNAKE_CASE_=30  ,						SCREAMING_SNAKE_CASE_=400  ,						SCREAMING_SNAKE_CASE_=True  ,						SCREAMING_SNAKE_CASE_=None  ,						SCREAMING_SNAKE_CASE_=True  ,						SCREAMING_SNAKE_CASE_=None  ,						SCREAMING_SNAKE_CASE_=True  ,						SCREAMING_SNAKE_CASE_=[0.5, 0.5, 0.5]  ,						SCREAMING_SNAKE_CASE_=[0.5, 0.5, 0.5]  ,						)-> List[str]:





													'''simple docstring'''






													__UpperCamelCase  	=      size if size is not None else {'''height''': 20, '''width''': 20}
													__UpperCamelCase  	=      crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}

													__UpperCamelCase  	=      parent
													__UpperCamelCase  	=      batch_size
													__UpperCamelCase  	=      num_channels
													__UpperCamelCase  	=      image_size
													__UpperCamelCase  	=      min_resolution
													__UpperCamelCase  	=      max_resolution
													__UpperCamelCase  	=      do_resize
													__UpperCamelCase  	=      size
													__UpperCamelCase  	=      do_center_crop
													__UpperCamelCase  	=      crop_size
													__UpperCamelCase  	=      do_normalize
													__UpperCamelCase  	=      image_mean
													__UpperCamelCase  	=      image_std



							def      A__		(	self      )-> int:





													'''simple docstring'''






													return {
													    "do_resize": self.do_resize,
													    "size": self.size,
													    "do_center_crop": self.do_center_crop,
													    "crop_size": self.crop_size,
													    "do_normalize": self.do_normalize,
													    "image_mean": self.image_mean,
													    "image_std": self.image_std,
													}






@require_torch
@require_vision
class 							SCREAMING_SNAKE_CASE__     (				SCREAMING_SNAKE_CASE_ ,		unittest.TestCase     ):

							"""simple docstring"""






							_snake_case  		=	DeiTImageProcessor if is_vision_available() else None
							_snake_case  		=	True



							def      A__		(	self      )-> int:





													'''simple docstring'''






													__UpperCamelCase  	=      DeiTImageProcessingTester(self      )



							@property
							def      A__		(	self      )-> Any:





													'''simple docstring'''






													return self.image_processor_tester.prepare_image_processor_dict()



							def      A__		(	self      )-> Optional[Any]:





													'''simple docstring'''






													__UpperCamelCase  	=      self.image_processing_class(**self.image_processor_dict      )
													self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_  ,						'''do_resize'''      )      )
													self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_  ,						'''size'''      )      )
													self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_  ,						'''do_center_crop'''      )      )
													self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_  ,						'''center_crop'''      )      )
													self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_  ,						'''do_normalize'''      )      )
													self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_  ,						'''image_mean'''      )      )
													self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_  ,						'''image_std'''      )      )



							def      A__		(	self      )-> int:





													'''simple docstring'''






													__UpperCamelCase  	=      self.image_processing_class.from_dict(self.image_processor_dict      )
													self.assertEqual(image_processor.size  ,						{'''height''': 20, '''width''': 20}      )
													self.assertEqual(image_processor.crop_size  ,						{'''height''': 18, '''width''': 18}      )

													__UpperCamelCase  	=      self.image_processing_class.from_dict(self.image_processor_dict  ,						size=42  ,						crop_size=84      )
													self.assertEqual(image_processor.size  ,						{'''height''': 42, '''width''': 42}      )
													self.assertEqual(image_processor.crop_size  ,						{'''height''': 84, '''width''': 84}      )



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





													'''simple docstring'''






													pass



							def      A__		(	self      )-> str:





													'''simple docstring'''






													__UpperCamelCase  	=      self.image_processing_class(**self.image_processor_dict      )
													# create random PIL images
													__UpperCamelCase  	=      prepare_image_inputs(self.image_processor_tester  ,						equal_resolution=SCREAMING_SNAKE_CASE_      )
													for image in image_inputs:
																			self.assertIsInstance(SCREAMING_SNAKE_CASE_  ,						Image.Image      )

													# Test not batched input
													__UpperCamelCase  	=      image_processing(image_inputs[0]  ,						return_tensors='''pt'''      ).pixel_values
													self.assertEqual(
													    encoded_images.shape  ,						(
													        1,
													        self.image_processor_tester.num_channels,
													        self.image_processor_tester.crop_size['''height'''],
													        self.image_processor_tester.crop_size['''width'''],
													    )  ,						)

													# Test batched
													__UpperCamelCase  	=      image_processing(SCREAMING_SNAKE_CASE_  ,						return_tensors='''pt'''      ).pixel_values
													self.assertEqual(
													    encoded_images.shape  ,						(
													        self.image_processor_tester.batch_size,
													        self.image_processor_tester.num_channels,
													        self.image_processor_tester.crop_size['''height'''],
													        self.image_processor_tester.crop_size['''width'''],
													    )  ,						)



							def      A__		(	self      )-> List[str]:





													'''simple docstring'''






													__UpperCamelCase  	=      self.image_processing_class(**self.image_processor_dict      )
													# create random numpy tensors
													__UpperCamelCase  	=      prepare_image_inputs(self.image_processor_tester  ,						equal_resolution=SCREAMING_SNAKE_CASE_  ,						numpify=SCREAMING_SNAKE_CASE_      )
													for image in image_inputs:
																			self.assertIsInstance(SCREAMING_SNAKE_CASE_  ,						np.ndarray      )

													# Test not batched input
													__UpperCamelCase  	=      image_processing(image_inputs[0]  ,						return_tensors='''pt'''      ).pixel_values
													self.assertEqual(
													    encoded_images.shape  ,						(
													        1,
													        self.image_processor_tester.num_channels,
													        self.image_processor_tester.crop_size['''height'''],
													        self.image_processor_tester.crop_size['''width'''],
													    )  ,						)

													# Test batched
													__UpperCamelCase  	=      image_processing(SCREAMING_SNAKE_CASE_  ,						return_tensors='''pt'''      ).pixel_values
													self.assertEqual(
													    encoded_images.shape  ,						(
													        self.image_processor_tester.batch_size,
													        self.image_processor_tester.num_channels,
													        self.image_processor_tester.crop_size['''height'''],
													        self.image_processor_tester.crop_size['''width'''],
													    )  ,						)



							def      A__		(	self      )-> str:





													'''simple docstring'''






													__UpperCamelCase  	=      self.image_processing_class(**self.image_processor_dict      )
													# create random PyTorch tensors
													__UpperCamelCase  	=      prepare_image_inputs(self.image_processor_tester  ,						equal_resolution=SCREAMING_SNAKE_CASE_  ,						torchify=SCREAMING_SNAKE_CASE_      )
													for image in image_inputs:
																			self.assertIsInstance(SCREAMING_SNAKE_CASE_  ,						torch.Tensor      )

													# Test not batched input
													__UpperCamelCase  	=      image_processing(image_inputs[0]  ,						return_tensors='''pt'''      ).pixel_values
													self.assertEqual(
													    encoded_images.shape  ,						(
													        1,
													        self.image_processor_tester.num_channels,
													        self.image_processor_tester.crop_size['''height'''],
													        self.image_processor_tester.crop_size['''width'''],
													    )  ,						)

													# Test batched
													__UpperCamelCase  	=      image_processing(SCREAMING_SNAKE_CASE_  ,						return_tensors='''pt'''      ).pixel_values
													self.assertEqual(
													    encoded_images.shape  ,						(
													        self.image_processor_tester.batch_size,
													        self.image_processor_tester.num_channels,
													        self.image_processor_tester.crop_size['''height'''],
													        self.image_processor_tester.crop_size['''width'''],
													    )  ,						)




