





'''simple docstring'''



import copy
import os
from typing import Union

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


__magic_name__   :						List[Any]    =			logging.get_logger(__name__)

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


class       __SCREAMING_SNAKE_CASE	(						__UpperCamelCase			):



     '''simple docstring'''






     UpperCAmelCase__       :						Any      =   '''altclip_text_model'''

     def __init__(					self						,   lowerCamelCase=250_002						,   lowerCamelCase=1_024						,   lowerCamelCase=24						,   lowerCamelCase=16						,   lowerCamelCase=4_096						,   lowerCamelCase="gelu"						,   lowerCamelCase=0.1						,   lowerCamelCase=0.1						,   lowerCamelCase=514						,   lowerCamelCase=1						,   lowerCamelCase=0.02						,   lowerCamelCase=0.02						,   lowerCamelCase=1e-05						,   lowerCamelCase=1						,   lowerCamelCase=0						,   lowerCamelCase=2						,   lowerCamelCase="absolute"						,   lowerCamelCase=True						,   lowerCamelCase=768						,   **lowerCamelCase						,   ):
       super().__init__(pad_token_id=lowerCamelCase						,   bos_token_id=lowerCamelCase						,   eos_token_id=lowerCamelCase						,   **lowerCamelCase	)

       _snake_case     		=				vocab_size
       _snake_case     		=				hidden_size
       _snake_case     		=				num_hidden_layers
       _snake_case     		=				num_attention_heads
       _snake_case     		=				hidden_act
       _snake_case     		=				intermediate_size
       _snake_case     		=				hidden_dropout_prob
       _snake_case     		=				attention_probs_dropout_prob
       _snake_case     		=				max_position_embeddings
       _snake_case     		=				type_vocab_size
       _snake_case     		=				initializer_range
       _snake_case     		=				initializer_factor
       _snake_case     		=				layer_norm_eps
       _snake_case     		=				position_embedding_type
       _snake_case     		=				use_cache
       _snake_case     		=				project_dim







class       __SCREAMING_SNAKE_CASE	(						__UpperCamelCase			):



     '''simple docstring'''






     UpperCAmelCase__       :						Optional[int]      =   '''altclip_vision_model'''

     def __init__(					self						,   lowerCamelCase=768						,   lowerCamelCase=3_072						,   lowerCamelCase=512						,   lowerCamelCase=12						,   lowerCamelCase=12						,   lowerCamelCase=3						,   lowerCamelCase=224						,   lowerCamelCase=32						,   lowerCamelCase="quick_gelu"						,   lowerCamelCase=1e-5						,   lowerCamelCase=0.0						,   lowerCamelCase=0.02						,   lowerCamelCase=1.0						,   **lowerCamelCase						,   ):
       super().__init__(**lowerCamelCase	)

       _snake_case     		=				hidden_size
       _snake_case     		=				intermediate_size
       _snake_case     		=				projection_dim
       _snake_case     		=				num_hidden_layers
       _snake_case     		=				num_attention_heads
       _snake_case     		=				num_channels
       _snake_case     		=				patch_size
       _snake_case     		=				image_size
       _snake_case     		=				initializer_range
       _snake_case     		=				initializer_factor
       _snake_case     		=				attention_dropout
       _snake_case     		=				layer_norm_eps
       _snake_case     		=				hidden_act






     @classmethod
     def 	UpperCamelCase(					cls						,   lowerCamelCase						,   **lowerCamelCase	):
       cls._set_token_in_kwargs(lowerCamelCase	)

       _snake_case		,		_snake_case     		=				cls.get_config_dict(lowerCamelCase						,   **lowerCamelCase	)

       # get the vision config dict if we are loading from AltCLIPConfig
       if config_dict.get("model_type"	) == "altclip":
         _snake_case     		=				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(lowerCamelCase						,   **lowerCamelCase	)







class       __SCREAMING_SNAKE_CASE	(						__UpperCamelCase			):



     '''simple docstring'''






     UpperCAmelCase__       :						str      =   '''altclip'''
     UpperCAmelCase__       :						str      =   True

     def __init__(					self						,   lowerCamelCase=None						,   lowerCamelCase=None						,   lowerCamelCase=768						,   lowerCamelCase=2.6592						,   **lowerCamelCase	):
       # 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!).
       _snake_case     		=				kwargs.pop("text_config_dict"						,   lowerCamelCase	)
       _snake_case     		=				kwargs.pop("vision_config_dict"						,   lowerCamelCase	)

       super().__init__(**lowerCamelCase	)

       # 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:
           _snake_case     		=				{}

         # This is the complete result when using `text_config_dict`.
         _snake_case     		=				AltCLIPTextConfig(**lowerCamelCase	).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:
               _snake_case     		=				(
                   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:
               _snake_case     		=				(
                   F'''`text_config_dict` is provided which will be used to initialize `AltCLIPTextConfig`. The '''
                   F'''value `text_config["{key}"]` will be overriden.'''
               )
             logger.warning(lowerCamelCase	)

            # 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:
           _snake_case     		=				{}

         # This is the complete result when using `vision_config_dict`.
         _snake_case     		=				AltCLIPVisionConfig(**lowerCamelCase	).to_dict()
         # convert keys to string instead of integer
         if "id2label" in _vision_config_dict:
           _snake_case     		=				{
               str(lowerCamelCase	): 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:
               _snake_case     		=				(
                   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:
               _snake_case     		=				(
                   F'''`vision_config_dict` is provided which will be used to initialize `AltCLIPVisionConfig`. '''
                   F'''The value `vision_config["{key}"]` will be overriden.'''
               )
             logger.warning(lowerCamelCase	)

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

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

       if vision_config is None:
         _snake_case     		=				{}
         logger.info("`vision_config` is `None`. initializing the `AltCLIPVisionConfig` with default values."	)

       _snake_case     		=				AltCLIPTextConfig(**lowerCamelCase	)
       _snake_case     		=				AltCLIPVisionConfig(**lowerCamelCase	)

       _snake_case     		=				projection_dim
       _snake_case     		=				logit_scale_init_value
       _snake_case     		=				1.0

     @classmethod
     def 	UpperCamelCase(					cls						,   lowerCamelCase						,   lowerCamelCase						,   **lowerCamelCase	):
       return cls(text_config=text_config.to_dict()						,   vision_config=vision_config.to_dict()						,   **lowerCamelCase	)






     def 	UpperCamelCase(					self	):
       _snake_case     		=				copy.deepcopy(self.__dict__	)
       _snake_case     		=				self.text_config.to_dict()
       _snake_case     		=				self.vision_config.to_dict()
       _snake_case     		=				self.__class__.model_type
       return output









'''simple docstring'''



import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


__magic_name__   :						Optional[int]    =			logging.get_logger(__name__)

__magic_name__   :						str    =			"""▁"""

__magic_name__   :						int    =			{"""vocab_file""": """sentencepiece.bpe.model"""}

__magic_name__   :						List[str]    =			{
    """vocab_file""": {
        """facebook/xglm-564M""": """https://huggingface.co/facebook/xglm-564M/resolve/main/sentencepiece.bpe.model""",
    }
}

__magic_name__   :						Union[str, Any]    =			{
    """facebook/xglm-564M""": 2_048,
}


class       __SCREAMING_SNAKE_CASE	(						__UpperCamelCase			):



     '''simple docstring'''






     UpperCAmelCase__       :						Union[str, Any]      =   VOCAB_FILES_NAMES
     UpperCAmelCase__       :						str      =   PRETRAINED_VOCAB_FILES_MAP
     UpperCAmelCase__       :						Any      =   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     UpperCAmelCase__       :						Any      =   ['''input_ids''', '''attention_mask''']

     def __init__(					self						,   lowerCamelCase						,   lowerCamelCase="<s>"						,   lowerCamelCase="</s>"						,   lowerCamelCase="</s>"						,   lowerCamelCase="<s>"						,   lowerCamelCase="<unk>"						,   lowerCamelCase="<pad>"						,   lowerCamelCase = None						,   **lowerCamelCase						,   ):
       _snake_case     		=				{} if sp_model_kwargs is None else sp_model_kwargs

       # Compatibility with the original tokenizer
       _snake_case     		=				7
       _snake_case     		=				[F'''<madeupword{i}>''' for i in range(self.num_madeup_words	)]

       _snake_case     		=				kwargs.get("additional_special_tokens"						,   []	)
       kwargs["additional_special_tokens"] += [
           word for word in madeup_words if word not in kwargs["additional_special_tokens"]
       ]

       super().__init__(
           bos_token=lowerCamelCase						,   eos_token=lowerCamelCase						,   unk_token=lowerCamelCase						,   sep_token=lowerCamelCase						,   cls_token=lowerCamelCase						,   pad_token=lowerCamelCase						,   sp_model_kwargs=self.sp_model_kwargs						,   **lowerCamelCase						,   )

       _snake_case     		=				spm.SentencePieceProcessor(**self.sp_model_kwargs	)
       self.sp_model.Load(str(lowerCamelCase	)	)
       _snake_case     		=				vocab_file

       # Original fairseq vocab and spm vocab must be "aligned":
       # Vocab    |    0    |    1    |   2    |    3    |  4  |  5  |  6  |   7   |   8   |  9
       # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
       # fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's'   | '▁de' | '-'
       # spm      | '<unk>' | '<s>'   | '</s>' | ','     | '.' | '▁' | 's' | '▁de' | '-'   | '▁a'

       # The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
       _snake_case     		=				1

       # Mimic fairseq token-to-id alignment for the first 4 token
       _snake_case     		=				{"<s>": 0, "<pad>": 1, "</s>": 2, "<unk>": 3}

       _snake_case     		=				len(self.sp_model	)
       _snake_case     		=				{F'''<madeupword{i}>''': sp_size + i + self.fairseq_offset for i in range(self.num_madeup_words	)}
       self.fairseq_tokens_to_ids.update(lowerCamelCase	)

       _snake_case     		=				{v: k for k, v in self.fairseq_tokens_to_ids.items()}

     def __getstate__(					self	):
       _snake_case     		=				self.__dict__.copy()
       _snake_case     		=				None
       _snake_case     		=				self.sp_model.serialized_model_proto()
       return state

     def __setstate__(					self						,   lowerCamelCase	):
       _snake_case     		=				d

       # for backward compatibility
       if not hasattr(self						,   "sp_model_kwargs"	):
         _snake_case     		=				{}

       _snake_case     		=				spm.SentencePieceProcessor(**self.sp_model_kwargs	)
       self.sp_model.LoadFromSerializedProto(self.sp_model_proto	)

     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase = None	):

       if token_ids_a is None:
         return [self.sep_token_id] + token_ids_a
       _snake_case     		=				[self.sep_token_id]
       return sep + token_ids_a + sep + sep + token_ids_a

     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase = None						,   lowerCamelCase = False	):

       if already_has_special_tokens:
         return super().get_special_tokens_mask(
             token_ids_a=lowerCamelCase						,   token_ids_a=lowerCamelCase						,   already_has_special_tokens=lowerCamelCase	)

       if token_ids_a is None:
         return [1] + ([0] * len(lowerCamelCase	))
       return [1] + ([0] * len(lowerCamelCase	)) + [1, 1] + ([0] * len(lowerCamelCase	))

     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase = None	):
       _snake_case     		=				[self.sep_token_id]

       if token_ids_a is None:
         return len(sep + token_ids_a	) * [0]
       return len(sep + token_ids_a + sep + sep + token_ids_a	) * [0]

     @property
     def 	UpperCamelCase(					self	):
       return len(self.sp_model	) + self.fairseq_offset + self.num_madeup_words

     def 	UpperCamelCase(					self	):
       _snake_case     		=				{self.convert_ids_to_tokens(lowerCamelCase	): i for i in range(self.vocab_size	)}
       vocab.update(self.added_tokens_encoder	)
       return vocab

     def 	UpperCamelCase(					self						,   lowerCamelCase	):
       return self.sp_model.encode(lowerCamelCase						,   out_type=lowerCamelCase	)

     def 	UpperCamelCase(					self						,   lowerCamelCase	):
       if token in self.fairseq_tokens_to_ids:
         return self.fairseq_tokens_to_ids[token]
       _snake_case     		=				self.sp_model.PieceToId(lowerCamelCase	)

       # Need to return unknown token if the SP model returned 0
       return spm_id + self.fairseq_offset if spm_id else self.unk_token_id

     def 	UpperCamelCase(					self						,   lowerCamelCase	):
       if index in self.fairseq_ids_to_tokens:
         return self.fairseq_ids_to_tokens[index]
       return self.sp_model.IdToPiece(index - self.fairseq_offset	)

     def 	UpperCamelCase(					self						,   lowerCamelCase	):
       _snake_case     		=				"".join(lowerCamelCase	).replace(lowerCamelCase						,   " "	).strip()
       return out_string






     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase = None	):
       if not os.path.isdir(lowerCamelCase	):
         logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''	)
         return
       _snake_case     		=				os.path.join(
           lowerCamelCase						,   (filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]	)

       if os.path.abspath(self.vocab_file	) != os.path.abspath(lowerCamelCase	) and os.path.isfile(self.vocab_file	):
         copyfile(self.vocab_file						,   lowerCamelCase	)
       elif not os.path.isfile(self.vocab_file	):
         with open(lowerCamelCase						,   "wb"	) as fi:
           _snake_case     		=				self.sp_model.serialized_model_proto()
           fi.write(lowerCamelCase	)

       return (out_vocab_file,)


