

'''simple docstring'''







from collections import OrderedDict
from typing import TYPE_CHECKING, Any, List, Mapping, Optional

from packaging import version


if TYPE_CHECKING:
      from ... import PreTrainedTokenizer, TensorType

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import is_torch_available, logging


__lowerCamelCase						    =      logging.get_logger(__name__)

__lowerCamelCase						    =      {
    '''bigscience/bloom''': '''https://huggingface.co/bigscience/bloom/resolve/main/config.json''',
    '''bigscience/bloom-560m''': '''https://huggingface.co/bigscience/bloom-560m/blob/main/config.json''',
    '''bigscience/bloom-1b1''': '''https://huggingface.co/bigscience/bloom-1b1/blob/main/config.json''',
    '''bigscience/bloom-1b7''': '''https://huggingface.co/bigscience/bloom-1b7/blob/main/config.json''',
    '''bigscience/bloom-3b''': '''https://huggingface.co/bigscience/bloom-3b/blob/main/config.json''',
    '''bigscience/bloom-7b1''': '''https://huggingface.co/bigscience/bloom-7b1/blob/main/config.json''',
}


class    A__ ( _snake_case     ):
    lowercase		   =						"bloom"
    lowercase		   =						["past_key_values"]
    lowercase		   =						{
        "num_hidden_layers": "n_layer",
        "num_attention_heads": "n_head",
    }



    def __init__(   self						,			UpperCamelCase__=250880						,			UpperCamelCase__=64						,			UpperCamelCase__=2						,			UpperCamelCase__=8						,			UpperCamelCase__=1e-5						,			UpperCamelCase__=0.02						,			UpperCamelCase__=True						,			UpperCamelCase__=1						,			UpperCamelCase__=2						,			UpperCamelCase__=False						,			UpperCamelCase__=0.0						,			UpperCamelCase__=0.0						,			UpperCamelCase__=1						,			UpperCamelCase__=False						,			**UpperCamelCase__						,			)  -> List[Any]:





           '''simple docstring'''
           A_		   = vocab_size
           # Backward compatibility with n_embed kwarg
           A_		   = kwargs.pop("""n_embed"""						,			UpperCamelCase__    )
           A_		   = hidden_size if n_embed is None else n_embed
           A_		   = n_layer
           A_		   = n_head
           A_		   = layer_norm_epsilon
           A_		   = initializer_range
           A_		   = use_cache
           A_		   = pretraining_tp
           A_		   = apply_residual_connection_post_layernorm
           A_		   = hidden_dropout
           A_		   = attention_dropout

           A_		   = bos_token_id
           A_		   = eos_token_id
           A_		   = slow_but_exact

           super().__init__(bos_token_id=UpperCamelCase__						,			eos_token_id=UpperCamelCase__						,			**UpperCamelCase__    )


