



import json
import os
import re
import unittest

from transformers import CodeGenTokenizer, CodeGenTokenizerFast
from transformers.models.codegen.tokenization_codegen import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


@require_tokenizers
class 	lowerCamelCase__	(       _A							,  unittest.TestCase):



 """simple docstring"""

 a__					: str =  CodeGenTokenizer
 a__					: Tuple =  CodeGenTokenizerFast
 a__					: List[str] =  True
 a__					: str =  {"add_prefix_space": True}
 a__					: Tuple =  False

 def     snake_case_      (    self					:					Optional[int]      )   ->	Tuple:
    super().setUp()

    # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
    _A      =       [
        '''l''',
        '''o''',
        '''w''',
        '''e''',
        '''r''',
        '''s''',
        '''t''',
        '''i''',
        '''d''',
        '''n''',
        '''\u0120''',
        '''\u0120l''',
        '''\u0120n''',
        '''\u0120lo''',
        '''\u0120low''',
        '''er''',
        '''\u0120lowest''',
        '''\u0120newer''',
        '''\u0120wider''',
        '''<unk>''',
        '''<|endoftext|>''',
    ]
    _A      =       dict(zip(__lowerCAmelCase			,						range(len(__lowerCAmelCase      )      )      )      )
    _A      =       ['''#version: 0.2''', '''\u0120 l''', '''\u0120l o''', '''\u0120lo w''', '''e r''', '''''']
    _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(__lowerCAmelCase      ) + '''\n'''      )
    with open(self.merges_file			,						'''w'''			,						encoding='''utf-8'''      ) as fp:
       fp.write('''\n'''.join(__lowerCAmelCase      )      )

 def     snake_case_      (    self					:					Union[str, Any]			,						**__lowerCAmelCase					:					List[Any]      )   ->	int:
    kwargs.update(self.special_tokens_map      )
    return CodeGenTokenizer.from_pretrained(self.tmpdirname			,						**__lowerCAmelCase      )

 def     snake_case_      (    self					:					int			,						**__lowerCAmelCase					:					int      )   ->	str:
    kwargs.update(self.special_tokens_map      )
    return CodeGenTokenizerFast.from_pretrained(self.tmpdirname			,						**__lowerCAmelCase      )

 def     snake_case_      (    self					:					List[str]			,						__lowerCAmelCase					:					List[str]      )   ->	List[Any]:
    _A      =       '''lower newer'''
    _A      =       '''lower newer'''
    return input_text, output_text

 def     snake_case_      (    self					:					Any      )   ->	Union[str, Any]:
    _A      =       CodeGenTokenizer(self.vocab_file			,						self.merges_file			,						**self.special_tokens_map      )
    _A      =       '''lower newer'''
    _A      =       ['''\u0120low''', '''er''', '''\u0120''', '''n''', '''e''', '''w''', '''er''']
    _A      =       tokenizer.tokenize(__lowerCAmelCase			,						add_prefix_space=__lowerCAmelCase      )
    self.assertListEqual(__lowerCAmelCase			,						__lowerCAmelCase      )

    _A      =       tokens + [tokenizer.unk_token]
    _A      =       [14, 15, 10, 9, 3, 2, 15, 19]
    self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowerCAmelCase      )			,						__lowerCAmelCase      )

 def     snake_case_      (    self					:					Tuple      )   ->	Union[str, Any]:
    if not self.test_rust_tokenizer:
       return

    _A      =       self.get_tokenizer()
    _A      =       self.get_rust_tokenizer(add_prefix_space=__lowerCAmelCase      )

    _A      =       '''lower newer'''

    # Testing tokenization
    _A      =       tokenizer.tokenize(__lowerCAmelCase			,						add_prefix_space=__lowerCAmelCase      )
    _A      =       rust_tokenizer.tokenize(__lowerCAmelCase      )
    self.assertListEqual(__lowerCAmelCase			,						__lowerCAmelCase      )

    # Testing conversion to ids without special tokens
    _A      =       tokenizer.encode(__lowerCAmelCase			,						add_special_tokens=__lowerCAmelCase			,						add_prefix_space=__lowerCAmelCase      )
    _A      =       rust_tokenizer.encode(__lowerCAmelCase			,						add_special_tokens=__lowerCAmelCase      )
    self.assertListEqual(__lowerCAmelCase			,						__lowerCAmelCase      )

    # Testing conversion to ids with special tokens
    _A      =       self.get_rust_tokenizer(add_prefix_space=__lowerCAmelCase      )
    _A      =       tokenizer.encode(__lowerCAmelCase			,						add_prefix_space=__lowerCAmelCase      )
    _A      =       rust_tokenizer.encode(__lowerCAmelCase      )
    self.assertListEqual(__lowerCAmelCase			,						__lowerCAmelCase      )

    # Testing the unknown token
    _A      =       tokens + [rust_tokenizer.unk_token]
    _A      =       [14, 15, 10, 9, 3, 2, 15, 19]
    self.assertListEqual(rust_tokenizer.convert_tokens_to_ids(__lowerCAmelCase      )			,						__lowerCAmelCase      )

 def     snake_case_      (    self					:					str			,						*__lowerCAmelCase					:					Dict			,						**__lowerCAmelCase					:					str      )   ->	Any:
    # It's very difficult to mix/test pretokenization with byte-level
    # And get both CodeGen and Roberta to work at the same time (mostly an issue of adding a space before the string)
    pass

 def     snake_case_      (    self					:					Dict			,						__lowerCAmelCase					:					int=15      )   ->	int:
    for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
       with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''      ):
          _A      =       self.rust_tokenizer_class.from_pretrained(__lowerCAmelCase			,						**__lowerCAmelCase      )

          # Simple input
          _A      =       '''This is a simple input'''
          _A      =       ['''This is a simple input 1''', '''This is a simple input 2''']
          _A      =       ('''This is a simple input''', '''This is a pair''')
          _A      =       [
              ('''This is a simple input 1''', '''This is a simple input 2'''),
              ('''This is a simple pair 1''', '''This is a simple pair 2'''),
          ]

          # Simple input tests
          self.assertRaises(__lowerCAmelCase			,						tokenizer_r.encode			,						__lowerCAmelCase			,						max_length=__lowerCAmelCase			,						padding='''max_length'''      )

          # Simple input
          self.assertRaises(__lowerCAmelCase			,						tokenizer_r.encode_plus			,						__lowerCAmelCase			,						max_length=__lowerCAmelCase			,						padding='''max_length'''      )

          # Simple input
          self.assertRaises(
              __lowerCAmelCase			,						tokenizer_r.batch_encode_plus			,						__lowerCAmelCase			,						max_length=__lowerCAmelCase			,						padding='''max_length'''			,						)

          # Pair input
          self.assertRaises(__lowerCAmelCase			,						tokenizer_r.encode			,						__lowerCAmelCase			,						max_length=__lowerCAmelCase			,						padding='''max_length'''      )

          # Pair input
          self.assertRaises(__lowerCAmelCase			,						tokenizer_r.encode_plus			,						__lowerCAmelCase			,						max_length=__lowerCAmelCase			,						padding='''max_length'''      )

          # Pair input
          self.assertRaises(
              __lowerCAmelCase			,						tokenizer_r.batch_encode_plus			,						__lowerCAmelCase			,						max_length=__lowerCAmelCase			,						padding='''max_length'''			,						)

 def     snake_case_      (    self					:					List[Any]      )   ->	Optional[int]:
    _A      =       CodeGenTokenizer.from_pretrained(self.tmpdirname			,						pad_token='''<pad>'''      )

    # Simple input
    _A      =       '''This is a simple input'''
    _A      =       ['''This is a simple input looooooooong''', '''This is a simple input''']
    _A      =       ('''This is a simple input''', '''This is a pair''')
    _A      =       [
        ('''This is a simple input loooooong''', '''This is a simple input'''),
        ('''This is a simple pair loooooong''', '''This is a simple pair'''),
    ]

    _A      =       tokenizer.pad_token_id

    _A      =       tokenizer(__lowerCAmelCase			,						padding='''max_length'''			,						max_length=30			,						return_tensors='''np'''      )
    _A      =       tokenizer(__lowerCAmelCase			,						padding=__lowerCAmelCase			,						truncate=__lowerCAmelCase			,						return_tensors='''np'''      )
    _A      =       tokenizer(*__lowerCAmelCase			,						padding='''max_length'''			,						max_length=60			,						return_tensors='''np'''      )
    _A      =       tokenizer(__lowerCAmelCase			,						padding=__lowerCAmelCase			,						truncate=__lowerCAmelCase			,						return_tensors='''np'''      )

    # s
    # test single string max_length padding
    self.assertEqual(out_s['''input_ids'''].shape[-1]			,						30      )
    self.assertTrue(pad_token_id in out_s['''input_ids''']      )
    self.assertTrue(0 in out_s['''attention_mask''']      )

    # s2
    # test automatic padding
    self.assertEqual(out_sa['''input_ids'''].shape[-1]			,						33      )
    # long slice doesn't have padding
    self.assertFalse(pad_token_id in out_sa['''input_ids'''][0]      )
    self.assertFalse(0 in out_sa['''attention_mask'''][0]      )
    # short slice does have padding
    self.assertTrue(pad_token_id in out_sa['''input_ids'''][1]      )
    self.assertTrue(0 in out_sa['''attention_mask'''][1]      )

    # p
    # test single pair max_length padding
    self.assertEqual(out_p['''input_ids'''].shape[-1]			,						60      )
    self.assertTrue(pad_token_id in out_p['''input_ids''']      )
    self.assertTrue(0 in out_p['''attention_mask''']      )

    # p2
    # test automatic padding pair
    self.assertEqual(out_pa['''input_ids'''].shape[-1]			,						52      )
    # long slice pair doesn't have padding
    self.assertFalse(pad_token_id in out_pa['''input_ids'''][0]      )
    self.assertFalse(0 in out_pa['''attention_mask'''][0]      )
    # short slice pair does have padding
    self.assertTrue(pad_token_id in out_pa['''input_ids'''][1]      )
    self.assertTrue(0 in out_pa['''attention_mask'''][1]      )

 def     snake_case_      (    self					:					List[Any]      )   ->	int:
    _A      =       '''$$$'''
    _A      =       CodeGenTokenizer.from_pretrained(self.tmpdirname			,						bos_token=__lowerCAmelCase			,						add_bos_token=__lowerCAmelCase      )

    _A      =       '''This is a simple input'''
    _A      =       ['''This is a simple input 1''', '''This is a simple input 2''']

    _A      =       tokenizer.bos_token_id

    _A      =       tokenizer(__lowerCAmelCase      )
    _A      =       tokenizer(__lowerCAmelCase      )

    self.assertEqual(out_s.input_ids[0]			,						__lowerCAmelCase      )
    self.assertTrue(all(o[0] == bos_token_id for o in out_sa.input_ids      )      )

    _A      =       tokenizer.decode(out_s.input_ids      )
    _A      =       tokenizer.batch_decode(out_sa.input_ids      )

    self.assertEqual(decode_s.split()[0]			,						__lowerCAmelCase      )
    self.assertTrue(all(d.split()[0] == bos_token for d in decode_sa      )      )

 @slow
 def     snake_case_      (    self					:					Tuple      )   ->	Any:
    _A      =       CodeGenTokenizer.from_pretrained('''Salesforce/codegen-350M-mono'''      )

    _A      =       '''\nif len_a > len_b:\n    result = a\nelse:\n    result = b\n\n\n\n#'''
    _A      =       '''\nif len_a > len_b:      result = a\nelse:      result = b'''

    _A      =       tokenizer.encode(__lowerCAmelCase      )
    _A      =       ['''^#''', re.escape('''<|endoftext|>'''      ), '''^\'\'\'''', '''^"""''', '''\n\n\n''']
    _A      =       tokenizer.decode(__lowerCAmelCase			,						truncate_before_pattern=__lowerCAmelCase      )
    self.assertEqual(__lowerCAmelCase			,						__lowerCAmelCase      )

 def     snake_case_      (    self					:					Any      )   ->	Dict:
    pass








