





import re
import string
from collections import Counter

import sacrebleu
import sacremoses
from packaging import version

import datasets


SCREAMING_SNAKE_CASE_		     = """
@inproceedings{xu-etal-2016-optimizing,
    title = {Optimizing Statistical Machine Translation for Text Simplification},
    authors={Xu, Wei and Napoles, Courtney and Pavlick, Ellie and Chen, Quanze and Callison-Burch, Chris},
    journal = {Transactions of the Association for Computational Linguistics},
    volume = {4},
    year={2016},
    url = {https://www.aclweb.org/anthology/Q16-1029},
    pages = {401--415
},
@inproceedings{post-2018-call,
    title = \"A Call for Clarity in Reporting {BLEU} Scores\",
    author = \"Post, Matt\",
    booktitle = \"Proceedings of the Third Conference on Machine Translation: Research Papers\",
    month = oct,
    year = \"2018\",
    address = \"Belgium, Brussels\",
    publisher = \"Association for Computational Linguistics\",
    url = \"https://www.aclweb.org/anthology/W18-6319\",
    pages = \"186--191\",
}
"""

SCREAMING_SNAKE_CASE_		     = """\
WIKI_SPLIT is the combination of three metrics SARI, EXACT and SACREBLEU
It can be used to evaluate the quality of machine-generated texts.
"""


SCREAMING_SNAKE_CASE_		     = """
Calculates sari score (between 0 and 100) given a list of source and predicted
sentences, and a list of lists of reference sentences. It also computes the BLEU score as well as the exact match score.
Args:
    sources: list of source sentences where each sentence should be a string.
    predictions: list of predicted sentences where each sentence should be a string.
    references: list of lists of reference sentences where each sentence should be a string.
Returns:
    sari: sari score
    sacrebleu: sacrebleu score
    exact: exact score

Examples:
    >>> sources=[\"About 95 species are currently accepted .\"]
    >>> predictions=[\"About 95 you now get in .\"]
    >>> references=[[\"About 95 species are currently known .\"]]
    >>> wiki_split = datasets.load_metric(\"wiki_split\")
    >>> results = wiki_split.compute(sources=sources, predictions=predictions, references=references)
    >>> print(results)
    {'sari': 21.805555555555557, 'sacrebleu': 14.535768424205482, 'exact': 0.0}
"""



def      __lowercase     (   _SCREAMING_SNAKE_CASE			)				->     Tuple:


      '''simple docstring'''


      def remove_articles(_SCREAMING_SNAKE_CASE			):
            SCREAMING_SNAKE_CASE	=		re.compile(r"""\b(a|an|the)\b"""				,		re.UNICODE			)
            return re.sub(_SCREAMING_SNAKE_CASE				,		""" """				,		_SCREAMING_SNAKE_CASE			)

      def white_space_fix(_SCREAMING_SNAKE_CASE			):
            return " ".join(text.split()			)

      def remove_punc(_SCREAMING_SNAKE_CASE			):
            SCREAMING_SNAKE_CASE	=		set(string.punctuation			)
            return "".join(ch for ch in text if ch not in exclude			)

      def lower(_SCREAMING_SNAKE_CASE			):
            return text.lower()

      return white_space_fix(remove_articles(remove_punc(lower(_SCREAMING_SNAKE_CASE			)			)			)			)



def      __lowercase     (   _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)				->     Tuple:


      '''simple docstring'''


      return int(normalize_answer(_SCREAMING_SNAKE_CASE			) == normalize_answer(_SCREAMING_SNAKE_CASE			)			)



def      __lowercase     (   _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)				->     Optional[Any]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE	=		[any(compute_exact(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			) for ref in refs			) for pred, refs in zip(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)]
      return (sum(_SCREAMING_SNAKE_CASE			) / len(_SCREAMING_SNAKE_CASE			)) * 1_00



