

import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
      from PIL import Image

      from transformers import CLIPImageProcessor, CLIPProcessor

@require_vision
class    _lowercase				(					unittest.TestCase			):

   def     UpperCamelCase					(				self	:    Union[str, Any]       ) ->			str:
         """simple docstring"""





         A_							       =		tempfile.mkdtemp()

         # fmt: off
         A_							       =		['''l''', '''o''', '''w''', '''e''', '''r''', '''s''', '''t''', '''i''', '''d''', '''n''', '''lo''', '''l</w>''', '''w</w>''', '''r</w>''', '''t</w>''', '''low</w>''', '''er</w>''', '''lowest</w>''', '''newer</w>''', '''wider''', '''<unk>''', '''<|startoftext|>''', '''<|endoftext|>''']
         # fmt: on
         A_							       =		dict(zip(_UpperCamelCase			,						range(len(_UpperCamelCase       )       )       )       )
         A_							       =		['''#version: 0.2''', '''l o''', '''lo w</w>''', '''e r</w>''', '''''']
         A_							       =		{'''unk_token''': '''<unk>'''}

         A_							       =		os.path.join(self.tmpdirname			,						VOCAB_FILES_NAMES['''vocab_file''']       )
         A_							       =		os.path.join(self.tmpdirname			,						VOCAB_FILES_NAMES['''merges_file''']       )
         with open(self.vocab_file			,						'''w'''			,						encoding='''utf-8'''       ) as fp:
               fp.write(json.dumps(_UpperCamelCase       ) + '''\n'''       )
         with open(self.merges_file			,						'''w'''			,						encoding='''utf-8'''       ) as fp:
               fp.write('''\n'''.join(_UpperCamelCase       )       )

         A_							       =		{
             '''do_resize''': True,
             '''size''': 2_0,
             '''do_center_crop''': True,
             '''crop_size''': 1_8,
             '''do_normalize''': True,
             '''image_mean''': [0.48145466, 0.4578275, 0.40821073],
             '''image_std''': [0.26862954, 0.26130258, 0.27577711],
         }
         A_							       =		os.path.join(self.tmpdirname			,						_UpperCamelCase       )
         with open(self.image_processor_file			,						'''w'''			,						encoding='''utf-8'''       ) as fp:
               json.dump(_UpperCamelCase			,						_UpperCamelCase       )

   def     UpperCamelCase					(				self	:    Tuple			,						**lowerCamelCase__	:    Any       ) ->			Dict:
         """simple docstring"""





         return CLIPTokenizer.from_pretrained(self.tmpdirname			,						**_UpperCamelCase       )

   def     UpperCamelCase					(				self	:    Dict			,						**lowerCamelCase__	:    Union[str, Any]       ) ->			Tuple:
         """simple docstring"""





         return CLIPTokenizerFast.from_pretrained(self.tmpdirname			,						**_UpperCamelCase       )

   def     UpperCamelCase					(				self	:    Tuple			,						**lowerCamelCase__	:    Any       ) ->			Union[str, Any]:
         """simple docstring"""





         return CLIPImageProcessor.from_pretrained(self.tmpdirname			,						**_UpperCamelCase       )

   def     UpperCamelCase					(				self	:    Optional[Any]       ) ->			List[str]:
         """simple docstring"""





         shutil.rmtree(self.tmpdirname       )

   def     UpperCamelCase					(				self	:    Dict       ) ->			str:
         """simple docstring"""





         A_							       =		[np.random.randint(2_5_5			,						size=(3, 3_0, 4_0_0)			,						dtype=np.uinta       )]

         A_							       =		[Image.fromarray(np.moveaxis(_UpperCamelCase			,						0			,						-1       )       ) for x in image_inputs]

         return image_inputs

   def     UpperCamelCase					(				self	:    Tuple       ) ->			List[str]:
         """simple docstring"""





         A_							       =		self.get_tokenizer()
         A_							       =		self.get_rust_tokenizer()
         A_							       =		self.get_image_processor()

         A_							       =		CLIPProcessor(tokenizer=_UpperCamelCase			,						image_processor=_UpperCamelCase       )
         processor_slow.save_pretrained(self.tmpdirname       )
         A_							       =		CLIPProcessor.from_pretrained(self.tmpdirname			,						use_fast=_UpperCamelCase       )

         A_							       =		CLIPProcessor(tokenizer=_UpperCamelCase			,						image_processor=_UpperCamelCase       )
         processor_fast.save_pretrained(self.tmpdirname       )
         A_							       =		CLIPProcessor.from_pretrained(self.tmpdirname       )

         self.assertEqual(processor_slow.tokenizer.get_vocab()			,						tokenizer_slow.get_vocab()       )
         self.assertEqual(processor_fast.tokenizer.get_vocab()			,						tokenizer_fast.get_vocab()       )
         self.assertEqual(tokenizer_slow.get_vocab()			,						tokenizer_fast.get_vocab()       )
         self.assertIsInstance(processor_slow.tokenizer			,						_UpperCamelCase       )
         self.assertIsInstance(processor_fast.tokenizer			,						_UpperCamelCase       )

         self.assertEqual(processor_slow.image_processor.to_json_string()			,						image_processor.to_json_string()       )
         self.assertEqual(processor_fast.image_processor.to_json_string()			,						image_processor.to_json_string()       )
         self.assertIsInstance(processor_slow.image_processor			,						_UpperCamelCase       )
         self.assertIsInstance(processor_fast.image_processor			,						_UpperCamelCase       )

   def     UpperCamelCase					(				self	:    Tuple       ) ->			List[Any]:
         """simple docstring"""





         A_							       =		CLIPProcessor(tokenizer=self.get_tokenizer()			,						image_processor=self.get_image_processor()       )
         processor.save_pretrained(self.tmpdirname       )

         A_							       =		self.get_tokenizer(bos_token='''(BOS)'''			,						eos_token='''(EOS)'''       )
         A_							       =		self.get_image_processor(do_normalize=_UpperCamelCase			,						padding_value=1.0       )

         A_							       =		CLIPProcessor.from_pretrained(
             self.tmpdirname			,						bos_token='''(BOS)'''			,						eos_token='''(EOS)'''			,						do_normalize=_UpperCamelCase			,						padding_value=1.0       )

         self.assertEqual(processor.tokenizer.get_vocab()			,						tokenizer_add_kwargs.get_vocab()       )
         self.assertIsInstance(processor.tokenizer			,						_UpperCamelCase       )

         self.assertEqual(processor.image_processor.to_json_string()			,						image_processor_add_kwargs.to_json_string()       )
         self.assertIsInstance(processor.image_processor			,						_UpperCamelCase       )

   def     UpperCamelCase					(				self	:    Optional[int]       ) ->			List[str]:
         """simple docstring"""





         A_							       =		self.get_image_processor()
         A_							       =		self.get_tokenizer()

         A_							       =		CLIPProcessor(tokenizer=_UpperCamelCase			,						image_processor=_UpperCamelCase       )

         A_							       =		self.prepare_image_inputs()

         A_							       =		image_processor(_UpperCamelCase			,						return_tensors='''np'''       )
         A_							       =		processor(images=_UpperCamelCase			,						return_tensors='''np'''       )

         for key in input_image_proc.keys():
               self.assertAlmostEqual(input_image_proc[key].sum()			,						input_processor[key].sum()			,						delta=1e-2       )

   def     UpperCamelCase					(				self	:    List[str]       ) ->			int:
         """simple docstring"""





         A_							       =		self.get_image_processor()
         A_							       =		self.get_tokenizer()

         A_							       =		CLIPProcessor(tokenizer=_UpperCamelCase			,						image_processor=_UpperCamelCase       )

         A_							       =		'''lower newer'''

         A_							       =		processor(text=_UpperCamelCase       )

         A_							       =		tokenizer(_UpperCamelCase       )

         for key in encoded_tok.keys():
               self.assertListEqual(encoded_tok[key]			,						encoded_processor[key]       )

   def     UpperCamelCase					(				self	:    Dict       ) ->			int:
         """simple docstring"""





         A_							       =		self.get_image_processor()
         A_							       =		self.get_tokenizer()

         A_							       =		CLIPProcessor(tokenizer=_UpperCamelCase			,						image_processor=_UpperCamelCase       )

         A_							       =		'''lower newer'''
         A_							       =		self.prepare_image_inputs()

         A_							       =		processor(text=_UpperCamelCase			,						images=_UpperCamelCase       )

         self.assertListEqual(list(inputs.keys()       )			,						['''input_ids''', '''attention_mask''', '''pixel_values''']       )

         # test if it raises when no input is passed
         with pytest.raises(_UpperCamelCase       ):
               processor()

   def     UpperCamelCase					(				self	:    Dict       ) ->			Any:
         """simple docstring"""





         A_							       =		self.get_image_processor()
         A_							       =		self.get_tokenizer()

         A_							       =		CLIPProcessor(tokenizer=_UpperCamelCase			,						image_processor=_UpperCamelCase       )

         A_							       =		[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

         A_							       =		processor.batch_decode(_UpperCamelCase       )
         A_							       =		tokenizer.batch_decode(_UpperCamelCase       )

         self.assertListEqual(_UpperCamelCase			,						_UpperCamelCase       )





   def     UpperCamelCase					(				self	:    Tuple       ) ->			Optional[int]:
         """simple docstring"""





         A_							       =		self.get_image_processor()
         A_							       =		self.get_tokenizer()

         A_							       =		CLIPProcessor(tokenizer=_UpperCamelCase			,						image_processor=_UpperCamelCase       )

         A_							       =		'''lower newer'''
         A_							       =		self.prepare_image_inputs()

         A_							       =		processor(text=_UpperCamelCase			,						images=_UpperCamelCase       )

         self.assertListEqual(list(inputs.keys()       )			,						processor.model_input_names       )









'''simple docstring'''
# Copyright 2021 The HuggingFace 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 pathlib import Path

import torch

from ...utils import is_npu_available, is_xpu_available
from .config_args import ClusterConfig, default_json_config_file
from .config_utils import SubcommandHelpFormatter


lowerCAmelCase						=					"""Create a default config file for Accelerate with only a few flags set."""

def 					lowerCamelCase_ ( __UpperCamelCase					:       Union[str, Any]="no"							,    __UpperCamelCase					:       str = default_json_config_file							,    __UpperCamelCase					:       bool = False		)					->	Tuple:







     """simple docstring"""
     _A				=							Path(__UpperCamelCase		)
     path.parent.mkdir(parents=__UpperCamelCase							,    exist_ok=__UpperCamelCase		)
     if path.exists():
          print(
              F'Configuration already exists at {save_location}, will not override. Run `accelerate config` manually or pass a different `save_location`.'		)
          return False
     _A				=							mixed_precision.lower()
     if mixed_precision not in ["no", "fp16", "bf16", "fp8"]:
          raise ValueError(
              F'`mixed_precision` should be one of \'no\', \'fp16\', \'bf16\', or \'fp8\'. Received {mixed_precision}'		)
     _A				=							{
         'compute_environment': 'LOCAL_MACHINE',
         'mixed_precision': mixed_precision,
     }
     if torch.cuda.is_available():
          _A				=							torch.cuda.device_count()
          _A				=							num_gpus
          _A				=							False
          if num_gpus > 1:
               _A				=							'MULTI_GPU'
          else:
               _A				=							'NO'
     elif is_xpu_available() and use_xpu:
          _A				=							torch.xpu.device_count()
          _A				=							num_xpus
          _A				=							False
          if num_xpus > 1:
               _A				=							'MULTI_XPU'
          else:
               _A				=							'NO'
     elif is_npu_available():
          _A				=							torch.npu.device_count()
          _A				=							num_npus
          _A				=							False
          if num_npus > 1:
               _A				=							'MULTI_NPU'
          else:
               _A				=							'NO'
     else:
          _A				=							0
          _A				=							True
          _A				=							1
          _A				=							'NO'
     _A				=							ClusterConfig(**__UpperCamelCase		)
     config.to_json_file(__UpperCamelCase		)
     return path

def 					lowerCamelCase_ ( __UpperCamelCase					:       List[Any]							,    __UpperCamelCase					:       str		)					->	Any:







     """simple docstring"""
     _A				=							parser.add_parser('default'							,    parents=__UpperCamelCase							,    help=__UpperCamelCase							,    formatter_class=__UpperCamelCase		)
     parser.add_argument(
         '--config_file'							,    default=__UpperCamelCase							,    help=(
             'The path to use to store the config file. Will default to a file named default_config.yaml in the cache '
             'location, which is the content of the environment `HF_HOME` suffixed with \'accelerate\', or if you don\'t have '
             'such an environment variable, your cache directory (\'~/.cache\' or the content of `XDG_CACHE_HOME`) suffixed '
             'with \'huggingface\'.'
         )							,    dest='save_location'							,    )

     parser.add_argument(
         '--mixed_precision'							,    choices=['no', 'fp16', 'bf16']							,    type=__UpperCamelCase							,    help='Whether or not to use mixed precision training. '
         'Choose between FP16 and BF16 (bfloat16) training. '
         'BF16 training is only supported on Nvidia Ampere GPUs and PyTorch 1.10 or later.'							,    default='no'							,    )
     parser.set_defaults(func=__UpperCamelCase		)
     return parser

def 					lowerCamelCase_ ( __UpperCamelCase					:       Any		)					->	Union[str, Any]:







     """simple docstring"""
     _A				=							write_basic_config(args.mixed_precision							,    args.save_location		)
     if config_file:
          print(F'accelerate configuration saved at {config_file}'		)





