

import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin



class       __snake_case  (    unittest.TestCase     , lowerCAmelCase__       ):

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						load_tool('text-classification')
      self.tool.setup()
      SCREAMING_SNAKE_CASE_									=						load_tool('text-classification'						,		remote=_A)

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.tool('That\'s quite cool'						,		['positive', 'negative'])
      self.assertEqual(_A						,		'positive')

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.remote_tool('That\'s quite cool'						,		['positive', 'negative'])
      self.assertEqual(_A						,		'positive')

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.tool(text='That\'s quite cool'						,		labels=['positive', 'negative'])
      self.assertEqual(_A						,		'positive')


  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.remote_tool(text='That\'s quite cool'						,		labels=['positive', 'negative'])
      self.assertEqual(_A						,		'positive')





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

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


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


UpperCamelCase__  :      Optional[Any]			=    {"vocab_file": "vocab.json", "merges_file": "merges.txt"}

# See all BART models at https://huggingface.co/models?filter=bart
UpperCamelCase__  :      List[str]			=    {
    "vocab_file": {
        "facebook/bart-base": "https://huggingface.co/facebook/bart-base/resolve/main/vocab.json",
        "facebook/bart-large": "https://huggingface.co/facebook/bart-large/resolve/main/vocab.json",
        "facebook/bart-large-mnli": "https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json",
        "facebook/bart-large-cnn": "https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json",
        "facebook/bart-large-xsum": "https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json",
        "yjernite/bart_eli5": "https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json",
    },
    "merges_file": {
        "facebook/bart-base": "https://huggingface.co/facebook/bart-base/resolve/main/merges.txt",
        "facebook/bart-large": "https://huggingface.co/facebook/bart-large/resolve/main/merges.txt",
        "facebook/bart-large-mnli": "https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt",
        "facebook/bart-large-cnn": "https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt",
        "facebook/bart-large-xsum": "https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt",
        "yjernite/bart_eli5": "https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt",
    },
}

UpperCamelCase__  :      str			=    {
    "facebook/bart-base": 1_024,
    "facebook/bart-large": 1_024,
    "facebook/bart-large-mnli": 1_024,
    "facebook/bart-large-cnn": 1_024,
    "facebook/bart-large-xsum": 1_024,
    "yjernite/bart_eli5": 1_024,
}


@lru_cache()
def 					_UpperCAmelCase       (  ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						(
        list(range(ord('!'       ) ,   ord('~'       ) + 1       )       ) + list(range(ord('¡'       ) ,   ord('¬'       ) + 1       )       ) + list(range(ord('®'       ) ,   ord('ÿ'       ) + 1       )       )
    )
    SCREAMING_SNAKE_CASE_									=						bs[:]
    SCREAMING_SNAKE_CASE_									=						0
    for b in range(2**8       ):
        if b not in bs:
            bs.append(_SCREAMING_SNAKE_CASE       )
            cs.append(2**8 + n       )
            n += 1
    SCREAMING_SNAKE_CASE_									=						[chr(_SCREAMING_SNAKE_CASE       ) for n in cs]
    return dict(zip(_SCREAMING_SNAKE_CASE ,   _SCREAMING_SNAKE_CASE       )       )


def 					_UpperCAmelCase       (  _SCREAMING_SNAKE_CASE					:		List[str]       ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_									=						set()
    SCREAMING_SNAKE_CASE_									=						word[0]
    for char in word[1:]:
        pairs.add((prev_char, char)       )
        SCREAMING_SNAKE_CASE_									=						char
    return pairs





class       __snake_case  (    lowerCAmelCase__       ):
  __lowerCAmelCase     :	str						 =  VOCAB_FILES_NAMES
  __lowerCAmelCase     :	Any						 =  PRETRAINED_VOCAB_FILES_MAP
  __lowerCAmelCase     :	Dict						 =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  __lowerCAmelCase     :	List[Any]						 =  ['input_ids', 'attention_mask']

  def __init__(					self						,		_A						,		_A						,		_A="replace"						,		_A="<s>"						,		_A="</s>"						,		_A="</s>"						,		_A="<s>"						,		_A="<unk>"						,		_A="<pad>"						,		_A="<mask>"						,		_A=False						,		**_A						,		):
      SCREAMING_SNAKE_CASE_									=						AddedToken(_A						,		lstrip=_A						,		rstrip=_A) if isinstance(_A						,		_A) else bos_token
      SCREAMING_SNAKE_CASE_									=						AddedToken(_A						,		lstrip=_A						,		rstrip=_A) if isinstance(_A						,		_A) else eos_token
      SCREAMING_SNAKE_CASE_									=						AddedToken(_A						,		lstrip=_A						,		rstrip=_A) if isinstance(_A						,		_A) else sep_token
      SCREAMING_SNAKE_CASE_									=						AddedToken(_A						,		lstrip=_A						,		rstrip=_A) if isinstance(_A						,		_A) else cls_token
      SCREAMING_SNAKE_CASE_									=						AddedToken(_A						,		lstrip=_A						,		rstrip=_A) if isinstance(_A						,		_A) else unk_token
      SCREAMING_SNAKE_CASE_									=						AddedToken(_A						,		lstrip=_A						,		rstrip=_A) if isinstance(_A						,		_A) else pad_token

      # Mask token behave like a normal word, i.e. include the space before it
      SCREAMING_SNAKE_CASE_									=						AddedToken(_A						,		lstrip=_A						,		rstrip=_A) if isinstance(_A						,		_A) else mask_token

      super().__init__(
          errors=_A						,		bos_token=_A						,		eos_token=_A						,		unk_token=_A						,		sep_token=_A						,		cls_token=_A						,		pad_token=_A						,		mask_token=_A						,		add_prefix_space=_A						,		**_A						,		)

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

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

  @property
  def 						lowerCAmelCase__     (					self):
      return len(self.encoder)

  def 						lowerCAmelCase__     (					self):
      return dict(self.encoder						,		**self.added_tokens_encoder)

  def 						lowerCAmelCase__     (					self						,		_A):
      if token in self.cache:
          return self.cache[token]
      SCREAMING_SNAKE_CASE_									=						tuple(_A)
      SCREAMING_SNAKE_CASE_									=						get_pairs(_A)

      if not pairs:
          return token

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

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

  def 						lowerCAmelCase__     (					self						,		_A):
      SCREAMING_SNAKE_CASE_									=						[]
      for token in re.findall(self.pat						,		_A):
          SCREAMING_SNAKE_CASE_									=						''.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(_A).split(' '))
      return bpe_tokens

  def 						lowerCAmelCase__     (					self						,		_A):
      return self.encoder.get(_A						,		self.encoder.get(self.unk_token))

  def 						lowerCAmelCase__     (					self						,		_A):
      return self.decoder.get(_A)

  def 						lowerCAmelCase__     (					self						,		_A):
      SCREAMING_SNAKE_CASE_									=						''.join(_A)
      SCREAMING_SNAKE_CASE_									=						bytearray([self.byte_decoder[c] for c in text]).decode('utf-8'						,		errors=self.errors)
      return text

  def 						lowerCAmelCase__     (					self						,		_A						,		_A = None):
      if not os.path.isdir(_A):
          logger.error(f"""Vocabulary path ({save_directory}) should be a directory""")
          return
      SCREAMING_SNAKE_CASE_									=						os.path.join(
          _A						,		(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'])
      SCREAMING_SNAKE_CASE_									=						os.path.join(
          _A						,		(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['merges_file'])

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

      SCREAMING_SNAKE_CASE_									=						0
      with open(_A						,		'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 _A: 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!')
                  SCREAMING_SNAKE_CASE_									=						token_index
              writer.write(' '.join(_A) + '\n')
              index += 1

      return vocab_file, merge_file

  def 						lowerCAmelCase__     (					self						,		_A						,		_A = None):
      if token_ids_a is None:
          return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
      SCREAMING_SNAKE_CASE_									=						[self.cls_token_id]
      SCREAMING_SNAKE_CASE_									=						[self.sep_token_id]
      return cls + token_ids_a + sep + sep + token_ids_a + sep

  def 						lowerCAmelCase__     (					self						,		_A						,		_A = None						,		_A = False):
      if already_has_special_tokens:
          return super().get_special_tokens_mask(
              token_ids_a=_A						,		token_ids_a=_A						,		already_has_special_tokens=_A)

      if token_ids_a is None:
          return [1] + ([0] * len(_A)) + [1]
      return [1] + ([0] * len(_A)) + [1, 1] + ([0] * len(_A)) + [1]

  def 						lowerCAmelCase__     (					self						,		_A						,		_A = None):
      SCREAMING_SNAKE_CASE_									=						[self.sep_token_id]
      SCREAMING_SNAKE_CASE_									=						[self.cls_token_id]

      if token_ids_a is None:
          return len(cls + token_ids_a + sep) * [0]
      return len(cls + token_ids_a + sep + sep + token_ids_a + sep) * [0]


  def 						lowerCAmelCase__     (					self						,		_A						,		_A=False						,		**_A):
      SCREAMING_SNAKE_CASE_									=						kwargs.pop('add_prefix_space'						,		self.add_prefix_space)
      if (is_split_into_words or add_prefix_space) and (len(_A) > 0 and not text[0].isspace()):
          SCREAMING_SNAKE_CASE_									=						' ' + text
      return (text, kwargs)