def      __lowercase     (   _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)				->     Optional[int]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE	=		[rgram for rgrams in rgramslist for rgram in rgrams]
      SCREAMING_SNAKE_CASE	=		Counter(_SCREAMING_SNAKE_CASE			)

      SCREAMING_SNAKE_CASE	=		Counter(_SCREAMING_SNAKE_CASE			)
      SCREAMING_SNAKE_CASE	=		Counter()
      for sgram, scount in sgramcounter.items():
            SCREAMING_SNAKE_CASE	=		scount * numref

      SCREAMING_SNAKE_CASE	=		Counter(_SCREAMING_SNAKE_CASE			)
      SCREAMING_SNAKE_CASE	=		Counter()
      for cgram, ccount in cgramcounter.items():
            SCREAMING_SNAKE_CASE	=		ccount * numref

      # KEEP
      SCREAMING_SNAKE_CASE	=		sgramcounter_rep & cgramcounter_rep
      SCREAMING_SNAKE_CASE	=		keepgramcounter_rep & rgramcounter
      SCREAMING_SNAKE_CASE	=		sgramcounter_rep & rgramcounter

      SCREAMING_SNAKE_CASE	=		0
      SCREAMING_SNAKE_CASE	=		0
      for keepgram in keepgramcountergood_rep:
            keeptmpscorea += keepgramcountergood_rep[keepgram] / keepgramcounter_rep[keepgram]
            # Fix an alleged bug [2] in the keep score computation.
            # keeptmpscore2 += keepgramcountergood_rep[keepgram] / keepgramcounterall_rep[keepgram]
            keeptmpscorea += keepgramcountergood_rep[keepgram]
      # Define 0/0=1 instead of 0 to give higher scores for predictions that match
      #      a target exactly.
      SCREAMING_SNAKE_CASE	=		1
      SCREAMING_SNAKE_CASE	=		1
      if len(_SCREAMING_SNAKE_CASE			) > 0:
            SCREAMING_SNAKE_CASE	=		keeptmpscorea / len(_SCREAMING_SNAKE_CASE			)
      if len(_SCREAMING_SNAKE_CASE			) > 0:
            # Fix an alleged bug [2] in the keep score computation.
            # keepscore_recall = keeptmpscore2 / len(keepgramcounterall_rep)
            SCREAMING_SNAKE_CASE	=		keeptmpscorea / sum(keepgramcounterall_rep.values()			)
      SCREAMING_SNAKE_CASE	=		0
      if keepscore_precision > 0 or keepscore_recall > 0:
            SCREAMING_SNAKE_CASE	=		2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall)

      # DELETION
      SCREAMING_SNAKE_CASE	=		sgramcounter_rep - cgramcounter_rep
      SCREAMING_SNAKE_CASE	=		delgramcounter_rep - rgramcounter
      SCREAMING_SNAKE_CASE	=		sgramcounter_rep - rgramcounter
      SCREAMING_SNAKE_CASE	=		0
      SCREAMING_SNAKE_CASE	=		0
      for delgram in delgramcountergood_rep:
            deltmpscorea += delgramcountergood_rep[delgram] / delgramcounter_rep[delgram]
            deltmpscorea += delgramcountergood_rep[delgram] / delgramcounterall_rep[delgram]
      # Define 0/0=1 instead of 0 to give higher scores for predictions that match
      # a target exactly.
      SCREAMING_SNAKE_CASE	=		1
      if len(_SCREAMING_SNAKE_CASE			) > 0:
            SCREAMING_SNAKE_CASE	=		deltmpscorea / len(_SCREAMING_SNAKE_CASE			)

      # ADDITION
      SCREAMING_SNAKE_CASE	=		set(_SCREAMING_SNAKE_CASE			) - set(_SCREAMING_SNAKE_CASE			)
      SCREAMING_SNAKE_CASE	=		set(_SCREAMING_SNAKE_CASE			) & set(_SCREAMING_SNAKE_CASE			)
      SCREAMING_SNAKE_CASE	=		set(_SCREAMING_SNAKE_CASE			) - set(_SCREAMING_SNAKE_CASE			)

      SCREAMING_SNAKE_CASE	=		0
      for addgram in addgramcountergood:
            addtmpscore += 1

      # Define 0/0=1 instead of 0 to give higher scores for predictions that match
      # a target exactly.
      SCREAMING_SNAKE_CASE	=		1
      SCREAMING_SNAKE_CASE	=		1
      if len(_SCREAMING_SNAKE_CASE			) > 0:
            SCREAMING_SNAKE_CASE	=		addtmpscore / len(_SCREAMING_SNAKE_CASE			)
      if len(_SCREAMING_SNAKE_CASE			) > 0:
            SCREAMING_SNAKE_CASE	=		addtmpscore / len(_SCREAMING_SNAKE_CASE			)
      SCREAMING_SNAKE_CASE	=		0
      if addscore_precision > 0 or addscore_recall > 0:
            SCREAMING_SNAKE_CASE	=		2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall)

      return (keepscore, delscore_precision, addscore)