import collections
import os
import re
from pathlib import Path


UpperCAmelCase_		 =					"""src/transformers"""


# Matches is_xxx_available()
UpperCAmelCase_		 =					re.compile(r"""is\_([a-z_]*)_available()""")
# Catches a one-line _import_struct = {xxx}
UpperCAmelCase_		 =					re.compile(r"""^_import_structure\s+=\s+\{([^\}]+)\}""")
# Catches a line with a key-values pattern: "bla": ["foo", "bar"]
UpperCAmelCase_		 =					re.compile(r"""\s+\"\S*\":\s+\[([^\]]*)\]""")
# Catches a line if not is_foo_available
UpperCAmelCase_		 =					re.compile(r"""^\s*if\s+not\s+is\_[a-z_]*\_available\(\)""")
# Catches a line _import_struct["bla"].append("foo")
UpperCAmelCase_		 =					re.compile(r"""^\s*_import_structure\[\"\S*\"\]\.append\(\"(\S*)\"\)""")
# Catches a line _import_struct["bla"].extend(["foo", "bar"]) or _import_struct["bla"] = ["foo", "bar"]
UpperCAmelCase_		 =					re.compile(r"""^\s*_import_structure\[\S*\](?:\.extend\(|\s*=\s+)\[([^\]]*)\]""")
# Catches a line with an object between quotes and a comma:     "MyModel",
UpperCAmelCase_		 =					re.compile(r"""^\s+\"([^\"]+)\",""")
# Catches a line with objects between brackets only:    ["foo", "bar"],
UpperCAmelCase_		 =					re.compile(r"""^\s+\[([^\]]+)\]""")
# Catches a line with from foo import bar, bla, boo
UpperCAmelCase_		 =					re.compile(r"""\s+from\s+\S*\s+import\s+([^\(\s].*)\n""")
# Catches a line with try:
UpperCAmelCase_		 =					re.compile(r"""^\s*try:""")
# Catches a line with else:
UpperCAmelCase_		 =					re.compile(r"""^\s*else:""")

