






import json
import os
import shutil
import tempfile
import unittest

import numpy as np

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES, BertTokenizer
from transformers.testing_utils import require_tokenizers, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
 from PIL import Image

 from transformers import VisionTextDualEncoderProcessor, ViTImageProcessor



@require_tokenizers
@require_vision
class 							_UpperCamelCase			(unittest.TestCase			):


      def  __UpperCAmelCase		(	self	)->	Optional[Any]:
           __lowerCAmelCase								=					tempfile.mkdtemp()

           # fmt: off
           __lowerCAmelCase								=					["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "want", "##want", "##ed", "wa", "un", "runn", "##ing", ",", "low", "lowest"]
           # fmt: on
           __lowerCAmelCase								=					os.path.join(self.tmpdirname					,						VOCAB_FILES_NAMES["vocab_file"]	)
           with open(self.vocab_file					,						"w"					,						encoding="utf-8"	) as vocab_writer:
                vocab_writer.write("".join([x + "\n" for x in vocab_tokens]	)	)

           __lowerCAmelCase								=					{
               "do_resize": True,
               "size": {"height": 1_8, "width": 1_8},
               "do_normalize": True,
               "image_mean": [0.5, 0.5, 0.5],
               "image_std": [0.5, 0.5, 0.5],
           }
           __lowerCAmelCase								=					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					,						**__UpperCamelCase	)->	Optional[Any]:
           return BertTokenizer.from_pretrained(self.tmpdirname					,						**__UpperCamelCase	)


      def  __UpperCAmelCase		(	self					,						**__UpperCamelCase	)->	Any:
           return ViTImageProcessor.from_pretrained(self.tmpdirname					,						**__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	Any:
           shutil.rmtree(self.tmpdirname	)


      def  __UpperCAmelCase		(	self	)->	int:
           __lowerCAmelCase								=					[np.random.randint(2_5_5					,						size=(3, 3_0, 4_0_0)					,						dtype=np.uinta	)]

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

           return image_inputs


      def  __UpperCAmelCase		(	self	)->	Optional[Any]:
           __lowerCAmelCase								=					self.get_tokenizer()
           __lowerCAmelCase								=					self.get_image_processor()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           processor.save_pretrained(self.tmpdirname	)
           __lowerCAmelCase								=					VisionTextDualEncoderProcessor.from_pretrained(self.tmpdirname	)

           self.assertEqual(processor.tokenizer.get_vocab()					,						tokenizer.get_vocab()	)
           self.assertIsInstance(processor.tokenizer					,						(BertTokenizer, BertTokenizerFast)	)

           self.assertEqual(processor.image_processor.to_json_string()					,						image_processor.to_json_string()	)
           self.assertIsInstance(processor.image_processor					,						__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	str:
           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(
               tokenizer=self.get_tokenizer()					,						image_processor=self.get_image_processor()	)
           processor.save_pretrained(self.tmpdirname	)

           __lowerCAmelCase								=					self.get_tokenizer(bos_token="(BOS)"					,						eos_token="(EOS)"	)
           __lowerCAmelCase								=					self.get_image_processor(do_normalize=__UpperCamelCase					,						padding_value=1.0	)

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor.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					,						(BertTokenizer, BertTokenizerFast)	)

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


      def  __UpperCAmelCase		(	self	)->	Union[str, Any]:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           __lowerCAmelCase								=					self.prepare_image_inputs()

           __lowerCAmelCase								=					image_processor(__UpperCamelCase					,						return_tensors="np"	)
           __lowerCAmelCase								=					processor(images=__UpperCamelCase					,						return_tensors="np"	)

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


      def  __UpperCAmelCase		(	self	)->	Dict:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           __lowerCAmelCase								=					"lower newer"

           __lowerCAmelCase								=					processor(text=__UpperCamelCase	)

           __lowerCAmelCase								=					tokenizer(__UpperCamelCase	)

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


      def  __UpperCAmelCase		(	self	)->	List[str]:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           __lowerCAmelCase								=					"lower newer"
           __lowerCAmelCase								=					self.prepare_image_inputs()

           __lowerCAmelCase								=					processor(text=__UpperCamelCase					,						images=__UpperCamelCase	)

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

           # test if it raises when no input is passed
           with self.assertRaises(__UpperCamelCase	):
                processor()


      def  __UpperCAmelCase		(	self	)->	Optional[int]:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

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

           __lowerCAmelCase								=					processor.batch_decode(__UpperCamelCase	)
           __lowerCAmelCase								=					tokenizer.batch_decode(__UpperCamelCase	)

           self.assertListEqual(__UpperCamelCase					,						__UpperCamelCase	)


      def  __UpperCAmelCase		(	self	)->	Any:
           __lowerCAmelCase								=					self.get_image_processor()
           __lowerCAmelCase								=					self.get_tokenizer()

           __lowerCAmelCase								=					VisionTextDualEncoderProcessor(tokenizer=__UpperCamelCase					,						image_processor=__UpperCamelCase	)

           __lowerCAmelCase								=					"lower newer"
           __lowerCAmelCase								=					self.prepare_image_inputs()

           __lowerCAmelCase								=					processor(text=__UpperCamelCase					,						images=__UpperCamelCase	)

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














# 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			:					List[str]         =	'''Create a default config file for Accelerate with only a few flags set.'''





def       __lowerCAmelCase      (						__snake_case="no"					, __snake_case = default_json_config_file					, __snake_case = False       ):
     __lowerCAmelCase								=					Path(__snake_case       )
     path.parent.mkdir(parents=__snake_case					, exist_ok=__snake_case       )
     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
     __lowerCAmelCase								=					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}"""       )
     __lowerCAmelCase								=					{
         "compute_environment": "LOCAL_MACHINE",
         "mixed_precision": mixed_precision,
     }
     if torch.cuda.is_available():
          __lowerCAmelCase								=					torch.cuda.device_count()
          __lowerCAmelCase								=					num_gpus
          __lowerCAmelCase								=					False
          if num_gpus > 1:
               __lowerCAmelCase								=					"MULTI_GPU"
          else:
               __lowerCAmelCase								=					"NO"
     elif is_xpu_available() and use_xpu:
          __lowerCAmelCase								=					torch.xpu.device_count()
          __lowerCAmelCase								=					num_xpus
          __lowerCAmelCase								=					False
          if num_xpus > 1:
               __lowerCAmelCase								=					"MULTI_XPU"
          else:
               __lowerCAmelCase								=					"NO"
     elif is_npu_available():
          __lowerCAmelCase								=					torch.npu.device_count()
          __lowerCAmelCase								=					num_npus
          __lowerCAmelCase								=					False
          if num_npus > 1:
               __lowerCAmelCase								=					"MULTI_NPU"
          else:
               __lowerCAmelCase								=					"NO"
     else:
          __lowerCAmelCase								=					0
          __lowerCAmelCase								=					True
          __lowerCAmelCase								=					1
          __lowerCAmelCase								=					"NO"
     __lowerCAmelCase								=					ClusterConfig(**__snake_case       )
     config.to_json_file(__snake_case       )
     return path





def       __lowerCAmelCase      (						__snake_case					, __snake_case       ):
     __lowerCAmelCase								=					parser.add_parser("default"					, parents=__snake_case					, help=__snake_case					, formatter_class=__snake_case       )
     parser.add_argument(
         "--config_file"					, default=__snake_case					, 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=__snake_case					, 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=__snake_case       )
     return parser





def       __lowerCAmelCase      (						__snake_case       ):
     __lowerCAmelCase								=					write_basic_config(args.mixed_precision					, args.save_location       )
     if config_file:
          print(F"""accelerate configuration saved at {config_file}"""       )