def      __lowercase     (   _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)				->     Optional[int]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE	=		len(_SCREAMING_SNAKE_CASE			)

      SCREAMING_SNAKE_CASE	=		ssent.split(""" """			)
      SCREAMING_SNAKE_CASE	=		csent.split(""" """			)
      SCREAMING_SNAKE_CASE	=		[]
      SCREAMING_SNAKE_CASE	=		[]
      SCREAMING_SNAKE_CASE	=		[]
      SCREAMING_SNAKE_CASE	=		[]
      SCREAMING_SNAKE_CASE	=		[]
      SCREAMING_SNAKE_CASE	=		[]

      SCREAMING_SNAKE_CASE	=		[]
      SCREAMING_SNAKE_CASE	=		[]
      SCREAMING_SNAKE_CASE	=		[]
      SCREAMING_SNAKE_CASE	=		[]
      for rsent in rsents:
            SCREAMING_SNAKE_CASE	=		rsent.split(""" """			)
            SCREAMING_SNAKE_CASE	=		[]
            SCREAMING_SNAKE_CASE	=		[]
            SCREAMING_SNAKE_CASE	=		[]
            ragramslist.append(_SCREAMING_SNAKE_CASE			)
            for i in range(0				,		len(_SCREAMING_SNAKE_CASE			) - 1			):
                  if i < len(_SCREAMING_SNAKE_CASE			) - 1:
                        SCREAMING_SNAKE_CASE	=		ragrams[i] + """ """ + ragrams[i + 1]
                        ragrams.append(_SCREAMING_SNAKE_CASE			)
                  if i < len(_SCREAMING_SNAKE_CASE			) - 2:
                        SCREAMING_SNAKE_CASE	=		ragrams[i] + """ """ + ragrams[i + 1] + """ """ + ragrams[i + 2]
                        ragrams.append(_SCREAMING_SNAKE_CASE			)
                  if i < len(_SCREAMING_SNAKE_CASE			) - 3:
                        SCREAMING_SNAKE_CASE	=		ragrams[i] + """ """ + ragrams[i + 1] + """ """ + ragrams[i + 2] + """ """ + ragrams[i + 3]
                        ragrams.append(_SCREAMING_SNAKE_CASE			)
            ragramslist.append(_SCREAMING_SNAKE_CASE			)
            ragramslist.append(_SCREAMING_SNAKE_CASE			)
            ragramslist.append(_SCREAMING_SNAKE_CASE			)

      for i in range(0				,		len(_SCREAMING_SNAKE_CASE			) - 1			):
            if i < len(_SCREAMING_SNAKE_CASE			) - 1:
                  SCREAMING_SNAKE_CASE	=		sagrams[i] + """ """ + sagrams[i + 1]
                  sagrams.append(_SCREAMING_SNAKE_CASE			)
            if i < len(_SCREAMING_SNAKE_CASE			) - 2:
                  SCREAMING_SNAKE_CASE	=		sagrams[i] + """ """ + sagrams[i + 1] + """ """ + sagrams[i + 2]
                  sagrams.append(_SCREAMING_SNAKE_CASE			)
            if i < len(_SCREAMING_SNAKE_CASE			) - 3:
                  SCREAMING_SNAKE_CASE	=		sagrams[i] + """ """ + sagrams[i + 1] + """ """ + sagrams[i + 2] + """ """ + sagrams[i + 3]
                  sagrams.append(_SCREAMING_SNAKE_CASE			)

      for i in range(0				,		len(_SCREAMING_SNAKE_CASE			) - 1			):
            if i < len(_SCREAMING_SNAKE_CASE			) - 1:
                  SCREAMING_SNAKE_CASE	=		cagrams[i] + """ """ + cagrams[i + 1]
                  cagrams.append(_SCREAMING_SNAKE_CASE			)
            if i < len(_SCREAMING_SNAKE_CASE			) - 2:
                  SCREAMING_SNAKE_CASE	=		cagrams[i] + """ """ + cagrams[i + 1] + """ """ + cagrams[i + 2]
                  cagrams.append(_SCREAMING_SNAKE_CASE			)
            if i < len(_SCREAMING_SNAKE_CASE			) - 3:
                  SCREAMING_SNAKE_CASE	=		cagrams[i] + """ """ + cagrams[i + 1] + """ """ + cagrams[i + 2] + """ """ + cagrams[i + 3]
                  cagrams.append(_SCREAMING_SNAKE_CASE			)

      ((SCREAMING_SNAKE_CASE),      (SCREAMING_SNAKE_CASE),      (SCREAMING_SNAKE_CASE))	=		SARIngram(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)
      ((SCREAMING_SNAKE_CASE),      (SCREAMING_SNAKE_CASE),      (SCREAMING_SNAKE_CASE))	=		SARIngram(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)
      ((SCREAMING_SNAKE_CASE),      (SCREAMING_SNAKE_CASE),      (SCREAMING_SNAKE_CASE))	=		SARIngram(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)
      ((SCREAMING_SNAKE_CASE),      (SCREAMING_SNAKE_CASE),      (SCREAMING_SNAKE_CASE))	=		SARIngram(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)
      SCREAMING_SNAKE_CASE	=		sum([keepascore, keepascore, keepascore, keepascore]			) / 4
      SCREAMING_SNAKE_CASE	=		sum([delascore, delascore, delascore, delascore]			) / 4
      SCREAMING_SNAKE_CASE	=		sum([addascore, addascore, addascore, addascore]			) / 4
      SCREAMING_SNAKE_CASE	=		(avgkeepscore + avgdelscore + avgaddscore) / 3
      return finalscore



