


from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
     from PIL import Image

     from ..image_utils import load_image

if is_tf_available():
     import tensorflow as tf

     from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
     from ..tf_utils import stable_softmax

if is_torch_available():
     from ..models.auto.modeling_auto import MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING

snake_case    :   str	    =					logging.get_logger(__name__)







@add_end_docstrings(_snake_case							)
class 		_snake_case  (				_snake_case							):




 def __init__(		self ,  *_lowerCamelCase ,  **_lowerCamelCase   ):
       super().__init__(*_lowerCamelCase ,  **_lowerCamelCase   )
       requires_backends(self ,  '''vision'''   )
       self.check_model_type(
           TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
           if self.framework == '''tf'''
           else MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING   )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase=None   ):
       a						:Tuple										=	{}
       if top_k is not None:
             a						:int										=	top_k
       return {}, {}, postprocess_params




 def __call__(		self ,  _lowerCamelCase ,  **_lowerCamelCase   ):
       return super().__call__(_lowerCamelCase ,  **_lowerCamelCase   )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase   ):
       a						:str										=	load_image(_lowerCamelCase   )
       a						:Any										=	self.image_processor(images=_lowerCamelCase ,  return_tensors=self.framework   )
       return model_inputs




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase   ):
       a						:List[str]										=	self.model(**_lowerCamelCase   )
       return model_outputs




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase=5   ):
       if top_k > self.model.config.num_labels:
             a						:List[Any]										=	self.model.config.num_labels

       if self.framework == "pt":
             a						:int										=	model_outputs.logits.softmax(-1   )[0]
             a							,    a						:Union[str, Any]										=	probs.topk(_lowerCamelCase   )
       elif self.framework == "tf":
             a						:Optional[Any]										=	stable_softmax(model_outputs.logits ,  axis=-1   )[0]
             a						:Union[str, Any]										=	tf.math.top_k(_lowerCamelCase ,  k=_lowerCamelCase   )
             a							,    a						:Optional[int]										=	topk.values.numpy(), topk.indices.numpy()
       else:
             raise ValueError(F'''Unsupported framework: {self.framework}'''   )

       a						:Optional[int]										=	scores.tolist()
       a						:str										=	ids.tolist()
       return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(_lowerCamelCase ,  _lowerCamelCase   )]









import os
import re
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


snake_case    :   List[str]	    =					logging.get_logger(__name__)

snake_case    :   Optional[Any]	    =					{
    '''vocab_file''': '''vocab.txt''',
    '''merges_file''': '''bpe.codes''',
}

snake_case    :   str	    =					{
    '''vocab_file''': {
        '''vinai/phobert-base''': '''https://huggingface.co/vinai/phobert-base/resolve/main/vocab.txt''',
        '''vinai/phobert-large''': '''https://huggingface.co/vinai/phobert-large/resolve/main/vocab.txt''',
    },
    '''merges_file''': {
        '''vinai/phobert-base''': '''https://huggingface.co/vinai/phobert-base/resolve/main/bpe.codes''',
        '''vinai/phobert-large''': '''https://huggingface.co/vinai/phobert-large/resolve/main/bpe.codes''',
    },
}

snake_case    :   List[Any]	    =					{
    '''vinai/phobert-base''': 2_56,
    '''vinai/phobert-large''': 2_56,
}
def     __lowerCamelCase						(			UpperCAmelCase_						:		List[str]						):




      """simple docstring"""





      a						:Union[str, Any]										=	set()
      a						:str										=	word[0]
      for char in word[1:]:
            pairs.add((prev_char, char)						)
            a						:Optional[int]										=	char

      a						:Optional[int]										=	set(UpperCAmelCase_						)
      return pairs







