




"""simple docstring"""


import json
import re
from typing import TYPE_CHECKING, List, Optional, Tuple, Union

import numpy as np

from ...utils import is_tf_available, is_torch_available, logging


if TYPE_CHECKING:
     if is_torch_available():
          import torch
     if is_tf_available():
          import tensorflow as tf

from tokenizers import pre_tokenizers

from ...tokenization_utils_base import BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_codegen import CodeGenTokenizer


A_						=				logging.get_logger(__name__)

A_						=				{'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt''', '''tokenizer_file''': '''tokenizer.json'''}

A_						=				{
    '''vocab_file''': {
        '''Salesforce/codegen-350M-mono''': '''https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/vocab.json''',
    },
    '''merges_file''': {
        '''Salesforce/codegen-350M-mono''': '''https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/merges.txt''',
    },
    '''tokenizer_file''': {
        '''Salesforce/codegen-350M-mono''': (
            '''https://huggingface.co/Salesforce/codegen-350M-mono/resolve/main/tokenizer.json'''
        ),
    },
}

A_						=				{
    '''Salesforce/codegen-350M-mono''': 20_48,
}






class 					lowercase(     __a ):







 '''simple docstring'''





 lowercase__ 					=					VOCAB_FILES_NAMES
 lowercase__ 					=					PRETRAINED_VOCAB_FILES_MAP
 lowercase__ 					=					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 lowercase__ 					=					["input_ids", "attention_mask"]
 lowercase__ 					=					CodeGenTokenizer


 def __init__(				self:		Union[str, Any],      a_:		List[Any]=None,      a_:		str=None,      a_:		str=None,      a_:		Dict="<|endoftext|>",      a_:		Tuple="<|endoftext|>",      a_:		str="<|endoftext|>",      a_:		List[Any]=False,      **a_:		List[str],      ):




   '''simple docstring'''



   super().__init__(
       a_,      a_,      tokenizer_file=a_,      unk_token=a_,      bos_token=a_,      eos_token=a_,      add_prefix_space=a_,      **a_,      )

   if kwargs.pop("""add_bos_token""",      a_		):
     _snake_case							:		str								=  kwargs.pop("""name_or_path""",      """"""		)
     raise ValueError(
         """Currenty GPT2's fast tokenizer does NOT support adding a BOS token."""
         """Instead you should use GPT2's slow tokenizer class `CodeGenTokenizer` as follows: \n"""
         f"`CodeGenTokenizer.from_pretrained('{model_id}')`\nor\n"
         f"`AutoTokenizer.from_pretrained('{model_id}', use_fast=False)`\n"
         """This issue will be fixed soon, see: https://github.com/huggingface/tokenizers/pull/1005."""
         """ so that the fast tokenizer works correctly."""		)

   _snake_case							:		Tuple								=  json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()		)
   if pre_tok_state.get("""add_prefix_space""",      a_		) != add_prefix_space:
     _snake_case							:		Dict								=  getattr(a_,      pre_tok_state.pop("""type"""		)		)
     _snake_case							:		Dict								=  add_prefix_space
     _snake_case							:		str								=  pre_tok_class(**a_		)

   _snake_case							:		List[Any]								=  add_prefix_space


 def  UpperCamelCase_   (				self:		Any,      *a_:		Any,      **a_:		int		):




   '''simple docstring'''



   _snake_case							:		Optional[int]								=  kwargs.get("""is_split_into_words""",      a_		)
   assert self.add_prefix_space or not is_split_into_words, (
       f"You need to instantiate {self.__class__.__name__} with add_prefix_space=True "
       "to use it with pretokenized inputs."
   )

   return super()._batch_encode_plus(*a_,      **a_		)


 def  UpperCamelCase_   (				self:		Optional[Any],      *a_:		Any,      **a_:		List[str]		):




   '''simple docstring'''



   _snake_case							:		Dict								=  kwargs.get("""is_split_into_words""",      a_		)

   assert self.add_prefix_space or not is_split_into_words, (
       f"You need to instantiate {self.__class__.__name__} with add_prefix_space=True "
       "to use it with pretokenized inputs."
   )

   return super()._encode_plus(*a_,      **a_		)


 def  UpperCamelCase_   (				self:		Optional[int],      a_:		str,      a_:		Optional[str] = None		):




   '''simple docstring'''



   _snake_case							:		List[Any]								=  self._tokenizer.model.save(a_,      name=a_		)
   return tuple(a_		)


 def  UpperCamelCase_   (				self:		str,      a_:		Union[int, List[int], "np.ndarray", "torch.Tensor", "tf.Tensor"],      a_:		bool = False,      a_:		bool = None,      a_:		Optional[List[str]] = None,      **a_:		List[str],      ):




   '''simple docstring'''



   _snake_case							:		Any								=  super().decode(
       token_ids=a_,      skip_special_tokens=a_,      clean_up_tokenization_spaces=a_,      **a_,      )

   if truncate_before_pattern is not None and len(a_		) > 0:
     _snake_case							:		List[str]								=  self.truncate(a_,      a_		)

   return decoded_text


 def  UpperCamelCase_   (				self:		Dict,      a_:		Tuple,      a_:		Optional[Any]		):




   '''simple docstring'''



   def find_re(a_:		Dict,      a_:		str,      a_:		Union[str, Any]		):
     _snake_case							:		Any								=  pattern.search(a_,      a_		)
     return m.start() if m else -1

   _snake_case							:		Tuple								=  [re.compile(a_,      re.MULTILINE		) for pattern in truncate_before_pattern]

   _snake_case							:		List[Any]								=  list(re.finditer("""^print""",      a_,      re.MULTILINE		)		)

   if len(a_		) > 1:
     _snake_case							:		int								=  completion[: prints[1].start()]

   _snake_case							:		List[str]								=  list(re.finditer("""^def""",      a_,      re.MULTILINE		)		)

   if len(a_		) > 1:
     _snake_case							:		List[Any]								=  completion[: defs[1].start()]

   _snake_case							:		int								=  0

   _snake_case							:		List[Any]								=  [
       pos for pos in [find_re(a_,      a_,      a_		) for terminal in terminals] if pos != -1
   ]

   if len(a_		) > 0:
     return completion[: min(a_		)]
   else:
     return completion








