


'''simple docstring'''






import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

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


lowercase							=logging.get_logger(__name__)

lowercase							={'vocab_file': 'spm_char.model'}

lowercase							={
    'vocab_file': {
        'microsoft/speecht5_asr': 'https://huggingface.co/microsoft/speecht5_asr/resolve/main/spm_char.model',
        'microsoft/speecht5_tts': 'https://huggingface.co/microsoft/speecht5_tts/resolve/main/spm_char.model',
        'microsoft/speecht5_vc': 'https://huggingface.co/microsoft/speecht5_vc/resolve/main/spm_char.model',
    }
}

lowercase							={
    'microsoft/speecht5_asr': 1024,
    'microsoft/speecht5_tts': 1024,
    'microsoft/speecht5_vc': 1024,
}






class  __magic_name__							(		lowerCAmelCase    ):
       UpperCAmelCase										=VOCAB_FILES_NAMES
       UpperCAmelCase										=PRETRAINED_VOCAB_FILES_MAP
       UpperCAmelCase										=PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       UpperCAmelCase										=["input_ids", "attention_mask"]






       def __init__(      self  ,							snake_case  ,							snake_case="<s>"  ,							snake_case="</s>"  ,							snake_case="<unk>"  ,							snake_case="<pad>"  ,							snake_case = None  ,							**snake_case  ,							)						->  None:




          '''simple docstring'''
          _UpperCAmelCase       :       List[Any]							   ={} if sp_model_kwargs is None else sp_model_kwargs

          super().__init__(
              bos_token=snake_case  ,							eos_token=snake_case  ,							unk_token=snake_case  ,							pad_token=snake_case  ,							sp_model_kwargs=self.sp_model_kwargs  ,							**snake_case  ,							)

          _UpperCAmelCase       :       Any							   =vocab_file

          _UpperCAmelCase       :       Dict							   =spm.SentencePieceProcessor(**self.sp_model_kwargs)
          self.sp_model.Load(snake_case)






       @property
       def       lowerCAmelCase		(      self)						->  Any:




          '''simple docstring'''
          return self.sp_model.get_piece_size()






       def       lowerCAmelCase		(      self)						->  Any:




          '''simple docstring'''
          _UpperCAmelCase       :       Dict							   ={self.convert_ids_to_tokens(snake_case): i for i in range(self.vocab_size)}
          vocab.update(self.added_tokens_encoder)
          return vocab






       def __getstate__(      self)						->  Any:




          '''simple docstring'''
          _UpperCAmelCase       :       Dict							   =self.__dict__.copy()
          _UpperCAmelCase       :       Dict							   =None
          return state






       def __setstate__(      self  ,							snake_case)						->  Tuple:




          '''simple docstring'''
          _UpperCAmelCase       :       str							   =d

          # for backward compatibility
          if not hasattr(self  ,							'sp_model_kwargs'):
             _UpperCAmelCase       :       Any							   ={}

          _UpperCAmelCase       :       List[Any]							   =spm.SentencePieceProcessor(**self.sp_model_kwargs)
          self.sp_model.Load(self.vocab_file)






       def       lowerCAmelCase		(      self  ,							snake_case)						->  List[str]:




          '''simple docstring'''
          return self.sp_model.encode(snake_case  ,							out_type=snake_case)






       def       lowerCAmelCase		(      self  ,							snake_case)						->  Dict:




          '''simple docstring'''
          return self.sp_model.piece_to_id(snake_case)






       def       lowerCAmelCase		(      self  ,							snake_case)						->  List[str]:




          '''simple docstring'''
          _UpperCAmelCase       :       Union[str, Any]							   =self.sp_model.IdToPiece(snake_case)
          return token






       def       lowerCAmelCase		(      self  ,							snake_case)						->  int:




          '''simple docstring'''
          _UpperCAmelCase       :       Tuple							   =[]
          _UpperCAmelCase       :       List[Any]							   =''
          for token in tokens:
             # make sure that special tokens are not decoded using sentencepiece model
             if token in self.all_special_tokens:
                out_string += self.sp_model.decode(snake_case) + token
                _UpperCAmelCase       :       Tuple							   =[]
             else:
                current_sub_tokens.append(snake_case)
          out_string += self.sp_model.decode(snake_case)
          return out_string.strip()






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case=None)						->  List[int]:




          '''simple docstring'''
          if token_ids_a is None:
             return token_ids_a + [self.eos_token_id]
          # We don't expect to process pairs, but leave the pair logic for API consistency
          return token_ids_a + token_ids_a + [self.eos_token_id]






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case = None  ,							snake_case = False)						->  List[int]:




          '''simple docstring'''
          if already_has_special_tokens:
             return super().get_special_tokens_mask(
                 token_ids_a=snake_case  ,							token_ids_a=snake_case  ,							already_has_special_tokens=snake_case)

          _UpperCAmelCase       :       List[Any]							   =[1]
          if token_ids_a is None:
             return ([0] * len(snake_case)) + suffix_ones
          return ([0] * len(snake_case)) + ([0] * len(snake_case)) + suffix_ones






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case = None)						->  Tuple[str]:




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

          if os.path.abspath(self.vocab_file) != os.path.abspath(snake_case) and os.path.isfile(self.vocab_file):
             copyfile(self.vocab_file  ,							snake_case)
          elif not os.path.isfile(self.vocab_file):
             with open(snake_case  ,							'wb') as fi:
                _UpperCAmelCase       :       Optional[int]							   =self.sp_model.serialized_model_proto()
                fi.write(snake_case)

          return (out_vocab_file,)





