


# Copyright 2021 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from packaging import version

from .. import __version__
from .constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, IMAGENET_STANDARD_MEAN, IMAGENET_STANDARD_STD
from .doc import (
    add_code_sample_docstrings,
    add_end_docstrings,
    add_start_docstrings,
    add_start_docstrings_to_model_forward,
    copy_func,
    replace_return_docstrings,
)
from .generic import (
    ContextManagers,
    ExplicitEnum,
    ModelOutput,
    PaddingStrategy,
    TensorType,
    add_model_info_to_auto_map,
    cached_property,
    can_return_loss,
    expand_dims,
    find_labels,
    flatten_dict,
    infer_framework,
    is_jax_tensor,
    is_numpy_array,
    is_tensor,
    is_tf_symbolic_tensor,
    is_tf_tensor,
    is_torch_device,
    is_torch_dtype,
    is_torch_tensor,
    reshape,
    squeeze,
    strtobool,
    tensor_size,
    to_numpy,
    to_py_obj,
    transpose,
    working_or_temp_dir,
)
from .hub import (
    CLOUDFRONT_DISTRIB_PREFIX,
    DISABLE_TELEMETRY,
    HF_MODULES_CACHE,
    HUGGINGFACE_CO_PREFIX,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    PYTORCH_PRETRAINED_BERT_CACHE,
    PYTORCH_TRANSFORMERS_CACHE,
    S3_BUCKET_PREFIX,
    TRANSFORMERS_CACHE,
    TRANSFORMERS_DYNAMIC_MODULE_NAME,
    EntryNotFoundError,
    PushToHubMixin,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    cached_file,
    default_cache_path,
    define_sagemaker_information,
    download_url,
    extract_commit_hash,
    get_cached_models,
    get_file_from_repo,
    get_full_repo_name,
    has_file,
    http_user_agent,
    is_offline_mode,
    is_remote_url,
    move_cache,
    send_example_telemetry,
    try_to_load_from_cache,
)
from .import_utils import (
    ENV_VARS_TRUE_AND_AUTO_VALUES,
    ENV_VARS_TRUE_VALUES,
    TORCH_FX_REQUIRED_VERSION,
    USE_JAX,
    USE_TF,
    USE_TORCH,
    DummyObject,
    OptionalDependencyNotAvailable,
    _LazyModule,
    ccl_version,
    direct_transformers_import,
    get_torch_version,
    is_accelerate_available,
    is_apex_available,
    is_bitsandbytes_available,
    is_bsa_available,
    is_coloredlogs_available,
    is_cython_available,
    is_datasets_available,
    is_decord_available,
    is_detectrona_available,
    is_faiss_available,
    is_flax_available,
    is_ftfy_available,
    is_in_notebook,
    is_ipex_available,
    is_jieba_available,
    is_jumanpp_available,
    is_kenlm_available,
    is_keras_nlp_available,
    is_librosa_available,
    is_natten_available,
    is_ninja_available,
    is_onnx_available,
    is_openai_available,
    is_optimum_available,
    is_pandas_available,
    is_peft_available,
    is_phonemizer_available,
    is_protobuf_available,
    is_psutil_available,
    is_pyanvml_available,
    is_pyctcdecode_available,
    is_pytesseract_available,
    is_pytest_available,
    is_pytorch_quantization_available,
    is_rjieba_available,
    is_sacremoses_available,
    is_safetensors_available,
    is_sagemaker_dp_enabled,
    is_sagemaker_mp_enabled,
    is_scipy_available,
    is_sentencepiece_available,
    is_seqio_available,
    is_sklearn_available,
    is_soundfile_availble,
    is_spacy_available,
    is_speech_available,
    is_sudachi_available,
    is_tensorflow_probability_available,
    is_tensorflow_text_available,
    is_tfaonnx_available,
    is_tf_available,
    is_timm_available,
    is_tokenizers_available,
    is_torch_available,
    is_torch_bfaa_available,
    is_torch_bfaa_cpu_available,
    is_torch_bfaa_gpu_available,
    is_torch_compile_available,
    is_torch_cuda_available,
    is_torch_fx_available,
    is_torch_fx_proxy,
    is_torch_mps_available,
    is_torch_neuroncore_available,
    is_torch_tensorrt_fx_available,
    is_torch_tfaa_available,
    is_torch_tpu_available,
    is_torchaudio_available,
    is_torchdistx_available,
    is_torchdynamo_available,
    is_torchvision_available,
    is_training_run_on_sagemaker,
    is_vision_available,
    requires_backends,
    torch_only_method,
)


