






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

import sentencepiece as spm

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


snake_case    				=		logging.get_logger(__name__)

snake_case    				=		"""▁"""

snake_case    				=		{"""vocab_file""": """sentencepiece.bpe.model"""}

snake_case    				=		{
    """vocab_file""": {
        """facebook/mbart-large-50-one-to-many-mmt""": (
            """https://huggingface.co/facebook/mbart-large-50-one-to-many-mmt/resolve/main/sentencepiece.bpe.model"""
        ),
    }
}

snake_case    				=		{
    """facebook/mbart-large-50-one-to-many-mmt""": 1_024,
}

# fmt: off
snake_case    				=		["""ar_AR""", """cs_CZ""", """de_DE""", """en_XX""", """es_XX""", """et_EE""", """fi_FI""", """fr_XX""", """gu_IN""", """hi_IN""", """it_IT""", """ja_XX""", """kk_KZ""", """ko_KR""", """lt_LT""", """lv_LV""", """my_MM""", """ne_NP""", """nl_XX""", """ro_RO""", """ru_RU""", """si_LK""", """tr_TR""", """vi_VN""", """zh_CN""", """af_ZA""", """az_AZ""", """bn_IN""", """fa_IR""", """he_IL""", """hr_HR""", """id_ID""", """ka_GE""", """km_KH""", """mk_MK""", """ml_IN""", """mn_MN""", """mr_IN""", """pl_PL""", """ps_AF""", """pt_XX""", """sv_SE""", """sw_KE""", """ta_IN""", """te_IN""", """th_TH""", """tl_XX""", """uk_UA""", """ur_PK""", """xh_ZA""", """gl_ES""", """sl_SI"""]


class  SCREAMING_SNAKE_CASE			(			lowerCAmelCase					):
     '''simple docstring'''


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

     UpperCamelCase_							:		List[int]			=	[]
     UpperCamelCase_							:		List[int]			=	[]


     def __init__(				self       :	Optional[int]					, UpperCAmelCase_       :	Any					, UpperCAmelCase_       :	str=None					, UpperCAmelCase_       :	List[Any]=None					, UpperCAmelCase_       :	str="</s>"					, UpperCAmelCase_       :	Any="</s>"					, UpperCAmelCase_       :	Optional[int]="<s>"					, UpperCAmelCase_       :	Any="<unk>"					, UpperCAmelCase_       :	List[str]="<pad>"					, UpperCAmelCase_       :	Union[str, Any]="<mask>"					, UpperCAmelCase_       :	Optional[Dict[str, Any]] = None					, **UpperCAmelCase_       :	Dict					, ):
       # Mask token behave like a normal word, i.e. include the space before it
       SCREAMING_SNAKE_CASE       :      str							=    AddedToken(UpperCAmelCase_					, lstrip=UpperCAmelCase_					, rstrip=UpperCAmelCase_      ) if isinstance(UpperCAmelCase_					, UpperCAmelCase_      ) else mask_token

       SCREAMING_SNAKE_CASE       :      int							=    {} if sp_model_kwargs is None else sp_model_kwargs

       SCREAMING_SNAKE_CASE       :      Any							=    kwargs.get("additional_special_tokens"					, []      )
       kwargs["additional_special_tokens"] += [
           code for code in FAIRSEQ_LANGUAGE_CODES if code not in kwargs["additional_special_tokens"]
       ]

       super().__init__(
           src_lang=UpperCAmelCase_					, tgt_lang=UpperCAmelCase_					, eos_token=UpperCAmelCase_					, unk_token=UpperCAmelCase_					, sep_token=UpperCAmelCase_					, cls_token=UpperCAmelCase_					, pad_token=UpperCAmelCase_					, mask_token=UpperCAmelCase_					, sp_model_kwargs=self.sp_model_kwargs					, **UpperCAmelCase_					, )

       SCREAMING_SNAKE_CASE       :      str							=    spm.SentencePieceProcessor(**self.sp_model_kwargs      )
       self.sp_model.Load(str(UpperCAmelCase_      )      )
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    vocab_file

       # Original fairseq vocab and spm vocab must be "aligned":
       # Vocab    |    0    |    1    |   2    |    3    |  4  |  5  |  6  |   7   |   8   |  9
       # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
       # fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's'   | '▁de' | '-'
       # spm      | '<unk>' | '<s>'   | '</s>' | ','     | '.' | '▁' | 's' | '▁de' | '-'   | '▁a'

       # Mimic fairseq token-to-id alignment for the first 4 token
       SCREAMING_SNAKE_CASE       :      Tuple							=    {"<s>": 0, "<pad>": 1, "</s>": 2, "<unk>": 3}

       # The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
       SCREAMING_SNAKE_CASE       :      Tuple							=    1

       SCREAMING_SNAKE_CASE       :      int							=    len(self.sp_model      )
       SCREAMING_SNAKE_CASE       :      List[Any]							=    {
           code: self.sp_model_size + i + self.fairseq_offset for i, code in enumerate(UpperCAmelCase_      )
       }
       SCREAMING_SNAKE_CASE       :      List[Any]							=    {v: k for k, v in self.lang_code_to_id.items()}
       SCREAMING_SNAKE_CASE       :      Tuple							=    len(self.sp_model      ) + len(self.lang_code_to_id      ) + self.fairseq_offset

       self.fairseq_tokens_to_ids.update(self.lang_code_to_id      )
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    {v: k for k, v in self.fairseq_tokens_to_ids.items()}

       SCREAMING_SNAKE_CASE       :      str							=    src_lang if src_lang is not None else "en_XX"
       SCREAMING_SNAKE_CASE       :      Any							=    self.lang_code_to_id[self._src_lang]
       SCREAMING_SNAKE_CASE       :      str							=    tgt_lang
       self.set_src_lang_special_tokens(self._src_lang      )


     @property
     def 				_A       (				self       :	str      ):
       return len(self.sp_model      ) + len(self.lang_code_to_id      ) + self.fairseq_offset + 1  # Plus 1 for the mask token


     @property
     def 				_A       (				self       :	Optional[int]      ):
       return self._src_lang


     @src_lang.setter
     def 				_A       (				self       :	List[str]					, UpperCAmelCase_       :	str      ):
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    new_src_lang
       self.set_src_lang_special_tokens(self._src_lang      )


     def __getstate__(				self       :	List[str]      ):
       SCREAMING_SNAKE_CASE       :      str							=    self.__dict__.copy()
       SCREAMING_SNAKE_CASE       :      Tuple							=    None
       return state


     def __setstate__(				self       :	Union[str, Any]					, UpperCAmelCase_       :	Dict      ):
       SCREAMING_SNAKE_CASE       :      int							=    d

       # for backward compatibility
       if not hasattr(self					, "sp_model_kwargs"      ):
         SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    {}

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


     def 				_A       (				self       :	List[Any]      ):
       SCREAMING_SNAKE_CASE       :      Any							=    {self.convert_ids_to_tokens(UpperCAmelCase_      ): i for i in range(self.vocab_size      )}
       vocab.update(self.added_tokens_encoder      )
       return vocab


     def 				_A       (				self       :	Optional[Any]					, UpperCAmelCase_       :	str      ):
       return self.sp_model.encode(UpperCAmelCase_					, out_type=UpperCAmelCase_      )


     def 				_A       (				self       :	str					, UpperCAmelCase_       :	str      ):
       if token in self.fairseq_tokens_to_ids:
         return self.fairseq_tokens_to_ids[token]
       SCREAMING_SNAKE_CASE       :      int							=    self.sp_model.PieceToId(UpperCAmelCase_      )

       # Need to return unknown token if the SP model returned 0
       return spm_id + self.fairseq_offset if spm_id else self.unk_token_id


     def 				_A       (				self       :	List[str]					, UpperCAmelCase_       :	int      ):
       if index in self.fairseq_ids_to_tokens:
         return self.fairseq_ids_to_tokens[index]
       return self.sp_model.IdToPiece(index - self.fairseq_offset      )


     def 				_A       (				self       :	Union[str, Any]					, UpperCAmelCase_       :	Tuple      ):
       SCREAMING_SNAKE_CASE       :      Dict							=    []
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    ""
       SCREAMING_SNAKE_CASE       :      List[str]							=    False
       for token in tokens:
         # make sure that special tokens are not decoded using sentencepiece model
         if token in self.all_special_tokens:
           if not prev_is_special:
             out_string += " "
           out_string += self.sp_model.decode(UpperCAmelCase_      ) + token
           SCREAMING_SNAKE_CASE       :      Any							=    True
           SCREAMING_SNAKE_CASE       :      List[Any]							=    []
         else:
           current_sub_tokens.append(UpperCAmelCase_      )
           SCREAMING_SNAKE_CASE       :      Tuple							=    False
       out_string += self.sp_model.decode(UpperCAmelCase_      )
       return out_string.strip()


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

       if os.path.abspath(self.vocab_file      ) != os.path.abspath(UpperCAmelCase_      ) and os.path.isfile(self.vocab_file      ):
         copyfile(self.vocab_file					, UpperCAmelCase_      )
       elif not os.path.isfile(self.vocab_file      ):
         with open(UpperCAmelCase_					, "wb"      ) as fi:
           SCREAMING_SNAKE_CASE       :      List[Any]							=    self.sp_model.serialized_model_proto()
           fi.write(UpperCAmelCase_      )

       return (out_vocab_file,)


     def 				_A       (				self       :	str					, UpperCAmelCase_       :	List[int]					, UpperCAmelCase_       :	Optional[List[int]] = None					, UpperCAmelCase_       :	bool = False      ):

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

       SCREAMING_SNAKE_CASE       :      str							=    [1] * len(self.prefix_tokens      )
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    [1] * len(self.suffix_tokens      )
       if token_ids_a is None:
         return prefix_ones + ([0] * len(UpperCAmelCase_      )) + suffix_ones
       return prefix_ones + ([0] * len(UpperCAmelCase_      )) + ([0] * len(UpperCAmelCase_      )) + suffix_ones


     def 				_A       (				self       :	str					, UpperCAmelCase_       :	List[int]					, UpperCAmelCase_       :	Optional[List[int]] = None      ):
       if token_ids_a is None:
         return self.prefix_tokens + token_ids_a + self.suffix_tokens
       # We don't expect to process pairs, but leave the pair logic for API consistency
       return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens


     def 				_A       (				self       :	Any					, UpperCAmelCase_       :	str					, UpperCAmelCase_       :	str					, UpperCAmelCase_       :	Optional[str]					, UpperCAmelCase_       :	Optional[str]					, **UpperCAmelCase_       :	List[str]      ):
       if src_lang is None or tgt_lang is None:
         raise ValueError("Translation requires a `src_lang` and a `tgt_lang` for this model"      )
       SCREAMING_SNAKE_CASE       :      Dict							=    src_lang
       SCREAMING_SNAKE_CASE       :      List[str]							=    self(UpperCAmelCase_					, add_special_tokens=UpperCAmelCase_					, return_tensors=UpperCAmelCase_					, **UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    self.convert_tokens_to_ids(UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      str							=    tgt_lang_id
       return inputs


     def 				_A       (				self       :	Tuple					, UpperCAmelCase_       :	List[str]					, UpperCAmelCase_       :	str = "en_XX"					, UpperCAmelCase_       :	Optional[List[str]] = None					, UpperCAmelCase_       :	str = "ro_RO"					, **UpperCAmelCase_       :	Optional[Any]					, ):
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    src_lang
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    tgt_lang
       return super().prepare_seqaseq_batch(UpperCAmelCase_					, UpperCAmelCase_					, **UpperCAmelCase_      )


     def 				_A       (				self       :	str      ):
       return self.set_src_lang_special_tokens(self.src_lang      )


     def 				_A       (				self       :	int      ):
       return self.set_tgt_lang_special_tokens(self.tgt_lang      )


     def 				_A       (				self       :	Optional[int]					, UpperCAmelCase_       :	str      ):
       SCREAMING_SNAKE_CASE       :      List[Any]							=    self.lang_code_to_id[src_lang]
       SCREAMING_SNAKE_CASE       :      Dict							=    [self.cur_lang_code_id]
       SCREAMING_SNAKE_CASE       :      Tuple							=    [self.eos_token_id]






     def 				_A       (				self       :	Union[str, Any]					, UpperCAmelCase_       :	str      ):
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    self.lang_code_to_id[tgt_lang]
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    [self.cur_lang_code_id]
       SCREAMING_SNAKE_CASE       :      Tuple							=    [self.eos_token_id]














import qiskit


def   lowerCamelCase__			(     lowercase						,     lowercase				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      List[str]							=    qiskit.Aer.get_backend("aer_simulator"				)

  # Create a Quantum Circuit acting on the q register
  SCREAMING_SNAKE_CASE       :      Dict							=    qiskit.QuantumCircuit(lowercase						,     lowercase				)

  # Map the quantum measurement to the classical bits
  circuit.measure([0]						,     [0]				)

  # Execute the circuit on the simulator
  SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    qiskit.execute(lowercase						,     lowercase						,     shots=1000				)

  # Return the histogram data of the results of the experiment.
  return job.result().get_counts(lowercase				)


if __name__ == "__main__":
   print(F"""Total count for various states are: {single_qubit_measure(1, 1)}""")






