





"""simple docstring"""





import json
import os
import unittest

from transformers import BatchEncoding, LEDTokenizer, LEDTokenizerFast
from transformers.models.led.tokenization_led import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class 		lowercase					(					_UpperCAmelCase     ,  unittest.TestCase					):
      _SCREAMING_SNAKE_CASE					=      LEDTokenizer
      _SCREAMING_SNAKE_CASE					=      LEDTokenizerFast
      _SCREAMING_SNAKE_CASE					=      True





      def     _snake_case			(       self )		->     Union[str, Any]:
            super().setUp()
            lowerCAmelCase  						=       [
                """l""",
                """o""",
                """w""",
                """e""",
                """r""",
                """s""",
                """t""",
                """i""",
                """d""",
                """n""",
                """\u0120""",
                """\u0120l""",
                """\u0120n""",
                """\u0120lo""",
                """\u0120low""",
                """er""",
                """\u0120lowest""",
                """\u0120newer""",
                """\u0120wider""",
                """<unk>""",
            ]
            lowerCAmelCase  						=       dict(zip(lowercase      ,						range(len(lowercase ) ) ) )
            lowerCAmelCase  						=       ["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
            lowerCAmelCase  						=       {"""unk_token""": """<unk>"""}

            lowerCAmelCase  						=       os.path.join(self.tmpdirname      ,						VOCAB_FILES_NAMES["""vocab_file"""] )
            lowerCAmelCase  						=       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(lowercase ) + """\n""" )
            with open(self.merges_file      ,						"""w"""      ,						encoding="""utf-8""" ) as fp:
                  fp.write("""\n""".join(lowercase ) )





      def     _snake_case			(       self      ,						**lowercase )		->     Optional[Any]:
            kwargs.update(self.special_tokens_map )
            return self.tokenizer_class.from_pretrained(self.tmpdirname      ,						**lowercase )





      def     _snake_case			(       self      ,						**lowercase )		->     List[str]:
            kwargs.update(self.special_tokens_map )
            return self.rust_tokenizer_class.from_pretrained(self.tmpdirname      ,						**lowercase )





      def     _snake_case			(       self      ,						lowercase )		->     Optional[Any]:
            return "lower newer", "lower newer"





      @cached_property
      def     _snake_case			(       self )		->     Any:
            return LEDTokenizer.from_pretrained("""allenai/led-base-16384""" )





      @cached_property
      def     _snake_case			(       self )		->     Optional[Any]:
            return LEDTokenizerFast.from_pretrained("""allenai/led-base-16384""" )





      @require_torch
      def     _snake_case			(       self )		->     Tuple:
            lowerCAmelCase  						=       ["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
            lowerCAmelCase  						=       [0, 250, 251, 17_818, 13, 39_186, 1_938, 4, 2]

            for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
                  lowerCAmelCase  						=       tokenizer(lowercase      ,						max_length=len(lowercase )      ,						padding=lowercase      ,						return_tensors="""pt""" )
                  self.assertIsInstance(lowercase      ,						lowercase )

                  self.assertEqual((2, 9)      ,						batch.input_ids.shape )
                  self.assertEqual((2, 9)      ,						batch.attention_mask.shape )
                  lowerCAmelCase  						=       batch.input_ids.tolist()[0]
                  self.assertListEqual(lowercase      ,						lowercase )





      @require_torch
      def     _snake_case			(       self )		->     List[str]:
            lowerCAmelCase  						=       ["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
            for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
                  lowerCAmelCase  						=       tokenizer(lowercase      ,						padding=lowercase      ,						return_tensors="""pt""" )
                  self.assertIn("""input_ids"""      ,						lowercase )
                  self.assertIn("""attention_mask"""      ,						lowercase )
                  self.assertNotIn("""labels"""      ,						lowercase )
                  self.assertNotIn("""decoder_attention_mask"""      ,						lowercase )





      @require_torch
      def     _snake_case			(       self )		->     str:
            lowerCAmelCase  						=       [
                """Summary of the text.""",
                """Another summary.""",
            ]
            for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
                  lowerCAmelCase  						=       tokenizer(text_target=lowercase      ,						max_length=32      ,						padding="""max_length"""      ,						return_tensors="""pt""" )
                  self.assertEqual(32      ,						targets["""input_ids"""].shape[1] )





      @require_torch
      def     _snake_case			(       self )		->     Optional[Any]:
            for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
                  lowerCAmelCase  						=       tokenizer(
                      ["""I am a small frog""" * 1_024, """I am a small frog"""]      ,						padding=lowercase      ,						truncation=lowercase      ,						return_tensors="""pt""" )
                  self.assertIsInstance(lowercase      ,						lowercase )
                  self.assertEqual(batch.input_ids.shape      ,						(2, 5_122) )





      @require_torch
      def     _snake_case			(       self )		->     str:
            lowerCAmelCase  						=       ["""A long paragraph for summarization."""]
            lowerCAmelCase  						=       [
                """Summary of the text.""",
            ]
            for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
                  lowerCAmelCase  						=       tokenizer(lowercase      ,						return_tensors="""pt""" )
                  lowerCAmelCase  						=       tokenizer(text_target=lowercase      ,						return_tensors="""pt""" )
                  lowerCAmelCase  						=       inputs["""input_ids"""]
                  lowerCAmelCase  						=       targets["""input_ids"""]
                  self.assertTrue((input_ids[:, 0] == tokenizer.bos_token_id).all().item() )
                  self.assertTrue((labels[:, 0] == tokenizer.bos_token_id).all().item() )
                  self.assertTrue((input_ids[:, -1] == tokenizer.eos_token_id).all().item() )
                  self.assertTrue((labels[:, -1] == tokenizer.eos_token_id).all().item() )





      @require_torch
      def     _snake_case			(       self )		->     int:
            for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
                  lowerCAmelCase  						=       ["""Summary of the text.""", """Another summary."""]
                  lowerCAmelCase  						=       [[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, -1, -1]]

                  lowerCAmelCase  						=       tokenizer(lowercase      ,						padding=lowercase )
                  lowerCAmelCase  						=       [[0] * len(lowercase ) for x in encoded_output["""input_ids"""]]
                  lowerCAmelCase  						=       tokenizer.pad(lowercase )
                  self.assertSequenceEqual(outputs["""global_attention_mask"""]      ,						lowercase )





      def     _snake_case			(       self )		->     Optional[Any]:
            pass





      def     _snake_case			(       self )		->     List[Any]:
            for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                  with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})' ):
                        lowerCAmelCase  						=       self.rust_tokenizer_class.from_pretrained(lowercase      ,						**lowercase )
                        lowerCAmelCase  						=       self.tokenizer_class.from_pretrained(lowercase      ,						**lowercase )
                        lowerCAmelCase  						=       """A, <mask> AllenNLP sentence."""
                        lowerCAmelCase  						=       tokenizer_r.encode_plus(lowercase      ,						add_special_tokens=lowercase      ,						return_token_type_ids=lowercase )
                        lowerCAmelCase  						=       tokenizer_p.encode_plus(lowercase      ,						add_special_tokens=lowercase      ,						return_token_type_ids=lowercase )
                        self.assertEqual(sum(tokens_r["""token_type_ids"""] )      ,						sum(tokens_p["""token_type_ids"""] ) )
                        self.assertEqual(
                            sum(tokens_r["""attention_mask"""] ) / len(tokens_r["""attention_mask"""] )      ,						sum(tokens_p["""attention_mask"""] ) / len(tokens_p["""attention_mask"""] )      ,						)

                        lowerCAmelCase  						=       tokenizer_r.convert_ids_to_tokens(tokens_r["""input_ids"""] )
                        lowerCAmelCase  						=       tokenizer_p.convert_ids_to_tokens(tokens_p["""input_ids"""] )
                        self.assertSequenceEqual(tokens_p["""input_ids"""]      ,						[0, 250, 6, 50_264, 3_823, 487, 21_992, 3_645, 4, 2] )
                        self.assertSequenceEqual(tokens_r["""input_ids"""]      ,						[0, 250, 6, 50_264, 3_823, 487, 21_992, 3_645, 4, 2] )

                        self.assertSequenceEqual(
                            lowercase      ,						["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""] )
                        self.assertSequenceEqual(
                            lowercase      ,						["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""] )







'''simple docstring'''




import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_lowercase						: Optional[Any]						=						logging.get_logger(__name__)

_lowercase						: Tuple						=						{
    "BAAI/AltCLIP": "https://huggingface.co/BAAI/AltCLIP/resolve/main/config.json",
    # See all AltCLIP models at https://huggingface.co/models?filter=altclip
}





class     __magic_name__						(    _UpperCAmelCase):
			UpperCamelCase__				=       '''altclip_text_model'''







			def __init__(	self				:  Union[str, Any]				,			lowercase_				:  str=250002				,			lowercase_				:  Union[str, Any]=1024				,			lowercase_				:  Any=24				,			lowercase_				:  Union[str, Any]=16				,			lowercase_				:  Any=4096				,			lowercase_				:  Union[str, Any]="gelu"				,			lowercase_				:  Union[str, Any]=0.1				,			lowercase_				:  Union[str, Any]=0.1				,			lowercase_				:  int=514				,			lowercase_				:  Union[str, Any]=1				,			lowercase_				:  List[str]=0.02				,			lowercase_				:  Optional[int]=0.02				,			lowercase_				:  str=1E-05				,			lowercase_				:  List[str]=1				,			lowercase_				:  List[Any]=0				,			lowercase_				:  Dict=2				,			lowercase_				:  Union[str, Any]="absolute"				,			lowercase_				:  Any=True				,			lowercase_				:  Union[str, Any]=768				,			**lowercase_				:  Any				,			):
										super().__init__(pad_token_id=lowercase_				,			bos_token_id=lowercase_				,			eos_token_id=lowercase_				,			**lowercase_    )

										lowercase_					:			Union[str, Any]										=       vocab_size
										lowercase_					:			str										=       hidden_size
										lowercase_					:			Optional[Any]										=       num_hidden_layers
										lowercase_					:			int										=       num_attention_heads
										lowercase_					:			str										=       hidden_act
										lowercase_					:			List[str]										=       intermediate_size
										lowercase_					:			Optional[int]										=       hidden_dropout_prob
										lowercase_					:			str										=       attention_probs_dropout_prob
										lowercase_					:			str										=       max_position_embeddings
										lowercase_					:			List[str]										=       type_vocab_size
										lowercase_					:			Union[str, Any]										=       initializer_range
										lowercase_					:			List[Any]										=       initializer_factor
										lowercase_					:			str										=       layer_norm_eps
										lowercase_					:			Tuple										=       position_embedding_type
										lowercase_					:			List[Any]										=       use_cache
										lowercase_					:			Tuple										=       project_dim





class     __magic_name__						(    _UpperCAmelCase):
			UpperCamelCase__				=       '''altclip_vision_model'''







			def __init__(	self				:  Dict				,			lowercase_				:  Any=768				,			lowercase_				:  Dict=3072				,			lowercase_				:  Optional[Any]=512				,			lowercase_				:  Dict=12				,			lowercase_				:  Optional[int]=12				,			lowercase_				:  Optional[Any]=3				,			lowercase_				:  str=224				,			lowercase_				:  List[Any]=32				,			lowercase_				:  Union[str, Any]="quick_gelu"				,			lowercase_				:  Dict=1E-5				,			lowercase_				:  Optional[int]=0.0				,			lowercase_				:  Optional[Any]=0.02				,			lowercase_				:  Optional[Any]=1.0				,			**lowercase_				:  Dict				,			):
										super().__init__(**lowercase_    )

										lowercase_					:			Tuple										=       hidden_size
										lowercase_					:			Optional[Any]										=       intermediate_size
										lowercase_					:			Optional[Any]										=       projection_dim
										lowercase_					:			Tuple										=       num_hidden_layers
										lowercase_					:			List[Any]										=       num_attention_heads
										lowercase_					:			Any										=       num_channels
										lowercase_					:			Any										=       patch_size
										lowercase_					:			Dict										=       image_size
										lowercase_					:			Optional[Any]										=       initializer_range
										lowercase_					:			str										=       initializer_factor
										lowercase_					:			Any										=       attention_dropout
										lowercase_					:			Optional[int]										=       layer_norm_eps
										lowercase_					:			int										=       hidden_act







			@classmethod
			def 	SCREAMING_SNAKE_CASE_     (	cls				:  Optional[int]				,			lowercase_				:  Union[str, os.PathLike]				,			**lowercase_				:  Any    ):
										cls._set_token_in_kwargs(lowercase_    )

										lowercase_						,						lowercase_					:			str										=       cls.get_config_dict(lowercase_				,			**lowercase_    )

										# get the vision config dict if we are loading from AltCLIPConfig
										if config_dict.get("""model_type"""    ) == "altclip":
																	lowercase_					:			List[str]										=       config_dict["""vision_config"""]

										if "model_type" in config_dict and hasattr(cls				,			"""model_type"""    ) and config_dict["model_type"] != cls.model_type:
																	logger.warning(
																	    f'''You are using a model of type {config_dict['model_type']} to instantiate a model of type '''
																	    f'''{cls.model_type}. This is not supported for all configurations of models and can yield errors.'''    )

										return cls.from_dict(lowercase_				,			**lowercase_    )





class     __magic_name__						(    _UpperCAmelCase):
			UpperCamelCase__				=       '''altclip'''
			UpperCamelCase__				=       True







			def __init__(	self				:  Optional[int]				,			lowercase_				:  Dict=None				,			lowercase_				:  List[Any]=None				,			lowercase_				:  Tuple=768				,			lowercase_				:  List[str]=2.65_92				,			**lowercase_				:  List[Any]    ):
										# If `_config_dict` exist, we use them for the backward compatibility.
										# We pop out these 2 attributes before calling `super().__init__` to avoid them being saved (which causes a lot
										# of confusion!).
										lowercase_					:			Dict										=       kwargs.pop("""text_config_dict"""				,			lowercase_    )
										lowercase_					:			str										=       kwargs.pop("""vision_config_dict"""				,			lowercase_    )

										super().__init__(**lowercase_    )

										# Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in
										# `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most
										# cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`.
										if text_config_dict is not None:
																	if text_config is None:
																								lowercase_					:			Dict										=       {}

																	# This is the complete result when using `text_config_dict`.
																	lowercase_					:			List[str]										=       AltCLIPTextConfig(**lowercase_    ).to_dict()

																	# Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different.
																	for key, value in _text_config_dict.items():
																								if key in text_config and value != text_config[key] and key not in ["transformers_version"]:
																															# If specified in `text_config_dict`
																															if key in text_config_dict:
																																						lowercase_					:			Optional[Any]										=       (
																																						    f'''`{key}` is found in both `text_config_dict` and `text_config` but with different values. '''
																																						    f'''The value `text_config_dict["{key}"]` will be used instead.'''
																																						)
																															# If inferred from default argument values (just to be super careful)
																															else:
																																						lowercase_					:			Tuple										=       (
																																						    f'''`text_config_dict` is provided which will be used to initialize `AltCLIPTextConfig`. The '''
																																						    f'''value `text_config["{key}"]` will be overriden.'''
																																						)
																															logger.warning(lowercase_    )

            # Update all values in `text_config` with the ones in `_text_config_dict`.
																	text_config.update(_text_config_dict    )

										if vision_config_dict is not None:
																	if vision_config is None:
																								lowercase_					:			int										=       {}

																	# This is the complete result when using `vision_config_dict`.
																	lowercase_					:			List[str]										=       AltCLIPVisionConfig(**lowercase_    ).to_dict()
																	# convert keys to string instead of integer
																	if "id2label" in _vision_config_dict:
																								lowercase_					:			List[str]										=       {
																								    str(lowercase_    ): value for key, value in _vision_config_dict["""id2label"""].items()
																								}

																	# Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different.
																	for key, value in _vision_config_dict.items():
																								if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]:
																															# If specified in `vision_config_dict`
																															if key in vision_config_dict:
																																						lowercase_					:			Any										=       (
																																						    f'''`{key}` is found in both `vision_config_dict` and `vision_config` but with different '''
																																						    f'''values. The value `vision_config_dict["{key}"]` will be used instead.'''
																																						)
																															# If inferred from default argument values (just to be super careful)
																															else:
																																						lowercase_					:			List[str]										=       (
																																						    f'''`vision_config_dict` is provided which will be used to initialize `AltCLIPVisionConfig`. '''
																																						    f'''The value `vision_config["{key}"]` will be overriden.'''
																																						)
																															logger.warning(lowercase_    )

            # Update all values in `vision_config` with the ones in `_vision_config_dict`.
																	vision_config.update(_vision_config_dict    )

										if text_config is None:
																	lowercase_					:			int										=       {}
																	logger.info("""`text_config` is `None`. Initializing the `AltCLIPTextConfig` with default values."""    )

										if vision_config is None:
																	lowercase_					:			Optional[int]										=       {}
																	logger.info("""`vision_config` is `None`. initializing the `AltCLIPVisionConfig` with default values."""    )

										lowercase_					:			Optional[int]										=       AltCLIPTextConfig(**lowercase_    )
										lowercase_					:			Any										=       AltCLIPVisionConfig(**lowercase_    )

										lowercase_					:			List[Any]										=       projection_dim
										lowercase_					:			Optional[Any]										=       logit_scale_init_value
										lowercase_					:			int										=       1.0







			@classmethod
			def 	SCREAMING_SNAKE_CASE_     (	cls				:  Dict				,			lowercase_				:  AltCLIPTextConfig				,			lowercase_				:  AltCLIPVisionConfig				,			**lowercase_				:  Optional[int]    ):
										return cls(text_config=text_config.to_dict()				,			vision_config=vision_config.to_dict()				,			**lowercase_    )







			def 	SCREAMING_SNAKE_CASE_     (	self				:  Optional[int]    ):
										lowercase_					:			Union[str, Any]										=       copy.deepcopy(self.__dict__    )
										lowercase_					:			Optional[int]										=       self.text_config.to_dict()
										lowercase_					:			Any										=       self.vision_config.to_dict()
										lowercase_					:			List[str]										=       self.__class__.model_type
										return output