lowerCAmelCase							=						"""pytorch_model.bin"""
lowerCAmelCase							=						"""pytorch_model.bin.index.json"""
lowerCAmelCase							=						"""adapter_config.json"""
lowerCAmelCase							=						"""adapter_model.bin"""
lowerCAmelCase							=						"""adapter_model.safetensors"""
lowerCAmelCase							=						"""tf_model.h5"""
lowerCAmelCase							=						"""tf_model.h5.index.json"""
lowerCAmelCase							=						"""model.ckpt"""
lowerCAmelCase							=						"""flax_model.msgpack"""
lowerCAmelCase							=						"""flax_model.msgpack.index.json"""
lowerCAmelCase							=						"""model.safetensors"""
lowerCAmelCase							=						"""model.safetensors.index.json"""
lowerCAmelCase							=						"""config.json"""
lowerCAmelCase							=						"""preprocessor_config.json"""
lowerCAmelCase							=						FEATURE_EXTRACTOR_NAME
lowerCAmelCase							=						"""generation_config.json"""
lowerCAmelCase							=						"""modelcard.json"""

lowerCAmelCase							=						"""▁"""
lowerCAmelCase							=						SENTENCEPIECE_UNDERLINE  # Kept for backward compatibility

lowerCAmelCase							=						[
    [[0, 1, 0, 1], [1, 0, 0, 1]]
] * 2  # Needs to have 0s and 1s only since XLM uses it for langs too.
lowerCAmelCase							=						[[7, 6, 0, 0, 1], [1, 2, 3, 0, 0], [0, 0, 0, 4, 5]]
lowerCAmelCase							=						[[1, 1, 1, 1, 1], [1, 1, 1, 0, 0], [0, 0, 0, 1, 1]]




def 						__SCREAMING_SNAKE_CASE       (					lowercase_			)		->    Dict:




						'''simple docstring'''







						if version.parse(lowercase_			) < version.parse(lowercase_			):
												if "dev" in min_version:
																		__UpperCAmelCase :       Union[str, Any]  						=  (
																		    '''This example requires a source install from HuggingFace Transformers (see '''
																		    '''`https://huggingface.co/docs/transformers/installation#install-from-source`),'''
																		)
												else:
																		__UpperCAmelCase :       List[Any]  						=  f"This example requires a minimum version of {min_version},"
												error_message += f" but the version found is {__version__}.\n"
												raise ImportError(
												    error_message
												    + '''Check out https://github.com/huggingface/transformers/tree/main/examples#important-note for the examples corresponding to other '''
												    '''versions of HuggingFace Transformers.'''			)





import json
import os
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

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

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
				import torch

if is_vision_available():
				from PIL import Image

				from transformers import ImageGPTImageProcessor




class        lowerCamelCase      (     unittest.TestCase   ):


	def __init__(						self							,    lowercase__							,    lowercase__=7							,    lowercase__=3							,    lowercase__=1_8							,    lowercase__=3_0							,    lowercase__=4_0_0							,    lowercase__=True							,    lowercase__=None							,    lowercase__=True							,    ):
							__UpperCAmelCase :       Union[str, Any]  						=  size if size is not None else {'''height''': 1_8, '''width''': 1_8}
							__UpperCAmelCase :       Any  						=  parent
							__UpperCAmelCase :       Dict  						=  batch_size
							__UpperCAmelCase :       List[str]  						=  num_channels
							__UpperCAmelCase :       int  						=  image_size
							__UpperCAmelCase :       Tuple  						=  min_resolution
							__UpperCAmelCase :       str  						=  max_resolution
							__UpperCAmelCase :       Optional[int]  						=  do_resize
							__UpperCAmelCase :       Tuple  						=  size
							__UpperCAmelCase :       Union[str, Any]  						=  do_normalize


	def    A(						self):
							return {
							    # here we create 2 clusters for the sake of simplicity
							    "clusters": np.asarray(
							        [
							            [0.8_8_6_6_4_4_3_6_3_4_0_3_3_2_0_3, 0.6_6_1_8_8_2_9_3_6_9_5_4_4_9_8_3, 0.3_8_9_1_7_4_6_4_0_1_7_8_6_8_0_4],
							            [-0.6_0_4_2_5_5_9_1_4_6_8_8_1_1_0_4, -0.0_2_2_9_5_0_0_8_8_6_0_5_2_8_4_6_9, 0.5_4_2_3_7_9_7_3_6_9_0_0_3_2_9_6],
							        ]),
							    "do_resize": self.do_resize,
							    "size": self.size,
							    "do_normalize": self.do_normalize,
							}