def      __lowercase     (   _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE = True				,		_SCREAMING_SNAKE_CASE = "13a"				,		_SCREAMING_SNAKE_CASE = True			)				->     List[Any]:


      '''simple docstring'''


      if lowercase:
            SCREAMING_SNAKE_CASE	=		sentence.lower()

      if tokenizer in ["13a", "intl"]:
            if version.parse(sacrebleu.__version__			).major >= 2:
                  SCREAMING_SNAKE_CASE	=		sacrebleu.metrics.bleu._get_tokenizer(_SCREAMING_SNAKE_CASE			)()(_SCREAMING_SNAKE_CASE			)
            else:
                  SCREAMING_SNAKE_CASE	=		sacrebleu.TOKENIZERS[tokenizer]()(_SCREAMING_SNAKE_CASE			)
      elif tokenizer == "moses":
            SCREAMING_SNAKE_CASE	=		sacremoses.MosesTokenizer().tokenize(_SCREAMING_SNAKE_CASE				,		return_str=_SCREAMING_SNAKE_CASE				,		escape=_SCREAMING_SNAKE_CASE			)
      elif tokenizer == "penn":
            SCREAMING_SNAKE_CASE	=		sacremoses.MosesTokenizer().penn_tokenize(_SCREAMING_SNAKE_CASE				,		return_str=_SCREAMING_SNAKE_CASE			)
      else:
            SCREAMING_SNAKE_CASE	=		sentence

      if not return_str:
            SCREAMING_SNAKE_CASE	=		normalized_sent.split()

      return normalized_sent



def      __lowercase     (   _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			)				->     Tuple:


      '''simple docstring'''


      if not (len(_SCREAMING_SNAKE_CASE			) == len(_SCREAMING_SNAKE_CASE			) == len(_SCREAMING_SNAKE_CASE			)):
            raise ValueError("""Sources length must match predictions and references lengths."""			)
      SCREAMING_SNAKE_CASE	=		0
      for src, pred, refs in zip(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			):
            sari_score += SARIsent(normalize(_SCREAMING_SNAKE_CASE			)				,		normalize(_SCREAMING_SNAKE_CASE			)				,		[normalize(_SCREAMING_SNAKE_CASE			) for sent in refs]			)
      SCREAMING_SNAKE_CASE	=		sari_score / len(_SCREAMING_SNAKE_CASE			)
      return 1_00 * sari_score