def 	SCREAMING_SNAKE_CASE_							(	_snake_case	:Optional[int]				)  ->     Any:
   if _re_test_backend.search(_snake_case				) is None:
      return None
   _A      =       [b[0] for b in _re_backend.findall(_snake_case				)]
   backends.sort()
   return "_and_".join(_snake_case				)

def 	SCREAMING_SNAKE_CASE_							(	_snake_case	:Any				)  ->     Any:
   with open(_snake_case	,   '''r'''	,   encoding='''utf-8'''	,   newline='''\n'''				) as f:
      _A      =       f.readlines()

   _A      =       0
   while line_index < len(_snake_case				) and not lines[line_index].startswith('''_import_structure = {'''				):
      line_index += 1

   # If this is a traditional init, just return.
   if line_index >= len(_snake_case				):
      return None

   # First grab the objects without a specific backend in _import_structure
   _A      =       []
   while not lines[line_index].startswith('''if TYPE_CHECKING'''				) and find_backend(lines[line_index]				) is None:
      _A      =       lines[line_index]
      # If we have everything on a single line, let's deal with it.
      if _re_one_line_import_struct.search(_snake_case				):
         _A      =       _re_one_line_import_struct.search(_snake_case				).groups()[0]
         _A      =       re.findall(r'''\[([^\]]+)\]'''	,   _snake_case				)
         for imp in imports:
            objects.extend([obj[1:-1] for obj in imp.split(''', '''				)]				)
         line_index += 1
         continue
      _A      =       _re_import_struct_key_value.search(_snake_case				)
      if single_line_import_search is not None:
         _A      =       [obj[1:-1] for obj in single_line_import_search.groups()[0].split(''', '''				) if len(_snake_case				) > 0]
         objects.extend(_snake_case				)
      elif line.startswith(''' ''' * 8 + '''"'''				):
         objects.append(line[9:-3]				)
      line_index += 1

   _A      =       {'''none''': objects}
   # Let's continue with backend-specific objects in _import_structure
   while not lines[line_index].startswith('''if TYPE_CHECKING'''				):
      # If the line is an if not is_backend_available, we grab all objects associated.
      _A      =       find_backend(lines[line_index]				)
      # Check if the backend declaration is inside a try block:
      if _re_try.search(lines[line_index - 1]				) is None:
         _A      =       None

      if backend is not None:
         line_index += 1

         # Scroll until we hit the else block of try-except-else
         while _re_else.search(lines[line_index]				) is None:
            line_index += 1

         line_index += 1

         _A      =       []
         # Until we unindent, add backend objects to the list
         while len(lines[line_index]				) <= 1 or lines[line_index].startswith(''' ''' * 4				):
            _A      =       lines[line_index]
            if _re_import_struct_add_one.search(_snake_case				) is not None:
               objects.append(_re_import_struct_add_one.search(_snake_case				).groups()[0]				)
            elif _re_import_struct_add_many.search(_snake_case				) is not None:
               _A      =       _re_import_struct_add_many.search(_snake_case				).groups()[0].split(''', '''				)
               _A      =       [obj[1:-1] for obj in imports if len(_snake_case				) > 0]
               objects.extend(_snake_case				)
            elif _re_between_brackets.search(_snake_case				) is not None:
               _A      =       _re_between_brackets.search(_snake_case				).groups()[0].split(''', '''				)
               _A      =       [obj[1:-1] for obj in imports if len(_snake_case				) > 0]
               objects.extend(_snake_case				)
            elif _re_quote_object.search(_snake_case				) is not None:
               objects.append(_re_quote_object.search(_snake_case				).groups()[0]				)
            elif line.startswith(''' ''' * 8 + '''"'''				):
               objects.append(line[9:-3]				)
            elif line.startswith(''' ''' * 12 + '''"'''				):
               objects.append(line[13:-3]				)
            line_index += 1

         _A      =       objects
      else:
         line_index += 1

    # At this stage we are in the TYPE_CHECKING part, first grab the objects without a specific backend
   _A      =       []
   while (
       line_index < len(_snake_case				)
       and find_backend(lines[line_index]				) is None
       and not lines[line_index].startswith('''else'''				)
   ):
      _A      =       lines[line_index]
      _A      =       _re_import.search(_snake_case				)
      if single_line_import_search is not None:
         objects.extend(single_line_import_search.groups()[0].split(''', '''				)				)
      elif line.startswith(''' ''' * 8				):
         objects.append(line[8:-2]				)
      line_index += 1

   _A      =       {'''none''': objects}
   # Let's continue with backend-specific objects
   while line_index < len(_snake_case				):
      # If the line is an if is_backend_available, we grab all objects associated.
      _A      =       find_backend(lines[line_index]				)
      # Check if the backend declaration is inside a try block:
      if _re_try.search(lines[line_index - 1]				) is None:
         _A      =       None

      if backend is not None:
         line_index += 1

         # Scroll until we hit the else block of try-except-else
         while _re_else.search(lines[line_index]				) is None:
            line_index += 1

         line_index += 1

         _A      =       []
         # Until we unindent, add backend objects to the list
         while len(lines[line_index]				) <= 1 or lines[line_index].startswith(''' ''' * 8				):
            _A      =       lines[line_index]
            _A      =       _re_import.search(_snake_case				)
            if single_line_import_search is not None:
               objects.extend(single_line_import_search.groups()[0].split(''', '''				)				)
            elif line.startswith(''' ''' * 12				):
               objects.append(line[12:-2]				)
            line_index += 1

         _A      =       objects
      else:
         line_index += 1

   return import_dict_objects, type_hint_objects

def 	SCREAMING_SNAKE_CASE_							(	_snake_case	:List[str]	,   _snake_case	:Dict				)  ->     Any:

   def find_duplicates(_snake_case	:Any				):
      return [k for k, v in collections.Counter(_snake_case				).items() if v > 1]

   if list(import_dict_objects.keys()				) != list(type_hint_objects.keys()				):
      return ["Both sides of the init do not have the same backends!"]

   _A      =       []
   for key in import_dict_objects.keys():
      _A      =       find_duplicates(import_dict_objects[key]				)
      if duplicate_imports:
         errors.append(F'''Duplicate _import_structure definitions for: {duplicate_imports}'''				)
      _A      =       find_duplicates(type_hint_objects[key]				)
      if duplicate_type_hints:
         errors.append(F'''Duplicate TYPE_CHECKING objects for: {duplicate_type_hints}'''				)

      if sorted(set(import_dict_objects[key]				)				) != sorted(set(type_hint_objects[key]				)				):
         _A      =       '''base imports''' if key == '''none''' else F'''{key} backend'''
         errors.append(F'''Differences for {name}:'''				)
         for a in type_hint_objects[key]:
            if a not in import_dict_objects[key]:
               errors.append(F'''  {a} in TYPE_HINT but not in _import_structure.'''				)
         for a in import_dict_objects[key]:
            if a not in type_hint_objects[key]:
               errors.append(F'''  {a} in _import_structure but not in TYPE_HINT.'''				)
   return errors