class 		_snake_case  (				_snake_case							):
 SCREAMING_SNAKE_CASE__				=	VOCAB_FILES_NAMES
 SCREAMING_SNAKE_CASE__				=	PRETRAINED_VOCAB_FILES_MAP
 SCREAMING_SNAKE_CASE__				=	PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES




 def __init__(		self ,  _lowerCamelCase ,  _lowerCamelCase ,  _lowerCamelCase="<s>" ,  _lowerCamelCase="</s>" ,  _lowerCamelCase="</s>" ,  _lowerCamelCase="<s>" ,  _lowerCamelCase="<unk>" ,  _lowerCamelCase="<pad>" ,  _lowerCamelCase="<mask>" ,  **_lowerCamelCase ,  ):
       super().__init__(
           bos_token=_lowerCamelCase ,  eos_token=_lowerCamelCase ,  unk_token=_lowerCamelCase ,  sep_token=_lowerCamelCase ,  cls_token=_lowerCamelCase ,  pad_token=_lowerCamelCase ,  mask_token=_lowerCamelCase ,  **_lowerCamelCase ,  )

       a						:Optional[Any]										=	vocab_file
       a						:Optional[Any]										=	merges_file

       a						:Any										=	{}
       a						:Any										=	0
       a						:int										=	1
       a						:Union[str, Any]										=	2
       a						:List[Any]										=	3

       self.add_from_file(_lowerCamelCase   )

       a						:List[str]										=	{v: k for k, v in self.encoder.items()}

       with open(_lowerCamelCase ,  encoding='''utf-8'''   ) as merges_handle:
             a						:List[str]										=	merges_handle.read().split('''\n'''   )[:-1]
       a						:Any										=	[tuple(merge.split()[:-1]   ) for merge in merges]
       a						:str										=	dict(zip(_lowerCamelCase ,  range(len(_lowerCamelCase   )   )   )   )
       a						:str										=	{}




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase = None   ):

       if token_ids_a is None:
             return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
       a						:Union[str, Any]										=	[self.cls_token_id]
       a						:Tuple										=	[self.sep_token_id]
       return cls + token_ids_a + sep + sep + token_ids_a + sep




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase = None ,  _lowerCamelCase = False   ):

       if already_has_special_tokens:
             return super().get_special_tokens_mask(
                 token_ids_a=_lowerCamelCase ,  token_ids_a=_lowerCamelCase ,  already_has_special_tokens=_lowerCamelCase   )

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




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase = None   ):
       a						:Optional[int]										=	[self.sep_token_id]
       a						:Optional[Any]										=	[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]




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




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




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase   ):
       if token in self.cache:
             return self.cache[token]
       a						:Optional[int]										=	tuple(_lowerCamelCase   )
       a						:List[str]										=	tuple(list(word[:-1]   ) + [word[-1] + '''</w>''']   )
       a						:Union[str, Any]										=	get_pairs(_lowerCamelCase   )

       if not pairs:
             return token

       while True:
             a						:Optional[Any]										=	min(_lowerCamelCase ,  key=lambda _lowerCamelCase   : self.bpe_ranks.get(_lowerCamelCase ,  float('''inf'''   )   )   )
             if bigram not in self.bpe_ranks:
                   break
             a							,    a						:Dict										=	bigram
             a						:Union[str, Any]										=	[]
             a						:int										=	0
             while i < len(_lowerCamelCase   ):
                   try:
                         a						:Optional[Any]										=	word.index(_lowerCamelCase ,  _lowerCamelCase   )
                   except ValueError:
                         new_word.extend(word[i:]   )
                         break
                   else:
                         new_word.extend(word[i:j]   )
                         a						:Union[str, Any]										=	j

                   if word[i] == first and i < len(_lowerCamelCase   ) - 1 and word[i + 1] == second:
                         new_word.append(first + second   )
                         i += 2
                   else:
                         new_word.append(word[i]   )
                         i += 1
             a						:Union[str, Any]										=	tuple(_lowerCamelCase   )
             a						:int										=	new_word
             if len(_lowerCamelCase   ) == 1:
                   break
             else:
                   a						:List[str]										=	get_pairs(_lowerCamelCase   )
       a						:Union[str, Any]										=	'''@@ '''.join(_lowerCamelCase   )
       a						:Dict										=	word[:-4]
       a						:Any										=	word
       return word




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase   ):
       a						:Union[str, Any]										=	[]

       a						:str										=	re.findall(R'''\S+\n?''' ,  _lowerCamelCase   )

       for token in words:
             split_tokens.extend(list(self.bpe(_lowerCamelCase   ).split(''' '''   )   )   )
       return split_tokens




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase   ):
       return self.encoder.get(_lowerCamelCase ,  self.encoder.get(self.unk_token   )   )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase   ):
       return self.decoder.get(_lowerCamelCase ,  self.unk_token   )




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase   ):
       a						:Optional[int]										=	''' '''.join(_lowerCamelCase   ).replace('''@@ ''' ,  ''''''   ).strip()
       return out_string




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase ,  _lowerCamelCase = None   ):
       if not os.path.isdir(_lowerCamelCase   ):
             logger.error(F'''Vocabulary path ({save_directory}) should be a directory'''   )
             return
       a						:Tuple										=	os.path.join(
           _lowerCamelCase ,  (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']   )
       a						:Optional[int]										=	os.path.join(
           _lowerCamelCase ,  (filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''merges_file''']   )

       if os.path.abspath(self.vocab_file   ) != os.path.abspath(_lowerCamelCase   ):
             copyfile(self.vocab_file ,  _lowerCamelCase   )

       if os.path.abspath(self.merges_file   ) != os.path.abspath(_lowerCamelCase   ):
             copyfile(self.merges_file ,  _lowerCamelCase   )

       return out_vocab_file, out_merge_file




 def 	SCREAMING_SNAKE_CASE__    (		self ,  _lowerCamelCase   ):
       if isinstance(_lowerCamelCase ,  _lowerCamelCase   ):
             try:
                   with open(_lowerCamelCase ,  '''r''' ,  encoding='''utf-8'''   ) as fd:
                         self.add_from_file(_lowerCamelCase   )
             except FileNotFoundError as fnfe:
                   raise fnfe
             except UnicodeError:
                   raise Exception(F'''Incorrect encoding detected in {f}, please rebuild the dataset'''   )
             return

       a						:str										=	f.readlines()
       for lineTmp in lines:
             a						:Tuple										=	lineTmp.strip()
             a						:int										=	line.rfind(''' '''   )
             if idx == -1:
                   raise ValueError('''Incorrect dictionary format, expected \'<token> <cnt>\''''   )
             a						:Tuple										=	line[:idx]
             a						:Tuple										=	len(self.encoder   )