def      __lowercase     (   _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE="exp"				,		_SCREAMING_SNAKE_CASE=None				,		_SCREAMING_SNAKE_CASE=False				,		_SCREAMING_SNAKE_CASE=False				,		_SCREAMING_SNAKE_CASE=False				,		)				->     Union[str, Any]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE	=		len(references[0]			)
      if any(len(_SCREAMING_SNAKE_CASE			) != references_per_prediction for refs in references			):
            raise ValueError("""Sacrebleu requires the same number of references for each prediction"""			)
      SCREAMING_SNAKE_CASE	=		[[refs[i] for refs in references] for i in range(_SCREAMING_SNAKE_CASE			)]
      SCREAMING_SNAKE_CASE	=		sacrebleu.corpus_bleu(
          _SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE				,		smooth_method=_SCREAMING_SNAKE_CASE				,		smooth_value=_SCREAMING_SNAKE_CASE				,		force=_SCREAMING_SNAKE_CASE				,		lowercase=_SCREAMING_SNAKE_CASE				,		use_effective_order=_SCREAMING_SNAKE_CASE				,		)
      return output.score



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION							,   _KWARGS_DESCRIPTION     )
class 	UpperCamelCase__				(   datasets.Metric     ):



     '''simple docstring'''

     def        SCREAMING_SNAKE_CASE__						(							self		:					List[str] )  ->	str:




           '''simple docstring'''


           return datasets.MetricInfo(
               description=_DESCRIPTION		,citation=_CITATION		,inputs_description=_KWARGS_DESCRIPTION		,features=datasets.Features(
                   {
                       """predictions""": datasets.Value("""string"""		,id="""sequence""" ),
                       """references""": datasets.Sequence(datasets.Value("""string"""		,id="""sequence""" )		,id="""references""" ),
                   } )		,codebase_urls=[
                   """https://github.com/huggingface/transformers/blob/master/src/transformers/data/metrics/squad_metrics.py""",
                   """https://github.com/cocoxu/simplification/blob/master/SARI.py""",
                   """https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py""",
                   """https://github.com/mjpost/sacreBLEU""",
               ]		,reference_urls=[
                   """https://www.aclweb.org/anthology/Q16-1029.pdf""",
                   """https://github.com/mjpost/sacreBLEU""",
                   """https://en.wikipedia.org/wiki/BLEU""",
                   """https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213""",
               ]		,)






     def        SCREAMING_SNAKE_CASE__						(							self		:					List[str]		,lowerCamelCase__		:					Union[str, Any]		,lowerCamelCase__		:					Optional[Any]		,lowerCamelCase__		:					Tuple )  ->	int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE	=		{}
           result.update({"""sari""": compute_sari(sources=lowerCamelCase__		,predictions=lowerCamelCase__		,references=lowerCamelCase__ )} )
           result.update({"""sacrebleu""": compute_sacrebleu(predictions=lowerCamelCase__		,references=lowerCamelCase__ )} )
           result.update({"""exact""": compute_em(predictions=lowerCamelCase__		,references=lowerCamelCase__ )} )
           return result