def 	SCREAMING_SNAKE_CASE_							(	)  ->     int:
   _A      =       []
   for root, _, files in os.walk(_snake_case				):
      if "__init__.py" in files:
         _A      =       os.path.join(_snake_case	,   '''__init__.py'''				)
         _A      =       parse_init(_snake_case				)
         if objects is not None:
            _A      =       analyze_results(*_snake_case				)
            if len(_snake_case				) > 0:
               _A      =       F'''Problem in {fname}, both halves do not define the same objects.\n{errors[0]}'''
               failures.append('''\n'''.join(_snake_case				)				)
   if len(_snake_case				) > 0:
      raise ValueError('''\n\n'''.join(_snake_case				)				)

def 	SCREAMING_SNAKE_CASE_							(	)  ->     Optional[int]:
   _A      =       []
   for path, directories, files in os.walk(_snake_case				):
      for folder in directories:
         # Ignore private modules
         if folder.startswith('''_'''				):
            directories.remove(_snake_case				)
            continue
         # Ignore leftovers from branches (empty folders apart from pycache)
         if len(list((Path(_snake_case				) / folder).glob('''*.py'''				)				)				) == 0:
            continue
         _A      =       str((Path(_snake_case				) / folder).relative_to(_snake_case				)				)
         _A      =       short_path.replace(os.path.sep	,   '''.'''				)
         submodules.append(_snake_case				)
      for fname in files:
         if fname == "__init__.py":
            continue
         _A      =       str((Path(_snake_case				) / fname).relative_to(_snake_case				)				)
         _A      =       short_path.replace('''.py'''	,   ''''''				).replace(os.path.sep	,   '''.'''				)
         if len(submodule.split('''.'''				)				) == 1:
            submodules.append(_snake_case				)
   return submodules