@require_torch
@require_vision
class        lowerCamelCase      (     _UpperCamelCase       ,	unittest.TestCase   ):
	_lowerCAmelCase    :		Dict        =	ImageGPTImageProcessor if is_vision_available() else None


	def    A(						self):
							__UpperCAmelCase :       Optional[Any]  						=  ImageGPTImageProcessingTester(self)


	@property
	def    A(						self):
							return self.image_processor_tester.prepare_image_processor_dict()


	def    A(						self):
							__UpperCAmelCase :       Union[str, Any]  						=  self.image_processing_class(**self.image_processor_dict)
							self.assertTrue(hasattr(lowercase__							,    '''clusters'''))
							self.assertTrue(hasattr(lowercase__							,    '''do_resize'''))
							self.assertTrue(hasattr(lowercase__							,    '''size'''))
							self.assertTrue(hasattr(lowercase__							,    '''do_normalize'''))


	def    A(						self):
							__UpperCAmelCase :       List[Any]  						=  self.image_processing_class.from_dict(self.image_processor_dict)
							self.assertEqual(image_processor.size							,    {'''height''': 1_8, '''width''': 1_8})

							__UpperCAmelCase :       Union[str, Any]  						=  self.image_processing_class.from_dict(self.image_processor_dict							,    size=4_2)
							self.assertEqual(image_processor.size							,    {'''height''': 4_2, '''width''': 4_2})


	def    A(						self):
							__UpperCAmelCase :       Any  						=  self.image_processing_class(**self.image_processor_dict)
							__UpperCAmelCase :       Any  						=  json.loads(image_processor.to_json_string())
							for key, value in self.image_processor_dict.items():
													if key == "clusters":
																			self.assertTrue(np.array_equal(lowercase__							,    obj[key]))
													else:
																			self.assertEqual(obj[key]							,    lowercase__)


	def    A(						self):
							__UpperCAmelCase :       List[Any]  						=  self.image_processing_class(**self.image_processor_dict)

							with tempfile.TemporaryDirectory() as tmpdirname:
													__UpperCAmelCase :       Dict  						=  os.path.join(lowercase__							,    '''image_processor.json''')
													image_processor_first.to_json_file(lowercase__)
													__UpperCAmelCase :       Union[str, Any]  						=  self.image_processing_class.from_json_file(lowercase__).to_dict()

							__UpperCAmelCase :       Any  						=  image_processor_first.to_dict()
							for key, value in image_processor_first.items():
													if key == "clusters":
																			self.assertTrue(np.array_equal(lowercase__							,    image_processor_second[key]))
													else:
																			self.assertEqual(image_processor_first[key]							,    lowercase__)


	def    A(						self):
							__UpperCAmelCase :       Union[str, Any]  						=  self.image_processing_class(**self.image_processor_dict)

							with tempfile.TemporaryDirectory() as tmpdirname:
													image_processor_first.save_pretrained(lowercase__)
													__UpperCAmelCase :       Dict  						=  self.image_processing_class.from_pretrained(lowercase__).to_dict()

							__UpperCAmelCase :       Optional[Any]  						=  image_processor_first.to_dict()
							for key, value in image_processor_first.items():
													if key == "clusters":
																			self.assertTrue(np.array_equal(lowercase__							,    image_processor_second[key]))
													else:
																			self.assertEqual(image_processor_first[key]							,    lowercase__)


	@unittest.skip('''ImageGPT requires clusters at initialization''')
	def    A(						self):
							pass






def 						__SCREAMING_SNAKE_CASE       (					)		->    int:




						'''simple docstring'''







						__UpperCAmelCase :       List[str]  						=  load_dataset('''hf-internal-testing/fixtures_image_utils'''			,					split='''test'''			)

						__UpperCAmelCase :       Optional[Any]  						=  Image.open(dataset[4]['''file''']			)
						__UpperCAmelCase :       Optional[int]  						=  Image.open(dataset[5]['''file''']			)

						__UpperCAmelCase :       int  						=  [imagea, imagea]

						return images





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


	@slow
	def    A(						self):
							__UpperCAmelCase :       int  						=  ImageGPTImageProcessor.from_pretrained('''openai/imagegpt-small''')

							__UpperCAmelCase :       Any  						=  prepare_images()

							# test non-batched
							__UpperCAmelCase :       int  						=  image_processing(images[0]							,    return_tensors='''pt''')

							self.assertIsInstance(encoding.input_ids							,    torch.LongTensor)
							self.assertEqual(encoding.input_ids.shape							,    (1, 1_0_2_4))

							__UpperCAmelCase :       int  						=  [3_0_6, 1_9_1, 1_9_1]
							self.assertEqual(encoding.input_ids[0, :3].tolist()							,    lowercase__)

							# test batched
							__UpperCAmelCase :       int  						=  image_processing(lowercase__							,    return_tensors='''pt''')

							self.assertIsInstance(encoding.input_ids							,    torch.LongTensor)
							self.assertEqual(encoding.input_ids.shape							,    (2, 1_0_2_4))

							__UpperCAmelCase :       Any  						=  [3_0_3, 1_3, 1_3]
							self.assertEqual(encoding.input_ids[1, -3:].tolist()							,    lowercase__)

