





'''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


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

__lowerCAmelCase							:     Union[str, Any]		     ={"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"}

__lowerCAmelCase							:     List[Any]		     ={
    "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"
        ),
    },
}

__lowerCAmelCase							:     int		     ={
    "Salesforce/codegen-350M-mono": 2048,
}






class        UpperCAmelCase     (	UpperCamelCase__    ):
 __lowercase       		=    VOCAB_FILES_NAMES
 __lowercase       		=    PRETRAINED_VOCAB_FILES_MAP
 __lowercase       		=    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 __lowercase       		=    ["""input_ids""", """attention_mask"""]
 __lowercase       		=    CodeGenTokenizer
 def __init__(    self				:int						,	lowercase_				:int=None						,	lowercase_				:List[Any]=None						,	lowercase_				:int=None						,	lowercase_				:Tuple="<|endoftext|>"						,	lowercase_				:Optional[int]="<|endoftext|>"						,	lowercase_				:Optional[int]="<|endoftext|>"						,	lowercase_				:Tuple=False						,	**lowercase_				:Union[str, Any]						,	)->							int:
    super().__init__(
        lowercase_						,	lowercase_						,	tokenizer_file=lowercase_						,	unk_token=lowercase_						,	bos_token=lowercase_						,	eos_token=lowercase_						,	add_prefix_space=lowercase_						,	**lowercase_						,	)

    if kwargs.pop("add_bos_token"						,	lowercase_							):
       A__    =      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."							)

    A__    =      json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()							)
    if pre_tok_state.get("add_prefix_space"						,	lowercase_							) != add_prefix_space:
       A__    =      getattr(lowercase_						,	pre_tok_state.pop("type"							)							)
       A__    =      add_prefix_space
       A__    =      pre_tok_class(**lowercase_							)

    A__    =      add_prefix_space
 def 					UpperCAmelCase_							(    self				:Tuple						,	*lowercase_				:int						,	**lowercase_				:Tuple							)->							BatchEncoding:
    A__    =      kwargs.get("is_split_into_words"						,	lowercase_							)
    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(*lowercase_						,	**lowercase_							)
 def 					UpperCAmelCase_							(    self				:Dict						,	*lowercase_				:Union[str, Any]						,	**lowercase_				:Union[str, Any]							)->							BatchEncoding:
    A__    =      kwargs.get("is_split_into_words"						,	lowercase_							)

    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(*lowercase_						,	**lowercase_							)
 def 					UpperCAmelCase_							(    self				:Optional[int]						,	lowercase_				:str						,	lowercase_				:Optional[str] = None							)->							Tuple[str]:
    A__    =      self._tokenizer.model.save(lowercase_						,	name=lowercase_							)
    return tuple(lowercase_							)
 def 					UpperCAmelCase_							(    self				:Union[str, Any]						,	lowercase_				:Union[int, List[int], "np.ndarray", "torch.Tensor", "tf.Tensor"]						,	lowercase_				:bool = False						,	lowercase_				:bool = None						,	lowercase_				:Optional[List[str]] = None						,	**lowercase_				:Optional[Any]						,	)->							str:
    A__    =      super().decode(
        token_ids=lowercase_						,	skip_special_tokens=lowercase_						,	clean_up_tokenization_spaces=lowercase_						,	**lowercase_						,	)

    if truncate_before_pattern is not None and len(lowercase_							) > 0:
       A__    =      self.truncate(lowercase_						,	lowercase_							)

    return decoded_text



 def 					UpperCAmelCase_							(    self				:List[Any]						,	lowercase_				:List[str]						,	lowercase_				:Union[str, Any]							)->							int:
    def find_re(lowercase_				:Dict						,	lowercase_				:Dict						,	lowercase_				:str							):
       A__    =      pattern.search(lowercase_						,	lowercase_							)
       return m.start() if m else -1

    A__    =      [re.compile(lowercase_						,	re.MULTILINE							) for pattern in truncate_before_pattern]

    A__    =      list(re.finditer("^print"						,	lowercase_						,	re.MULTILINE							)							)

    if len(lowercase_							) > 1:
       A__    =      completion[: prints[1].start()]

    A__    =      list(re.finditer("^def"						,	lowercase_						,	re.MULTILINE							)							)

    if len(lowercase_							) > 1:
       A__    =      completion[: defs[1].start()]

    A__    =      0

    A__    =      [
        pos for pos in [find_re(lowercase_						,	lowercase_						,	lowercase_							) for terminal in terminals] if pos != -1
    ]

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










'''simple docstring'''

import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin






@require_tokenizers
class        UpperCAmelCase     (	UpperCamelCase__      ,	unittest.TestCase    ):
 __lowercase       		=    CLIPTokenizer
 __lowercase       		=    CLIPTokenizerFast
 __lowercase       		=    True
 __lowercase       		=    {}
 __lowercase       		=    False
 def 					UpperCAmelCase_							(    self				:Optional[int]							)->							Optional[Any]:
     super().setUp()

     # fmt: off
     A__    =      ["l", "o", "w", "e", "r", "s", "t", "i", "d", "n", "lo", "l</w>", "w</w>", "r</w>", "t</w>", "low</w>", "er</w>", "lowest</w>", "newer</w>", "wider", "<unk>", "<|startoftext|>", "<|endoftext|>"]
     # fmt: on
     A__    =      dict(zip(lowercase_						,	range(len(lowercase_							)							)							)							)
     A__    =      ["#version: 0.2", "l o", "lo w</w>", "e r</w>"]
     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(lowercase_							) + "\n"							)
     with open(self.merges_file						,	"w"						,	encoding="utf-8"							) as fp:
         fp.write("\n".join(lowercase_							)							)
 def 					UpperCAmelCase_							(    self				:Optional[int]						,	**lowercase_				:List[str]							)->							str:
     kwargs.update(self.special_tokens_map							)
     return CLIPTokenizer.from_pretrained(self.tmpdirname						,	**lowercase_							)
 def 					UpperCAmelCase_							(    self				:Optional[int]						,	**lowercase_				:Optional[int]							)->							Tuple:
     kwargs.update(self.special_tokens_map							)
     return CLIPTokenizerFast.from_pretrained(self.tmpdirname						,	**lowercase_							)
 def 					UpperCAmelCase_							(    self				:Optional[int]						,	lowercase_				:List[Any]							)->							List[str]:
     A__    =      "lower newer"
     A__    =      "lower newer"
     return input_text, output_text
 def 					UpperCAmelCase_							(    self				:int							)->							List[str]:
     A__    =      CLIPTokenizer(self.vocab_file						,	self.merges_file						,	**self.special_tokens_map							)
     A__    =      "lower newer"
     A__    =      ["lo", "w", "er</w>", "n", "e", "w", "er</w>"]
     A__    =      tokenizer.tokenize(lowercase_							)
     self.assertListEqual(lowercase_						,	lowercase_							)

     A__    =      tokens + [tokenizer.unk_token]
     A__    =      [10, 2, 16, 9, 3, 2, 16, 20]
     self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase_							)						,	lowercase_							)
 @require_ftfy
 def 					UpperCAmelCase_							(    self				:Dict							)->							str:
     for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
         with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"							):
             A__    =      self.tokenizer_class.from_pretrained(lowercase_						,	**lowercase_							)
             A__    =      self.rust_tokenizer_class.from_pretrained(lowercase_						,	**lowercase_							)

             A__    =      "A\n'll 11p223RF☆ho!!to?'d'd''d of a cat to-$''d."
             A__    =      tokenizer_s.tokenize(lowercase_							)
             A__    =      tokenizer_r.tokenize(lowercase_							)

             self.assertListEqual(lowercase_						,	lowercase_							)

             # Test that the tokenization is identical on an example containing a character (Latin Small Letter A
             # with Tilde) encoded in 2 different ways
             A__    =      "xa\u0303y" + " " + "x\xe3y"
             A__    =      tokenizer_s.tokenize(lowercase_							)
             A__    =      tokenizer_r.tokenize(lowercase_							)

             self.assertListEqual(lowercase_						,	lowercase_							)

             # Test that the tokenization is identical on unicode of space type
             A__    =      [
                 "\u0009",  # (horizontal tab, '\t')
                 "\u000B",  # (vertical tab)
                 "\u000C",  # (form feed)
                 "\u0020",  # (space, ' ')
                 "\u200E",  # (left-to-right mark):w
                 "\u200F",  # (right-to-left mark)
             ]
             for unicode_seq in spaces_unicodes:
                 A__    =      tokenizer_s.tokenize(lowercase_							)
                 A__    =      tokenizer_r.tokenize(lowercase_							)

                 self.assertListEqual(lowercase_						,	lowercase_							)

             # Test that the tokenization is identical on unicode of line break type
             A__    =      [
                 "\u000A",  # (line feed, '\n')
                 "\r\n",  # (carriage return and line feed, '\r\n')
                 "\u000D",  # (carriage return, '\r')
                 "\r",  # (carriage return, '\r')
                 "\u000D",  # (carriage return, '\r')
                 "\u2028",  # (line separator)
                 "\u2029",  # (paragraph separator)
                 # "\u0085", # (next line)
             ]

             # The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
             # it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
             # space (and thus into an empty list).

             for unicode_seq in line_break_unicodes:
                 A__    =      tokenizer_s.tokenize(lowercase_							)
                 A__    =      tokenizer_r.tokenize(lowercase_							)

                 self.assertListEqual(lowercase_						,	lowercase_							)
 def 					UpperCAmelCase_							(    self				:Optional[int]							)->							Optional[Any]:
     # Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space`
     for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
         with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"							):
             A__    =      "hello"  # `hello` is a token in the vocabulary of `pretrained_name`
             A__    =      F"{text_of_1_token} {text_of_1_token}"

             A__    =      self.rust_tokenizer_class.from_pretrained(
                 lowercase_						,	use_fast=lowercase_						,	)
             A__    =      tokenizer_r(lowercase_						,	return_offsets_mapping=lowercase_						,	add_special_tokens=lowercase_							)
             self.assertEqual(encoding.offset_mapping[0]						,	(0, len(lowercase_							))							)
             self.assertEqual(
                 encoding.offset_mapping[1]						,	(len(lowercase_							) + 1, len(lowercase_							) + 1 + len(lowercase_							))						,	)

             A__    =      F" {text}"

             A__    =      self.rust_tokenizer_class.from_pretrained(
                 lowercase_						,	use_fast=lowercase_						,	)
             A__    =      tokenizer_r(lowercase_						,	return_offsets_mapping=lowercase_						,	add_special_tokens=lowercase_							)
             self.assertEqual(encoding.offset_mapping[0]						,	(1, 1 + len(lowercase_							))							)
             self.assertEqual(
                 encoding.offset_mapping[1]						,	(1 + len(lowercase_							) + 1, 1 + len(lowercase_							) + 1 + len(lowercase_							))						,	)
 def 					UpperCAmelCase_							(    self				:Dict							)->							Optional[Any]:
     # Test related to the breaking change introduced in transformers v4.17.0
     # We need to check that an error in raised when the user try to load a previous version of the tokenizer.
     with self.assertRaises(lowercase_							) as context:
         self.rust_tokenizer_class.from_pretrained("robot-test/old-clip-tokenizer"							)

     self.assertTrue(
         context.exception.args[0].startswith(
             "The `backend_tokenizer` provided does not match the expected format."							)							)
 @require_ftfy
 def 					UpperCAmelCase_							(    self				:str							)->							Any:
     super().test_tokenization_python_rust_equals()



 def 					UpperCAmelCase_							(    self				:Optional[int]							)->							Union[str, Any]:
     # CLIP always lower cases letters
     pass