UpperCAmelCase_		 =					[
    """convert_pytorch_checkpoint_to_tf2""",
    """modeling_flax_pytorch_utils""",
    """models.esm.openfold_utils""",
]

def 	SCREAMING_SNAKE_CASE_							(	)  ->     List[str]:
   # This is to make sure the transformers module imported is the one in the repo.
   from transformers.utils import direct_transformers_import

   _A      =       direct_transformers_import(_snake_case				)

   _A      =       set(transformers._import_structure.keys()				)
   # This contains all the base keys of the _import_structure object defined in the init, but if the user is missing
   # some optional dependencies, they may not have all of them. Thus we read the init to read all additions and
   # (potentiall re-) add them.
   with open(os.path.join(_snake_case	,   '''__init__.py'''				)	,   '''r'''				) as f:
      _A      =       f.read()
   import_structure_keys.update(set(re.findall(r'''import_structure\[\"([^\"]*)\"\]'''	,   _snake_case				)				)				)

   _A      =       [
       module
       for module in get_transformers_submodules()
       if module not in IGNORE_SUBMODULES and module not in import_structure_keys
   ]

   if len(_snake_case				) > 0:
      _A      =       '''\n'''.join(F'''- {module}''' for module in module_not_registered				)
      raise ValueError(
          '''The following submodules are not properly registed in the main init of Transformers:\n'''
          F'''{list_of_modules}\n'''
          '''Make sure they appear somewhere in the keys of `_import_structure` with an empty list as value.'''				)


if __name__ == "__main__":
   check_all_inits()
   check_submodules()