from ..utils import DummyObject, requires_backends

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Dict				=    ["sentencepiece"]






     def __init__(							self		:					int		,*lowerCamelCase__		:					Any		,**lowerCamelCase__		:					Any )  ->	str:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Union[str, Any]				=    ["sentencepiece"]






     def __init__(							self		:					Any		,*lowerCamelCase__		:					str		,**lowerCamelCase__		:					List[Any] )  ->	str:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			str				=    ["sentencepiece"]






     def __init__(							self		:					Union[str, Any]		,*lowerCamelCase__		:					Union[str, Any]		,**lowerCamelCase__		:					Optional[int] )  ->	Optional[int]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Dict				=    ["sentencepiece"]






     def __init__(							self		:					Tuple		,*lowerCamelCase__		:					Dict		,**lowerCamelCase__		:					Any )  ->	Union[str, Any]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Dict				=    ["sentencepiece"]






     def __init__(							self		:					Optional[int]		,*lowerCamelCase__		:					List[Any]		,**lowerCamelCase__		:					Optional[int] )  ->	str:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			List[str]				=    ["sentencepiece"]






     def __init__(							self		:					Union[str, Any]		,*lowerCamelCase__		:					Union[str, Any]		,**lowerCamelCase__		:					Optional[Any] )  ->	Tuple:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			List[str]				=    ["sentencepiece"]






     def __init__(							self		:					int		,*lowerCamelCase__		:					List[str]		,**lowerCamelCase__		:					str )  ->	Optional[int]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			int				=    ["sentencepiece"]






     def __init__(							self		:					Union[str, Any]		,*lowerCamelCase__		:					List[Any]		,**lowerCamelCase__		:					Optional[Any] )  ->	int:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			List[Any]				=    ["sentencepiece"]






     def __init__(							self		:					List[str]		,*lowerCamelCase__		:					List[str]		,**lowerCamelCase__		:					int )  ->	Tuple:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Union[str, Any]				=    ["sentencepiece"]






     def __init__(							self		:					str		,*lowerCamelCase__		:					Union[str, Any]		,**lowerCamelCase__		:					List[str] )  ->	Optional[int]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Any				=    ["sentencepiece"]






     def __init__(							self		:					int		,*lowerCamelCase__		:					Dict		,**lowerCamelCase__		:					List[Any] )  ->	List[str]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Any				=    ["sentencepiece"]






     def __init__(							self		:					Dict		,*lowerCamelCase__		:					Any		,**lowerCamelCase__		:					Optional[int] )  ->	Union[str, Any]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Tuple				=    ["sentencepiece"]






     def __init__(							self		:					Dict		,*lowerCamelCase__		:					int		,**lowerCamelCase__		:					Optional[int] )  ->	Optional[Any]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			List[Any]				=    ["sentencepiece"]






     def __init__(							self		:					Optional[Any]		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					int )  ->	Any:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Tuple				=    ["sentencepiece"]






     def __init__(							self		:					Optional[Any]		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					Dict )  ->	Union[str, Any]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			List[Any]				=    ["sentencepiece"]






     def __init__(							self		:					int		,*lowerCamelCase__		:					str		,**lowerCamelCase__		:					Optional[Any] )  ->	Dict:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			int				=    ["sentencepiece"]






     def __init__(							self		:					Union[str, Any]		,*lowerCamelCase__		:					Any		,**lowerCamelCase__		:					str )  ->	List[Any]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Dict				=    ["sentencepiece"]






     def __init__(							self		:					int		,*lowerCamelCase__		:					Any		,**lowerCamelCase__		:					Dict )  ->	List[Any]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			int				=    ["sentencepiece"]






     def __init__(							self		:					List[Any]		,*lowerCamelCase__		:					str		,**lowerCamelCase__		:					Any )  ->	int:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Union[str, Any]				=    ["sentencepiece"]






     def __init__(							self		:					Dict		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					str )  ->	Tuple:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			str				=    ["sentencepiece"]






     def __init__(							self		:					Union[str, Any]		,*lowerCamelCase__		:					int		,**lowerCamelCase__		:					Any )  ->	List[str]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Any				=    ["sentencepiece"]






     def __init__(							self		:					Dict		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					str )  ->	int:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			List[str]				=    ["sentencepiece"]






     def __init__(							self		:					Optional[int]		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					Union[str, Any] )  ->	Tuple:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			str				=    ["sentencepiece"]






     def __init__(							self		:					Optional[Any]		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					List[Any] )  ->	Any:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Optional[Any]				=    ["sentencepiece"]






     def __init__(							self		:					List[str]		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					str )  ->	Union[str, Any]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Optional[int]				=    ["sentencepiece"]






     def __init__(							self		:					Optional[Any]		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					str )  ->	Dict:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Tuple				=    ["sentencepiece"]






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




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Dict				=    ["sentencepiece"]






     def __init__(							self		:					Union[str, Any]		,*lowerCamelCase__		:					List[str]		,**lowerCamelCase__		:					List[Any] )  ->	str:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			str				=    ["sentencepiece"]






     def __init__(							self		:					int		,*lowerCamelCase__		:					str		,**lowerCamelCase__		:					str )  ->	Dict:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Union[str, Any]				=    ["sentencepiece"]






     def __init__(							self		:					int		,*lowerCamelCase__		:					List[Any]		,**lowerCamelCase__		:					Optional[int] )  ->	List[str]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Union[str, Any]				=    ["sentencepiece"]






     def __init__(							self		:					List[Any]		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					Dict )  ->	Dict:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )


