


import json
import os
from typing import Optional, Tuple

import regex as re

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


__a	 =      logging.get_logger(__name__)

__a	 =      {
    '''vocab_file''': '''vocab.json''',
    '''merges_file''': '''merges.txt''',
}

__a	 =      {
    '''vocab_file''': {'''ctrl''': '''https://raw.githubusercontent.com/salesforce/ctrl/master/ctrl-vocab.json'''},
    '''merges_file''': {'''ctrl''': '''https://raw.githubusercontent.com/salesforce/ctrl/master/ctrl-merges.txt'''},
}

__a	 =      {
    '''ctrl''': 256,
}

__a	 =      {
    '''Pregnancy''': 16_8629,
    '''Christianity''': 7675,
    '''Explain''': 10_6423,
    '''Fitness''': 6_3440,
    '''Saving''': 6_3163,
    '''Ask''': 2_7171,
    '''Ass''': 9_5985,
    '''Joke''': 16_3509,
    '''Questions''': 4_5622,
    '''Thoughts''': 4_9605,
    '''Retail''': 5_2342,
    '''Feminism''': 16_4338,
    '''Writing''': 1_1992,
    '''Atheism''': 19_2263,
    '''Netflix''': 4_8616,
    '''Computing''': 3_9639,
    '''Opinion''': 4_3213,
    '''Alone''': 4_4967,
    '''Funny''': 5_8917,
    '''Gaming''': 4_0358,
    '''Human''': 4088,
    '''India''': 1331,
    '''Joker''': 7_7138,
    '''Diet''': 3_6206,
    '''Legal''': 1_1859,
    '''Norman''': 4939,
    '''Tip''': 7_2689,
    '''Weight''': 5_2343,
    '''Movies''': 4_6273,
    '''Running''': 2_3425,
    '''Science''': 2090,
    '''Horror''': 3_7793,
    '''Confession''': 6_0572,
    '''Finance''': 1_2250,
    '''Politics''': 1_6360,
    '''Scary''': 19_1985,
    '''Support''': 1_2654,
    '''Technologies''': 3_2516,
    '''Teenage''': 6_6160,
    '''Event''': 3_2769,
    '''Learned''': 6_7460,
    '''Notion''': 18_2770,
    '''Wikipedia''': 3_7583,
    '''Books''': 6665,
    '''Extract''': 7_6050,
    '''Confessions''': 10_2701,
    '''Conspiracy''': 7_5932,
    '''Links''': 6_3674,
    '''Narcissus''': 15_0425,
    '''Relationship''': 5_4766,
    '''Relationships''': 13_4796,
    '''Reviews''': 4_1671,
    '''News''': 4256,
    '''Translation''': 2_6820,
    '''multilingual''': 12_8406,
}
def 	_UpperCamelCase					(    lowerCAmelCase_ )    ->Tuple:
   UpperCAmelCase      					=  set()
   UpperCAmelCase      					=  word[0]
   for char in word[1:]:
      pairs.add((prev_char, char) )
      UpperCAmelCase      					=  char

   UpperCAmelCase      					=  set(UpperCamelCase_ )
   return pairs







