

'''simple docstring'''

import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert 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 AlignProcessor, EfficientNetImageProcessor







@require_vision
class __a (   unittest.TestCase			):





   def      UpperCAmelCase__     (					self				:			Optional[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       tempfile.mkdtemp()

      __SCREAMING_SNAKE_CASE      							=       [
          '''[UNK]''',
          '''[CLS]''',
          '''[SEP]''',
          '''[PAD]''',
          '''[MASK]''',
          '''want''',
          '''##want''',
          '''##ed''',
          '''wa''',
          '''un''',
          '''runn''',
          '''##ing''',
          ''',''',
          '''low''',
          '''lowest''',
      ]
      __SCREAMING_SNAKE_CASE      							=       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]    )    )

      __SCREAMING_SNAKE_CASE      							=       {
          '''do_resize''': True,
          '''size''': 20,
          '''do_center_crop''': True,
          '''crop_size''': 18,
          '''do_normalize''': True,
          '''image_mean''': [0.48_145_466, 0.4_578_275, 0.40_821_073],
          '''image_std''': [0.26_862_954, 0.26_130_258, 0.27_577_711],
      }
      __SCREAMING_SNAKE_CASE      							=       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				:			Optional[Any]				,**lowerCamelCase				:			Union[str, Any]    ):

      '''simple docstring'''

      return BertTokenizer.from_pretrained(self.tmpdirname				,**_UpperCAmelCase    )





   def      UpperCAmelCase__     (					self				:			Union[str, Any]				,**lowerCamelCase				:			Tuple    ):

      '''simple docstring'''

      return BertTokenizerFast.from_pretrained(self.tmpdirname				,**_UpperCAmelCase    )





   def      UpperCAmelCase__     (					self				:			int				,**lowerCamelCase				:			List[Any]    ):

      '''simple docstring'''

      return EfficientNetImageProcessor.from_pretrained(self.tmpdirname				,**_UpperCAmelCase    )





   def      UpperCAmelCase__     (					self				:			Tuple    ):

      '''simple docstring'''

      shutil.rmtree(self.tmpdirname    )





   def      UpperCAmelCase__     (					self				:			Optional[int]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       [np.random.randint(255				,size=(3, 30, 400)				,dtype=np.uinta    )]
      __SCREAMING_SNAKE_CASE      							=       [Image.fromarray(np.moveaxis(_UpperCAmelCase				,0				,-1    )    ) for x in image_inputs]
      return image_inputs





   def      UpperCAmelCase__     (					self				:			int    ):

      '''simple docstring'''

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

      __SCREAMING_SNAKE_CASE      							=       AlignProcessor(tokenizer=_UpperCAmelCase				,image_processor=_UpperCAmelCase    )
      processor_slow.save_pretrained(self.tmpdirname    )
      __SCREAMING_SNAKE_CASE      							=       AlignProcessor.from_pretrained(self.tmpdirname				,use_fast=_UpperCAmelCase    )

      __SCREAMING_SNAKE_CASE      							=       AlignProcessor(tokenizer=_UpperCAmelCase				,image_processor=_UpperCAmelCase    )
      processor_fast.save_pretrained(self.tmpdirname    )
      __SCREAMING_SNAKE_CASE      							=       AlignProcessor.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				:			Optional[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       AlignProcessor(tokenizer=self.get_tokenizer()				,image_processor=self.get_image_processor()    )
      processor.save_pretrained(self.tmpdirname    )

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

      __SCREAMING_SNAKE_CASE      							=       AlignProcessor.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				:			Dict    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_image_processor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()

      __SCREAMING_SNAKE_CASE      							=       AlignProcessor(tokenizer=_UpperCAmelCase				,image_processor=_UpperCAmelCase    )

      __SCREAMING_SNAKE_CASE      							=       self.prepare_image_inputs()

      __SCREAMING_SNAKE_CASE      							=       image_processor(_UpperCAmelCase				,return_tensors="""np"""    )
      __SCREAMING_SNAKE_CASE      							=       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				:			Any    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_image_processor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()

      __SCREAMING_SNAKE_CASE      							=       AlignProcessor(tokenizer=_UpperCAmelCase				,image_processor=_UpperCAmelCase    )

      __SCREAMING_SNAKE_CASE      							=       '''lower newer'''

      __SCREAMING_SNAKE_CASE      							=       processor(text=_UpperCAmelCase    )

      __SCREAMING_SNAKE_CASE      							=       tokenizer(_UpperCAmelCase				,padding="""max_length"""				,max_length=64    )

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





   def      UpperCAmelCase__     (					self				:			Union[str, Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_image_processor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()

      __SCREAMING_SNAKE_CASE      							=       AlignProcessor(tokenizer=_UpperCAmelCase				,image_processor=_UpperCAmelCase    )

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

      __SCREAMING_SNAKE_CASE      							=       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 pytest.raises(_UpperCAmelCase    ):
         processor()





   def      UpperCAmelCase__     (					self				:			Dict    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_image_processor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()

      __SCREAMING_SNAKE_CASE      							=       AlignProcessor(tokenizer=_UpperCAmelCase				,image_processor=_UpperCAmelCase    )

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

      __SCREAMING_SNAKE_CASE      							=       processor.batch_decode(_UpperCAmelCase    )
      __SCREAMING_SNAKE_CASE      							=       tokenizer.batch_decode(_UpperCAmelCase    )

      self.assertListEqual(_UpperCAmelCase				,_UpperCAmelCase    )





   def      UpperCAmelCase__     (					self				:			Optional[Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       self.get_image_processor()
      __SCREAMING_SNAKE_CASE      							=       self.get_tokenizer()

      __SCREAMING_SNAKE_CASE      							=       AlignProcessor(tokenizer=_UpperCAmelCase				,image_processor=_UpperCAmelCase    )

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

      __SCREAMING_SNAKE_CASE      							=       processor(text=_UpperCAmelCase				,images=_UpperCAmelCase    )

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












'''simple docstring'''

from ...utils import (
    OptionalDependencyNotAvailable,
    is_flax_available,
    is_torch_available,
    is_transformers_available,
)


try:
    if not (is_transformers_available() and is_torch_available()):
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
    from .multicontrolnet import MultiControlNetModel
    from .pipeline_controlnet import StableDiffusionControlNetPipeline
    from .pipeline_controlnet_imgaimg import StableDiffusionControlNetImgaImgPipeline
    from .pipeline_controlnet_inpaint import StableDiffusionControlNetInpaintPipeline


if is_transformers_available() and is_flax_available():
    from .pipeline_flax_controlnet import FlaxStableDiffusionControlNetPipeline





