


import json
import os
import shutil
import tempfile
import unittest

from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor, WavaVecaProcessor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_wavaveca import floats_list







class     lowerCamelCase__		(							unittest.TestCase ):






			"""simple docstring"""






			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    "<pad> <s> </s> <unk> | E T A O N I H S R D L U M W C F G Y P B V K ' X J Q Z".split(" "       )
						UpperCamelCase__   =    dict(zip(snake_case ,  range(len(snake_case       )       )       )       )

						UpperCamelCase__   =    {
						    "pad_token": "<pad>",
						    "unk_token": "<unk>",
						    "bos_token": "<s>",
						    "eos_token": "</s>",
						}
						UpperCamelCase__   =    {
						    "feature_size": 1,
						    "padding_value": 0.0,
						    "sampling_rate": 16000,
						    "return_attention_mask": False,
						    "do_normalize": True,
						}

						UpperCamelCase__   =    tempfile.mkdtemp()
						UpperCamelCase__   =    os.path.join(self.tmpdirname ,  VOCAB_FILES_NAMES["vocab_file"]       )
						UpperCamelCase__   =    os.path.join(self.tmpdirname ,  snake_case       )
						with open(self.vocab_file ,  "w" ,  encoding="utf-8"       ) as fp:
									fp.write(json.dumps(snake_case       ) + "\n"       )

						with open(self.feature_extraction_file ,  "w" ,  encoding="utf-8"       ) as fp:
									fp.write(json.dumps(snake_case       ) + "\n"       )




			def 			snake_case__			(							self ,  **snake_case       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.add_kwargs_tokens_map.copy()
						kwargs.update(snake_case       )
						return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname ,  **snake_case       )




			def 			snake_case__			(							self ,  **snake_case       ):

						'''simple docstring'''


						return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname ,  **snake_case       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						shutil.rmtree(self.tmpdirname       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.get_tokenizer()
						UpperCamelCase__   =    self.get_feature_extractor()

						UpperCamelCase__   =    WavaVecaProcessor(tokenizer=snake_case ,  feature_extractor=snake_case       )

						processor.save_pretrained(self.tmpdirname       )
						UpperCamelCase__   =    WavaVecaProcessor.from_pretrained(self.tmpdirname       )

						self.assertEqual(processor.tokenizer.get_vocab() ,  tokenizer.get_vocab()       )
						self.assertIsInstance(processor.tokenizer ,  snake_case       )

						self.assertEqual(processor.feature_extractor.to_json_string() ,  feature_extractor.to_json_string()       )
						self.assertIsInstance(processor.feature_extractor ,  snake_case       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    WavaVecaProcessor(tokenizer=self.get_tokenizer() ,  feature_extractor=self.get_feature_extractor()       )
						processor.save_pretrained(self.tmpdirname       )

						UpperCamelCase__   =    self.get_tokenizer(bos_token="(BOS)" ,  eos_token="(EOS)"       )
						UpperCamelCase__   =    self.get_feature_extractor(do_normalize=snake_case ,  padding_value=1.0       )

						UpperCamelCase__   =    WavaVecaProcessor.from_pretrained(
						    self.tmpdirname ,  bos_token="(BOS)" ,  eos_token="(EOS)" ,  do_normalize=snake_case ,  padding_value=1.0       )

						self.assertEqual(processor.tokenizer.get_vocab() ,  tokenizer_add_kwargs.get_vocab()       )
						self.assertIsInstance(processor.tokenizer ,  snake_case       )

						self.assertEqual(processor.feature_extractor.to_json_string() ,  feature_extractor_add_kwargs.to_json_string()       )
						self.assertIsInstance(processor.feature_extractor ,  snake_case       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.get_feature_extractor()
						UpperCamelCase__   =    self.get_tokenizer()

						UpperCamelCase__   =    WavaVecaProcessor(tokenizer=snake_case ,  feature_extractor=snake_case       )

						UpperCamelCase__   =    floats_list((3, 1000)       )

						UpperCamelCase__   =    feature_extractor(snake_case ,  return_tensors="np"       )
						UpperCamelCase__   =    processor(snake_case ,  return_tensors="np"       )

						for key in input_feat_extract.keys():
									self.assertAlmostEqual(input_feat_extract[key].sum() ,  input_processor[key].sum() ,  delta=1E-2       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.get_feature_extractor()
						UpperCamelCase__   =    self.get_tokenizer()

						UpperCamelCase__   =    WavaVecaProcessor(tokenizer=snake_case ,  feature_extractor=snake_case       )

						UpperCamelCase__   =    "This is a test string"

						UpperCamelCase__   =    processor(text=snake_case       )

						UpperCamelCase__   =    tokenizer(snake_case       )

						for key in encoded_tok.keys():
									self.assertListEqual(encoded_tok[key] ,  encoded_processor[key]       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.get_feature_extractor()
						UpperCamelCase__   =    self.get_tokenizer()

						UpperCamelCase__   =    WavaVecaProcessor(tokenizer=snake_case ,  feature_extractor=snake_case       )

						UpperCamelCase__   =    [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

						UpperCamelCase__   =    processor.batch_decode(snake_case       )
						UpperCamelCase__   =    tokenizer.batch_decode(snake_case       )

						self.assertListEqual(snake_case ,  snake_case       )







			def 			snake_case__			(							self       ):

						'''simple docstring'''


						UpperCamelCase__   =    self.get_feature_extractor()
						UpperCamelCase__   =    self.get_tokenizer()

						UpperCamelCase__   =    WavaVecaProcessor(tokenizer=snake_case ,  feature_extractor=snake_case       )

						self.assertListEqual(
						    processor.model_input_names ,  feature_extractor.model_input_names ,  msg="`processor` and `feature_extractor` model input names do not match" ,  )






import json
import os
from functools import lru_cache
from typing import TYPE_CHECKING, List, Optional, Tuple, Union

import numpy as np
import regex as re

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 ...tokenization_utils import AddedToken, PreTrainedTokenizer


__UpperCamelCase      						=    logging.get_logger(__name__)

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

__UpperCamelCase      						=    {
    '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',
    },
}

__UpperCamelCase      						=    {
    'Salesforce/codegen-350M-mono': 2_0_4_8,
}
@lru_cache()
def     UpperCamelCase_(			)->						Tuple:
			UpperCamelCase__   =    (
			    list(range(ord("!"					)			,       ord("~"					) + 1					)					) + list(range(ord("¡"					)			,       ord("¬"					) + 1					)					) + list(range(ord("®"					)			,       ord("ÿ"					) + 1					)					)
			)
			UpperCamelCase__   =    bs[:]
			UpperCamelCase__   =    0
			for b in range(2**8					):
						if b not in bs:
									bs.append(_A					)
									cs.append(2**8 + n					)
									n += 1
			UpperCamelCase__   =    [chr(_A					) for n in cs]
			return dict(zip(_A			,       _A					)					)
def     UpperCamelCase_(			_A				:Tuple					)->						Optional[Any]:
			UpperCamelCase__   =    set()
			UpperCamelCase__   =    word[0]
			for char in word[1:]:
						pairs.add((prev_char, char)					)
						UpperCamelCase__   =    char
			return pairs







class     lowerCamelCase__		(							UpperCAmelCase ):






			"""simple docstring"""






			_UpperCamelCase						:   Optional[Any]					=						VOCAB_FILES_NAMES
			_UpperCamelCase						:   List[Any]					=						PRETRAINED_VOCAB_FILES_MAP
			_UpperCamelCase						:   Any					=						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			_UpperCamelCase						:   int					=						['input_ids', 'attention_mask']




			def __init__(							self ,  snake_case ,  snake_case ,  snake_case="replace" ,  snake_case="<|endoftext|>" ,  snake_case="<|endoftext|>" ,  snake_case="<|endoftext|>" ,  snake_case=None ,  snake_case=False ,  snake_case=False ,  **snake_case ,  ):

						'''simple docstring'''


						UpperCamelCase__   =    AddedToken(snake_case ,  lstrip=snake_case ,  rstrip=snake_case       ) if isinstance(snake_case ,  snake_case       ) else bos_token
						UpperCamelCase__   =    AddedToken(snake_case ,  lstrip=snake_case ,  rstrip=snake_case       ) if isinstance(snake_case ,  snake_case       ) else eos_token
						UpperCamelCase__   =    AddedToken(snake_case ,  lstrip=snake_case ,  rstrip=snake_case       ) if isinstance(snake_case ,  snake_case       ) else unk_token
						UpperCamelCase__   =    AddedToken(snake_case ,  lstrip=snake_case ,  rstrip=snake_case       ) if isinstance(snake_case ,  snake_case       ) else pad_token
						super().__init__(
						    errors=snake_case ,  unk_token=snake_case ,  bos_token=snake_case ,  eos_token=snake_case ,  pad_token=snake_case ,  add_prefix_space=snake_case ,  add_bos_token=snake_case ,  **snake_case ,  )
						UpperCamelCase__   =    add_bos_token

						with open(snake_case ,  encoding="utf-8"       ) as vocab_handle:
									UpperCamelCase__   =    json.load(snake_case       )
						UpperCamelCase__   =    {v: k for k, v in self.encoder.items()}
						UpperCamelCase__   =    errors  # how to handle errors in decoding
						UpperCamelCase__   =    bytes_to_unicode()
						UpperCamelCase__   =    {v: k for k, v in self.byte_encoder.items()}
						with open(snake_case ,  encoding="utf-8"       ) as merges_handle:
									UpperCamelCase__   =    merges_handle.read().split("\n"       )[1:-1]
						UpperCamelCase__   =    [tuple(merge.split()       ) for merge in bpe_merges]
						UpperCamelCase__   =    dict(zip(snake_case ,  range(len(snake_case       )       )       )       )
						UpperCamelCase__   =    {}
						UpperCamelCase__   =    add_prefix_space

						# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
						UpperCamelCase__   =    re.compile(R"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"       )




			@property
			def 			snake_case__			(							self       ):

						'''simple docstring'''


						return len(self.encoder       )




			def 			snake_case__			(							self       ):

						'''simple docstring'''


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




			def 			snake_case__			(							self ,  snake_case       ):

						'''simple docstring'''


						if token in self.cache:
									return self.cache[token]
						UpperCamelCase__   =    tuple(snake_case       )
						UpperCamelCase__   =    get_pairs(snake_case       )

						if not pairs:
									return token

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

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




			def 			snake_case__			(							self ,  snake_case ,  snake_case=None       ):

						'''simple docstring'''


						if self.add_bos_token:
									UpperCamelCase__   =    [self.bos_token_id]
						else:
									UpperCamelCase__   =    []

						UpperCamelCase__   =    bos_token_ids + token_ids_a

						if token_ids_a is None:
									return output

						return output + bos_token_ids + token_ids_a




			def 			snake_case__			(							self ,  snake_case       ):

						'''simple docstring'''


						UpperCamelCase__   =    []
						for token in re.findall(self.pat ,  snake_case       ):
									UpperCamelCase__   =    "".join(
									    self.byte_encoder[b] for b in token.encode("utf-8"       )       )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
									bpe_tokens.extend(bpe_token for bpe_token in self.bpe(snake_case       ).split(" "       )       )
						return bpe_tokens




			def 			snake_case__			(							self ,  snake_case       ):

						'''simple docstring'''


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




			def 			snake_case__			(							self ,  snake_case       ):

						'''simple docstring'''


						return self.decoder.get(snake_case       )




			def 			snake_case__			(							self ,  snake_case       ):

						'''simple docstring'''


						UpperCamelCase__   =    "".join(snake_case       )
						UpperCamelCase__   =    bytearray([self.byte_decoder[c] for c in text]       ).decode("utf-8" ,  errors=self.errors       )
						return text




			def 			snake_case__			(							self ,  snake_case ,  snake_case = None       ):

						'''simple docstring'''


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

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

						UpperCamelCase__   =    0
						with open(snake_case ,  "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 snake_case       : 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(snake_case       ) + "\n"       )
												index += 1

						return vocab_file, merge_file




			def 			snake_case__			(							self ,  snake_case ,  snake_case=False ,  **snake_case       ):

						'''simple docstring'''


						UpperCamelCase__   =    kwargs.pop("add_prefix_space" ,  self.add_prefix_space       )
						if is_split_into_words or add_prefix_space:
									UpperCamelCase__   =    " " + text
						return (text, kwargs)




			def 			snake_case__			(							self ,  snake_case ,  snake_case = False ,  snake_case = None ,  snake_case = None ,  **snake_case ,  ):

						'''simple docstring'''


						UpperCamelCase__   =    super()._decode(
						    token_ids=snake_case ,  skip_special_tokens=snake_case ,  clean_up_tokenization_spaces=snake_case ,  **snake_case ,  )

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

						return decoded_text







			def 			snake_case__			(							self ,  snake_case ,  snake_case       ):

						'''simple docstring'''


						def find_re(snake_case ,  snake_case ,  snake_case       ):
									UpperCamelCase__   =    pattern.search(snake_case ,  snake_case       )
									return m.start() if m else -1

						UpperCamelCase__   =    [re.compile(snake_case ,  re.MULTILINE       ) for pattern in truncate_before_pattern]

						UpperCamelCase__   =    list(re.finditer("^print" ,  snake_case ,  re.MULTILINE       )       )

						if len(snake_case       ) > 1:
									UpperCamelCase__   =    completion[: prints[1].start()]

						UpperCamelCase__   =    list(re.finditer("^def" ,  snake_case ,  re.MULTILINE       )       )

						if len(snake_case       ) > 1:
									UpperCamelCase__   =    completion[: defs[1].start()]

						UpperCamelCase__   =    0

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

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