"""simple docstring"""


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 					lowercase(     __a       ,			unittest.TestCase ):







 '''simple docstring'''





 lowercase__ 					=					CodeGenTokenizer
 lowercase__ 					=					CodeGenTokenizerFast
 lowercase__ 					=					True
 lowercase__ 					=					{"add_prefix_space": True}
 lowercase__ 					=					False


 def  UpperCamelCase_   (				self:		Tuple		):




   '''simple docstring'''



   super().setUp()

   # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
   _snake_case							:		Tuple								=  [
       """l""",
       """o""",
       """w""",
       """e""",
       """r""",
       """s""",
       """t""",
       """i""",
       """d""",
       """n""",
       """\u0120""",
       """\u0120l""",
       """\u0120n""",
       """\u0120lo""",
       """\u0120low""",
       """er""",
       """\u0120lowest""",
       """\u0120newer""",
       """\u0120wider""",
       """<unk>""",
       """<|endoftext|>""",
   ]
   _snake_case							:		Tuple								=  dict(zip(a_,      range(len(a_		)		)		)		)
   _snake_case							:		str								=  ["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
   _snake_case							:		List[Any]								=  {"""unk_token""": """<unk>"""}

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


 def  UpperCamelCase_   (				self:		Any,      **a_:		int		):




   '''simple docstring'''



   kwargs.update(self.special_tokens_map		)
   return CodeGenTokenizer.from_pretrained(self.tmpdirname,      **a_		)


 def  UpperCamelCase_   (				self:		Any,      **a_:		str		):




   '''simple docstring'''



   kwargs.update(self.special_tokens_map		)
   return CodeGenTokenizerFast.from_pretrained(self.tmpdirname,      **a_		)


 def  UpperCamelCase_   (				self:		Union[str, Any],      a_:		Dict		):




   '''simple docstring'''



   _snake_case							:		Union[str, Any]								=  """lower newer"""
   _snake_case							:		Tuple								=  """lower newer"""
   return input_text, output_text


 def  UpperCamelCase_   (				self:		int		):




   '''simple docstring'''



   _snake_case							:		Union[str, Any]								=  CodeGenTokenizer(self.vocab_file,      self.merges_file,      **self.special_tokens_map		)
   _snake_case							:		Optional[Any]								=  """lower newer"""
   _snake_case							:		Optional[int]								=  ["""\u0120low""", """er""", """\u0120""", """n""", """e""", """w""", """er"""]
   _snake_case							:		int								=  tokenizer.tokenize(a_,      add_prefix_space=a_		)
   self.assertListEqual(a_,      a_		)

   _snake_case							:		str								=  tokens + [tokenizer.unk_token]
   _snake_case							:		Optional[int]								=  [14, 15, 10, 9, 3, 2, 15, 19]
   self.assertListEqual(tokenizer.convert_tokens_to_ids(a_		),      a_		)


 def  UpperCamelCase_   (				self:		Union[str, Any]		):




   '''simple docstring'''



   if not self.test_rust_tokenizer:
     return

   _snake_case							:		int								=  self.get_tokenizer()
   _snake_case							:		int								=  self.get_rust_tokenizer(add_prefix_space=a_		)

   _snake_case							:		Dict								=  """lower newer"""

   # Testing tokenization
   _snake_case							:		Dict								=  tokenizer.tokenize(a_,      add_prefix_space=a_		)
   _snake_case							:		List[str]								=  rust_tokenizer.tokenize(a_		)
   self.assertListEqual(a_,      a_		)

   # Testing conversion to ids without special tokens
   _snake_case							:		Optional[Any]								=  tokenizer.encode(a_,      add_special_tokens=a_,      add_prefix_space=a_		)
   _snake_case							:		Tuple								=  rust_tokenizer.encode(a_,      add_special_tokens=a_		)
   self.assertListEqual(a_,      a_		)

   # Testing conversion to ids with special tokens
   _snake_case							:		Tuple								=  self.get_rust_tokenizer(add_prefix_space=a_		)
   _snake_case							:		int								=  tokenizer.encode(a_,      add_prefix_space=a_		)
   _snake_case							:		Optional[Any]								=  rust_tokenizer.encode(a_		)
   self.assertListEqual(a_,      a_		)

   # Testing the unknown token
   _snake_case							:		Tuple								=  tokens + [rust_tokenizer.unk_token]
   _snake_case							:		List[Any]								=  [14, 15, 10, 9, 3, 2, 15, 19]
   self.assertListEqual(rust_tokenizer.convert_tokens_to_ids(a_		),      a_		)


 def  UpperCamelCase_   (				self:		Dict,      *a_:		Dict,      **a_:		int		):




   '''simple docstring'''



   pass


 def  UpperCamelCase_   (				self:		int,      a_:		List[Any]=15		):




   '''simple docstring'''



   for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
     with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"		):
       _snake_case							:		List[Any]								=  self.rust_tokenizer_class.from_pretrained(a_,      **a_		)

       # Simple input
       _snake_case							:		Any								=  """This is a simple input"""
       _snake_case							:		Optional[int]								=  ["""This is a simple input 1""", """This is a simple input 2"""]
       _snake_case							:		Optional[int]								=  ("""This is a simple input""", """This is a pair""")
       _snake_case							:		Optional[Any]								=  [
           ("""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(a_,      tokenizer_r.encode,      a_,      max_length=a_,      padding="""max_length"""		)

       # Simple input
       self.assertRaises(a_,      tokenizer_r.encode_plus,      a_,      max_length=a_,      padding="""max_length"""		)

       # Simple input
       self.assertRaises(
           a_,      tokenizer_r.batch_encode_plus,      a_,      max_length=a_,      padding="""max_length""",      )

       # Pair input
       self.assertRaises(a_,      tokenizer_r.encode,      a_,      max_length=a_,      padding="""max_length"""		)

       # Pair input
       self.assertRaises(a_,      tokenizer_r.encode_plus,      a_,      max_length=a_,      padding="""max_length"""		)

       # Pair input
       self.assertRaises(
           a_,      tokenizer_r.batch_encode_plus,      a_,      max_length=a_,      padding="""max_length""",      )


 def  UpperCamelCase_   (				self:		Optional[Any]		):




   '''simple docstring'''



   _snake_case							:		List[str]								=  CodeGenTokenizer.from_pretrained(self.tmpdirname,      pad_token="""<pad>"""		)

   # Simple input
   _snake_case							:		List[Any]								=  """This is a simple input"""
   _snake_case							:		int								=  ["""This is a simple input looooooooong""", """This is a simple input"""]
   _snake_case							:		Any								=  ("""This is a simple input""", """This is a pair""")
   _snake_case							:		str								=  [
       ("""This is a simple input loooooong""", """This is a simple input"""),
       ("""This is a simple pair loooooong""", """This is a simple pair"""),
   ]

   _snake_case							:		str								=  tokenizer.pad_token_id

   _snake_case							:		Optional[int]								=  tokenizer(a_,      padding="""max_length""",      max_length=30,      return_tensors="""np"""		)
   _snake_case							:		Dict								=  tokenizer(a_,      padding=a_,      truncate=a_,      return_tensors="""np"""		)
   _snake_case							:		Tuple								=  tokenizer(*a_,      padding="""max_length""",      max_length=60,      return_tensors="""np"""		)
   _snake_case							:		Optional[Any]								=  tokenizer(a_,      padding=a_,      truncate=a_,      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  UpperCamelCase_   (				self:		Union[str, Any]		):




   '''simple docstring'''



   _snake_case							:		Tuple								=  """$$$"""
   _snake_case							:		List[Any]								=  CodeGenTokenizer.from_pretrained(self.tmpdirname,      bos_token=a_,      add_bos_token=a_		)

   _snake_case							:		str								=  """This is a simple input"""
   _snake_case							:		int								=  ["""This is a simple input 1""", """This is a simple input 2"""]

   _snake_case							:		Union[str, Any]								=  tokenizer.bos_token_id

   _snake_case							:		Tuple								=  tokenizer(a_		)
   _snake_case							:		Optional[Any]								=  tokenizer(a_		)

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

   _snake_case							:		Optional[int]								=  tokenizer.decode(out_s.input_ids		)
   _snake_case							:		int								=  tokenizer.batch_decode(out_sa.input_ids		)

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


 @slow
 def  UpperCamelCase_   (				self:		str		):




   '''simple docstring'''



   _snake_case							:		Optional[int]								=  CodeGenTokenizer.from_pretrained("""Salesforce/codegen-350M-mono"""		)

   _snake_case							:		Dict								=  """\nif len_a > len_b:\n    result = a\nelse:\n    result = b\n\n\n\n#"""
   _snake_case							:		Union[str, Any]								=  """\nif len_a > len_b:      result = a\nelse:      result = b"""

   _snake_case							:		Optional[Any]								=  tokenizer.encode(a_		)
   _snake_case							:		Dict								=  ["""^#""", re.escape("""<|endoftext|>"""		), """^'''""", """^\"\"\"""", """\n\n\n"""]
   _snake_case							:		Optional[Any]								=  tokenizer.decode(a_,      truncate_before_pattern=a_		)
   self.assertEqual(a_,      a_		)


 def  UpperCamelCase_   (				self:		str		):




   '''simple docstring'''



   pass