class 	__lowercase					(	snake_case__	):
      UpperCamelCase										=							VOCAB_FILES_NAMES
      UpperCamelCase										=							PRETRAINED_VOCAB_FILES_MAP
      UpperCamelCase										=							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      UpperCamelCase										=							CONTROL_CODES





      def __init__(		self    :       List[str]       ,							__lowerCamelCase    :       Dict       ,							__lowerCamelCase    :       Optional[Any]       ,							__lowerCamelCase    :       Optional[Any]="<unk>"       ,							**__lowerCamelCase    :       int							)     -> Optional[Any]:






         """simple docstring"""







         super().__init__(unk_token=_UpperCAmelCase       ,							**_UpperCAmelCase							)

         with open(_UpperCAmelCase       ,							encoding="""utf-8"""							) as vocab_handle:
            UpperCAmelCase      					=  json.load(_UpperCAmelCase							)
         UpperCAmelCase      					=  {v: k for k, v in self.encoder.items()}
         with open(_UpperCAmelCase       ,							encoding="""utf-8"""							) as merges_handle:
            UpperCAmelCase      					=  merges_handle.read().split("""\n"""							)[1:-1]
         UpperCAmelCase      					=  [tuple(merge.split()							) for merge in merges]
         UpperCAmelCase      					=  dict(zip(_UpperCAmelCase       ,							range(len(_UpperCAmelCase							)							)							)							)
         UpperCAmelCase      					=  {}





      @property
      def 							_lowercase					(		self    :       Optional[int]							)     -> Tuple:






         """simple docstring"""







         return len(self.encoder							)





      def 							_lowercase					(		self    :       int							)     -> Dict:






         """simple docstring"""







         return dict(self.encoder       ,							**self.added_tokens_encoder							)





      def 							_lowercase					(		self    :       Dict       ,							__lowerCamelCase    :       Union[str, Any]							)     -> Dict:






         """simple docstring"""







         if token in self.cache:
            return self.cache[token]
         UpperCAmelCase      					=  tuple(_UpperCAmelCase							)
         UpperCAmelCase      					=  tuple(list(word[:-1]							) + [word[-1] + """</w>"""]							)
         UpperCAmelCase      					=  get_pairs(_UpperCAmelCase							)

         if not pairs:
            return token

         while True:
            UpperCAmelCase      					=  min(_UpperCAmelCase       ,							key=lambda __lowerCamelCase							: self.bpe_ranks.get(_UpperCAmelCase       ,							float("""inf"""							)							)							)
            if bigram not in self.bpe_ranks:
               break
            UpperCAmelCase					,	UpperCAmelCase      					=  bigram
            UpperCAmelCase      					=  []
            UpperCAmelCase      					=  0
            while i < len(_UpperCAmelCase							):
               try:
                  UpperCAmelCase      					=  word.index(_UpperCAmelCase       ,							_UpperCAmelCase							)
               except ValueError:
                  new_word.extend(word[i:]							)
                  break
               else:
                  new_word.extend(word[i:j]							)
                  UpperCAmelCase      					=  j

               if word[i] == first and i < len(_UpperCAmelCase							) - 1 and word[i + 1] == second:
                  new_word.append(first + second							)
                  i += 2
               else:
                  new_word.append(word[i]							)
                  i += 1
            UpperCAmelCase      					=  tuple(_UpperCAmelCase							)
            UpperCAmelCase      					=  new_word
            if len(_UpperCAmelCase							) == 1:
               break
            else:
               UpperCAmelCase      					=  get_pairs(_UpperCAmelCase							)
         UpperCAmelCase      					=  """@@ """.join(_UpperCAmelCase							)
         UpperCAmelCase      					=  word[:-4]
         UpperCAmelCase      					=  word
         return word





      def 							_lowercase					(		self    :       Optional[Any]       ,							__lowerCamelCase    :       Union[str, Any]							)     -> Union[str, Any]:






         """simple docstring"""







         UpperCAmelCase      					=  []

         UpperCAmelCase      					=  re.findall(r"""\S+\n?"""       ,							_UpperCAmelCase							)

         for token in words:
            split_tokens.extend(list(self.bpe(_UpperCAmelCase							).split(""" """							)							)							)
         return split_tokens





      def 							_lowercase					(		self    :       Dict       ,							__lowerCamelCase    :       int							)     -> int:






         """simple docstring"""







         return self.encoder.get(_UpperCAmelCase       ,							self.encoder.get(self.unk_token							)							)





      def 							_lowercase					(		self    :       List[str]       ,							__lowerCamelCase    :       str							)     -> Tuple:






         """simple docstring"""







         return self.decoder.get(_UpperCAmelCase       ,							self.unk_token							)





      def 							_lowercase					(		self    :       Union[str, Any]       ,							__lowerCamelCase    :       Dict							)     -> Any:






         """simple docstring"""







         UpperCAmelCase      					=  """ """.join(_UpperCAmelCase							).replace("""@@ """       ,							""""""							).strip()
         return out_string





      def 							_lowercase					(		self    :       Dict       ,							__lowerCamelCase    :       List[Any]       ,							__lowerCamelCase    :       Dict = None							)     -> Tuple[str]:






         """simple docstring"""







         if not os.path.isdir(_UpperCAmelCase							):
            logger.error(F"""Vocabulary path ({save_directory}) should be a directory"""							)
            return
         UpperCAmelCase      					=  os.path.join(
             _UpperCAmelCase       ,							(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]							)
         UpperCAmelCase      					=  os.path.join(
             _UpperCAmelCase       ,							(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""merges_file"""]							)

         with open(_UpperCAmelCase       ,							"""w"""       ,							encoding="""utf-8"""							) as f:
            f.write(json.dumps(self.encoder       ,							indent=2       ,							sort_keys=_UpperCAmelCase       ,							ensure_ascii=_UpperCAmelCase							) + """\n"""							)

         UpperCAmelCase      					=  0
         with open(_UpperCAmelCase       ,							"""w"""       ,							encoding="""utf-8"""							) as writer:
            writer.write("""#version: 0.2\n"""							)
            for bpe_tokens, token_index in sorted(self.bpe_ranks.items()       ,							key=lambda __lowerCamelCase							: kv[1]							):
               if index != token_index:
                  logger.warning(
                      F"""Saving vocabulary to {merge_file}: BPE merge indices are not consecutive."""
                      """ Please check that the tokenizer is not corrupted!"""							)
                  UpperCAmelCase      					=  token_index
               writer.write(""" """.join(_UpperCAmelCase							) + """\n"""							)
               index += 1

         return vocab_file, merge_file

      # def decode(self, token_ids, skip_special_tokens=False, clean_up_tokenization_spaces=True):
      #     filtered_tokens = ' '.join(self.convert_ids_to_tokens(token_ids, skip_special_tokens=skip_special_tokens))
      #     tokens_generated_so_far = re.sub('(@@ )', '', string=filtered_tokens)
      #     tokens_generated_so_far = re.sub('(@@ ?$)', '', string=tokens_generated_so_far)
      #     return ''.join(tokens_generated_so_far)








'''simple docstring'''

from collections import OrderedDict
from typing import List, Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


SCREAMING_SNAKE_CASE__     :						Union[str, Any]	=  logging.get_logger(__name__)

SCREAMING_SNAKE_CASE__     :						Union[str, Any]	=  {
    '''google/efficientnet-b7''': '''https://huggingface.co/google/efficientnet-b7/resolve/main/config.json''',
}

class 							a__( snake_case__     ):
			a_	: int									=      '''efficientnet'''






			def __init__(     self					,   _UpperCAmelCase = 3					,   _UpperCAmelCase = 600					,   _UpperCAmelCase = 2.0					,   _UpperCAmelCase = 3.1					,   _UpperCAmelCase = 8					,   _UpperCAmelCase = [3, 3, 5, 3, 5, 5, 3]					,   _UpperCAmelCase = [32, 16, 24, 40, 80, 112, 192]					,   _UpperCAmelCase = [16, 24, 40, 80, 112, 192, 320]					,   _UpperCAmelCase = []					,   _UpperCAmelCase = [1, 2, 2, 2, 1, 2, 1]					,   _UpperCAmelCase = [1, 2, 2, 3, 3, 4, 1]					,   _UpperCAmelCase = [1, 6, 6, 6, 6, 6, 6]					,   _UpperCAmelCase = 0.25					,   _UpperCAmelCase = "swish"					,   _UpperCAmelCase = 2560					,   _UpperCAmelCase = "mean"					,   _UpperCAmelCase = 0.02					,   _UpperCAmelCase = 0.001					,   _UpperCAmelCase = 0.99					,   _UpperCAmelCase = 0.5					,   _UpperCAmelCase = 0.2					,   **_UpperCAmelCase					,   )							->							Dict:
					super().__init__(**_UpperCAmelCase						)

					snake_case__	     =num_channels
					snake_case__	     =image_size
					snake_case__	     =width_coefficient
					snake_case__	     =depth_coefficient
					snake_case__	     =depth_divisor
					snake_case__	     =kernel_sizes
					snake_case__	     =in_channels
					snake_case__	     =out_channels
					snake_case__	     =depthwise_padding
					snake_case__	     =strides
					snake_case__	     =num_block_repeats
					snake_case__	     =expand_ratios
					snake_case__	     =squeeze_expansion_ratio
					snake_case__	     =hidden_act
					snake_case__	     =hidden_dim
					snake_case__	     =pooling_type
					snake_case__	     =initializer_range
					snake_case__	     =batch_norm_eps
					snake_case__	     =batch_norm_momentum
					snake_case__	     =dropout_rate
					snake_case__	     =drop_connect_rate
					snake_case__	     =sum(_UpperCAmelCase						) * 4





class 							a__( snake_case__     ):
			a_	: List[str]									=      version.parse('''1.11'''     )






			@property
			def 						_lowercase  (     self						)							->							Mapping[str, Mapping[int, str]]:
					return OrderedDict(
					    [
					        ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
					    ]						)






			@property
			def 						_lowercase  (     self						)							->							float:
					return 1E-5