'''simple docstring'''






from collections import UserDict
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_torch_available():
 from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING

if is_tf_available():
 from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
 from ..tf_utils import stable_softmax

lowercase							=logging.get_logger(__name__)






@add_end_docstrings(lowerCAmelCase    )
class  __magic_name__							(		lowerCAmelCase    ):






       def __init__(      self  ,							**snake_case)						->  Optional[int]:




          '''simple docstring'''
          super().__init__(**snake_case)

          requires_backends(self  ,							'vision')
          self.check_model_type(
              TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
              if self.framework == 'tf'
              else MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING)






       def __call__(      self  ,							snake_case  ,							**snake_case)						->  str:




          '''simple docstring'''
          return super().__call__(snake_case  ,							**snake_case)






       def       lowerCAmelCase		(      self  ,							**snake_case)						->  int:




          '''simple docstring'''
          _UpperCAmelCase       :       str							   ={}
          if "candidate_labels" in kwargs:
             _UpperCAmelCase       :       Union[str, Any]							   =kwargs['candidate_labels']
          if "hypothesis_template" in kwargs:
             _UpperCAmelCase       :       List[Any]							   =kwargs['hypothesis_template']

          return preprocess_params, {}, {}






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case=None  ,							snake_case="This is a photo of {}.")						->  Any:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[Any]							   =load_image(snake_case)
          _UpperCAmelCase       :       Union[str, Any]							   =self.image_processor(images=[image]  ,							return_tensors=self.framework)
          _UpperCAmelCase       :       Union[str, Any]							   =candidate_labels
          _UpperCAmelCase       :       List[Any]							   =[hypothesis_template.format(snake_case) for x in candidate_labels]
          _UpperCAmelCase       :       str							   =self.tokenizer(snake_case  ,							return_tensors=self.framework  ,							padding=snake_case)
          _UpperCAmelCase       :       Any							   =[text_inputs]
          return inputs






       def       lowerCAmelCase		(      self  ,							snake_case)						->  str:




          '''simple docstring'''
          _UpperCAmelCase       :       List[str]							   =model_inputs.pop('candidate_labels')
          _UpperCAmelCase       :       Tuple							   =model_inputs.pop('text_inputs')
          if isinstance(text_inputs[0]  ,							snake_case):
             _UpperCAmelCase       :       Any							   =text_inputs[0]
          else:
             # Batching case.
             _UpperCAmelCase       :       str							   =text_inputs[0][0]

          _UpperCAmelCase       :       Any							   =self.model(**snake_case  ,							**snake_case)

          _UpperCAmelCase       :       List[str]							   ={
              'candidate_labels': candidate_labels,
              'logits': outputs.logits_per_image,
          }
          return model_outputs






       def       lowerCAmelCase		(      self  ,							snake_case)						->  Optional[int]:




          '''simple docstring'''
          _UpperCAmelCase       :       str							   =model_outputs.pop('candidate_labels')
          _UpperCAmelCase       :       Union[str, Any]							   =model_outputs['logits'][0]
          if self.framework == "pt":
             _UpperCAmelCase       :       Dict							   =logits.softmax(dim=-1).squeeze(-1)
             _UpperCAmelCase       :       Union[str, Any]							   =probs.tolist()
             if not isinstance(snake_case  ,							snake_case):
                _UpperCAmelCase       :       Union[str, Any]							   =[scores]
          elif self.framework == "tf":
             _UpperCAmelCase       :       Dict							   =stable_softmax(snake_case  ,							axis=-1)
             _UpperCAmelCase       :       str							   =probs.numpy().tolist()
          else:
             raise ValueError(f"Unsupported framework: {self.framework}")

          _UpperCAmelCase       :       List[str]							   =[
              {'score': score, 'label': candidate_label}
              for score, candidate_label in sorted(zip(snake_case  ,							snake_case)  ,							key=lambda snake_case: -x[0])
          ]
          return result