class    A__ ( _snake_case     ):
    lowercase		   =						version.parse("1.12"     )



    def __init__(   self						,			UpperCamelCase__						,			UpperCamelCase__ = "default"						,			UpperCamelCase__ = None						,			UpperCamelCase__ = False						,			)  -> int:





           '''simple docstring'''
           super().__init__(UpperCamelCase__						,			task=UpperCamelCase__						,			patching_specs=UpperCamelCase__						,			use_past=UpperCamelCase__    )
           if not getattr(self._config						,			"""pad_token_id"""						,			UpperCamelCase__    ):
                  # TODO: how to do that better?
                  A_		   = 0



    @property
    def    snake_case_     (   self    )  -> Mapping[str, Mapping[int, str]]:





           '''simple docstring'''
           A_		   = OrderedDict({"""input_ids""": {0: """batch""", 1: """sequence"""}}    )
           if self.use_past:
                  # BLOOM stores values on dynamic axis 2. For more details see: https://github.com/huggingface/transformers/pull/18344
                  self.fill_with_past_key_values_(UpperCamelCase__						,			direction="""inputs"""						,			inverted_values_shape=UpperCamelCase__    )
                  A_		   = {0: """batch""", 1: """past_sequence + sequence"""}
           else:
                  A_		   = {0: """batch""", 1: """sequence"""}

           return common_inputs



    @property
    def    snake_case_     (   self    )  -> int:





           '''simple docstring'''
           return self._config.n_layer



    @property
    def    snake_case_     (   self    )  -> int:





           '''simple docstring'''
           return self._config.n_head



    @property
    def    snake_case_     (   self    )  -> float:





           '''simple docstring'''
           return 1e-3



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__ = -1						,			UpperCamelCase__ = -1						,			UpperCamelCase__ = False						,			UpperCamelCase__ = None						,			)  -> Mapping[str, Any]:





           '''simple docstring'''
           A_		   = super(UpperCamelCase__						,			self    ).generate_dummy_inputs(
               UpperCamelCase__						,			batch_size=UpperCamelCase__						,			seq_length=UpperCamelCase__						,			is_pair=UpperCamelCase__						,			framework=UpperCamelCase__    )

           # We need to order the input in the way they appears in the forward()
           A_		   = OrderedDict({"""input_ids""": common_inputs["""input_ids"""]}    )

           # Need to add the past_keys
           if self.use_past:
                  if not is_torch_available():
                         raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""    )
                  else:
                         import torch

                         A_   ,     A_		   = common_inputs["""input_ids"""].shape
                         # Not using the same length for past_key_values
                         A_		   = seqlen + 2
                         A_		   = self._config.hidden_size // self.num_attention_heads
                         A_		   = (
                             batch * self.num_attention_heads,
                             head_dim,
                             past_key_values_length,
                         )
                         A_		   = (
                             batch * self.num_attention_heads,
                             past_key_values_length,
                             head_dim,
                         )
                         A_		   = [
                             (torch.zeros(UpperCamelCase__    ), torch.zeros(UpperCamelCase__    )) for _ in range(self.num_layers    )
                         ]

           A_		   = common_inputs["""attention_mask"""]
           if self.use_past:
                  A_		   = ordered_inputs["""attention_mask"""].dtype
                  A_		   = torch.cat(
                      [ordered_inputs["""attention_mask"""], torch.ones(UpperCamelCase__						,			UpperCamelCase__						,			dtype=UpperCamelCase__    )]						,			dim=1    )

           return ordered_inputs







    @property
    def    snake_case_     (   self    )  -> int:





           '''simple docstring'''
           return 13



'''simple docstring'''







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    A__ ( unittest.TestCase     ):



    def    snake_case_     (   self    )  -> Any:





           '''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""": 20,
               """do_center_crop""": True,
               """crop_size""": 18,
               """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    snake_case_     (   self						,			**UpperCamelCase__    )  -> str:





           '''simple docstring'''
           return CLIPTokenizer.from_pretrained(self.tmpdirname						,			**UpperCamelCase__    )



    def    snake_case_     (   self						,			**UpperCamelCase__    )  -> Any:





           '''simple docstring'''
           return CLIPTokenizerFast.from_pretrained(self.tmpdirname						,			**UpperCamelCase__    )



    def    snake_case_     (   self						,			**UpperCamelCase__    )  -> Optional[Any]:





           '''simple docstring'''
           return CLIPImageProcessor.from_pretrained(self.tmpdirname						,			**UpperCamelCase__    )



    def    snake_case_     (   self    )  -> List[Any]:





           '''simple docstring'''
           shutil.rmtree(self.tmpdirname    )



    def    snake_case_     (   self    )  -> Any:





           '''simple docstring'''
           A_		   = [np.random.randint(255						,			size=(3, 30, 400)						,			dtype=np.uinta    )]

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

           return image_inputs



    def    snake_case_     (   self    )  -> Optional[int]:





           '''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    snake_case_     (   self    )  -> str:





           '''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    snake_case_     (   self    )  -> 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    snake_case_     (   self    )  -> Optional[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    snake_case_     (   self    )  -> Dict:





           '''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    snake_case_     (   self    )  -> Union[str, 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    snake_case_     (   self    )  -> 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    )
