code: 
  '''simple docstring'''
  
  
  
  import unittest
  
  import pytest
  
  from transformers import (
      MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
      TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
      MBartaaTokenizerFast,
      MBartConfig,
      MBartForConditionalGeneration,
      TranslationPipeline,
      pipeline,
  )
  from transformers.testing_utils import is_pipeline_test, require_tf, require_torch, slow
  
  from .test_pipelines_common import ANY
  
  
  
  
  
  @is_pipeline_test
  class 			A							(       unittest.TestCase				):
  			lowerCamelCase							:							Tuple       		=  MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
  			lowerCamelCase							:							Optional[int]       		=  TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
  
  
  
  			def A__ (					self       ,     lowerCamelCase__       ,     lowerCamelCase__       ,     lowerCamelCase__       )			->		Tuple:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									if isinstance(model.config       ,     lowerCamelCase__       ):
  															lowercase__ ,						lowercase__							 =       list(tokenizer.lang_code_to_id.keys()       )[:2]
  															lowercase__							 =       TranslationPipeline(model=lowerCamelCase__       ,     tokenizer=lowerCamelCase__       ,     src_lang=lowerCamelCase__       ,     tgt_lang=lowerCamelCase__       )
  									else:
  															lowercase__							 =       TranslationPipeline(model=lowerCamelCase__       ,     tokenizer=lowerCamelCase__       )
  									return translator, ["Some string", "Some other text"]
  
  
  
  			def A__ (					self       ,     lowerCamelCase__       ,     lowerCamelCase__       )			->		Union[str, Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       translator("""Some string"""       )
  									self.assertEqual(lowerCamelCase__       ,     [{"""translation_text""": ANY(lowerCamelCase__       )}]       )
  
  									lowercase__							 =       translator(["""Some string"""]       )
  									self.assertEqual(lowerCamelCase__       ,     [{"""translation_text""": ANY(lowerCamelCase__       )}]       )
  
  									lowercase__							 =       translator(["""Some string""", """other string"""]       )
  									self.assertEqual(lowerCamelCase__       ,     [{"""translation_text""": ANY(lowerCamelCase__       )}, {"""translation_text""": ANY(lowerCamelCase__       )}]       )
  
  
  
  			@require_torch
  			def A__ (					self       )			->		int:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       pipeline("""translation_en_to_ro"""       ,     model="""patrickvonplaten/t5-tiny-random"""       ,     framework="""pt"""       )
  									lowercase__							 =       translator("""This is a test string"""       ,     max_length=20       )
  									self.assertEqual(
  									    lowerCamelCase__       ,     [
  									        {
  									            """translation_text""": (
  									                """Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide"""
  									                """ Beide Beide"""
  									            )
  									        }
  									    ]       ,     )
  
  
  
  			@require_tf
  			def A__ (					self       )			->		Optional[int]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       pipeline("""translation_en_to_ro"""       ,     model="""patrickvonplaten/t5-tiny-random"""       ,     framework="""tf"""       )
  									lowercase__							 =       translator("""This is a test string"""       ,     max_length=20       )
  									self.assertEqual(
  									    lowerCamelCase__       ,     [
  									        {
  									            """translation_text""": (
  									                """Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide"""
  									                """ Beide Beide"""
  									            )
  									        }
  									    ]       ,     )
  
  
  
  			@require_torch
  			def A__ (					self       )			->		List[str]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       pipeline("""translation_en_to_de"""       ,     model="""patrickvonplaten/t5-tiny-random"""       ,     framework="""pt"""       )
  									lowercase__							 =       translator("""This is a test string"""       ,     max_length=20       )
  									self.assertEqual(
  									    lowerCamelCase__       ,     [
  									        {
  									            """translation_text""": (
  									                """monoton monoton monoton monoton monoton monoton monoton monoton monoton monoton urine urine"""
  									                """ urine urine urine urine urine urine urine"""
  									            )
  									        }
  									    ]       ,     )
  
  
  
  			@require_tf
  			def A__ (					self       )			->		Dict:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       pipeline("""translation_en_to_de"""       ,     model="""patrickvonplaten/t5-tiny-random"""       ,     framework="""tf"""       )
  									lowercase__							 =       translator("""This is a test string"""       ,     max_length=20       )
  									self.assertEqual(
  									    lowerCamelCase__       ,     [
  									        {
  									            """translation_text""": (
  									                """monoton monoton monoton monoton monoton monoton monoton monoton monoton monoton urine urine"""
  									                """ urine urine urine urine urine urine urine"""
  									            )
  									        }
  									    ]       ,     )
  
  
  
  
  
  class 			A							(       unittest.TestCase				):
  
  
  
  			@require_torch
  			@slow
  			def A__ (					self       )			->		Union[str, Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									with self.assertRaises(lowerCamelCase__       ):
  															pipeline(task="""translation_cn_to_ar"""       )
  
  									# but we do for this one
  									lowercase__							 =       pipeline(task="""translation_en_to_de"""       )
  									self.assertEqual(translator._preprocess_params["""src_lang"""]       ,     """en"""       )
  									self.assertEqual(translator._preprocess_params["""tgt_lang"""]       ,     """de"""       )
  
  
  
  			@require_torch
  			@slow
  			def A__ (					self       )			->		Union[str, Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       MBartForConditionalGeneration.from_pretrained("""facebook/mbart-large-50-many-to-many-mmt"""       )
  									lowercase__							 =       MBartaaTokenizerFast.from_pretrained("""facebook/mbart-large-50-many-to-many-mmt"""       )
  
  									lowercase__							 =       pipeline(task="""translation"""       ,     model=lowerCamelCase__       ,     tokenizer=lowerCamelCase__       )
  									# Missing src_lang, tgt_lang
  									with self.assertRaises(lowerCamelCase__       ):
  															translator("""This is a test"""       )
  
  									lowercase__							 =       translator("""This is a test"""       ,     src_lang="""en_XX"""       ,     tgt_lang="""ar_AR"""       )
  									self.assertEqual(lowerCamelCase__       ,     [{"""translation_text""": """هذا إختبار"""}]       )
  
  									lowercase__							 =       translator("""This is a test"""       ,     src_lang="""en_XX"""       ,     tgt_lang="""hi_IN"""       )
  									self.assertEqual(lowerCamelCase__       ,     [{"""translation_text""": """यह एक परीक्षण है"""}]       )
  
  									# src_lang, tgt_lang can be defined at pipeline call time
  									lowercase__							 =       pipeline(task="""translation"""       ,     model=lowerCamelCase__       ,     tokenizer=lowerCamelCase__       ,     src_lang="""en_XX"""       ,     tgt_lang="""ar_AR"""       )
  									lowercase__							 =       translator("""This is a test"""       )
  									self.assertEqual(lowerCamelCase__       ,     [{"""translation_text""": """هذا إختبار"""}]       )
  
  
  
  			@require_torch
  			def A__ (					self       )			->		List[str]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       """patrickvonplaten/t5-tiny-random"""
  									lowercase__							 =       pipeline(task="""translation_cn_to_ar"""       ,     model=lowerCamelCase__       )
  									self.assertEqual(translator._preprocess_params["""src_lang"""]       ,     """cn"""       )
  									self.assertEqual(translator._preprocess_params["""tgt_lang"""]       ,     """ar"""       )
  
  
  
  			@require_torch
  			def A__ (					self       )			->		Tuple:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       """patrickvonplaten/t5-tiny-random"""
  									with pytest.warns(lowerCamelCase__       ,     match=R""".*translation_en_to_de.*"""       ):
  															lowercase__							 =       pipeline(task="""translation"""       ,     model=lowerCamelCase__       )
  									self.assertEqual(translator.task       ,     """translation_en_to_de"""       )
  									self.assertEqual(translator._preprocess_params["""src_lang"""]       ,     """en"""       )
  									self.assertEqual(translator._preprocess_params["""tgt_lang"""]       ,     """de"""       )
  
  
  
  			@require_torch
  			def A__ (					self       )			->		Union[str, Any]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									with self.assertRaises(lowerCamelCase__       ):
  															pipeline(task="""translation"""       )
  
  
  
  
  
  
  
style_context: 
  '''simple docstring'''
  
  
  
  import bisect
  import copy
  from collections import defaultdict
  
  import numpy as np
  from torch.utils.data import BatchSampler, Sampler
  
  from utils import logger
  
  
  
  
  
  def  _A		(							lowercase__		,		lowercase__	):
  						lowercase__							 =       copy.deepcopy(lowercase__	)
  						lowercase__							 =       sorted(lowercase__	)
  						lowercase__							 =       [bisect.bisect_right(lowercase__		,		lowercase__	) for y in x]
  						return quantized
  
  
  
  
  
  def  _A		(							lowercase__		,		lowercase__=0	):
  						lowercase__							 =       np.arange(start=3		,		stop=lowercase__		,		step=4	).tolist() if k > 0 else [10]
  						lowercase__							 =       _quantize(lowercase__		,		lowercase__	)
  						# count number of elements per group
  						lowercase__							 =       np.unique(lowercase__		,		return_counts=lowercase__	)[1]
  						lowercase__							 =       [0] + bins + [np.inf]
  						logger.info("""Using {} as bins for aspect lengths quantization""".format(lowercase__	)	)
  						logger.info("""Count of instances per bin: {}""".format(lowercase__	)	)
  						return groups
  
  
  
  
  
  
  
  class 			A							(       __UpperCAmelCase				):
  
  
  
  			def __init__(					self       ,     lowerCamelCase__       ,     lowerCamelCase__       ,     lowerCamelCase__       )			->		Optional[int]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									if not isinstance(lowerCamelCase__       ,     lowerCamelCase__       ):
  															raise ValueError(
  															    """sampler should be an instance of torch.utils.data.Sampler, but got sampler={}""".format(lowerCamelCase__       )       )
  									lowercase__							 =       sampler
  									lowercase__							 =       group_ids
  									lowercase__							 =       batch_size
  
  
  
  			def __iter__(					self       )			->		List[str]:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									lowercase__							 =       defaultdict(lowerCamelCase__       )
  									lowercase__							 =       defaultdict(lowerCamelCase__       )
  
  									lowercase__							 =       0
  									for idx in self.sampler:
  															lowercase__							 =       self.group_ids[idx]
  															buffer_per_group[group_id].append(lowerCamelCase__       )
  															samples_per_group[group_id].append(lowerCamelCase__       )
  															if len(buffer_per_group[group_id]       ) == self.batch_size:
  																					yield buffer_per_group[group_id]  # TODO
  																					num_batches += 1
  																					del buffer_per_group[group_id]
  															assert len(buffer_per_group[group_id]       ) < self.batch_size
  
  									# now we have run out of elements that satisfy
  									# the group criteria, let's return the remaining
  									# elements so that the size of the sampler is
  									# deterministic
  									lowercase__							 =       len(self       )
  									lowercase__							 =       expected_num_batches - num_batches
  									if num_remaining > 0:
  															# for the remaining batches, group the batches by similar lengths
  															lowercase__							 =       []
  															for group_id, idxs in sorted(buffer_per_group.items()       ,     key=lambda lowerCamelCase__       : x[0]       ):
  																					batch_idx.extend(lowerCamelCase__       )
  																					if len(lowerCamelCase__       ) >= self.batch_size:
  																											yield batch_idx[: self.batch_size]
  																											lowercase__							 =       batch_idx[self.batch_size :]
  																											num_remaining -= 1
  															if len(lowerCamelCase__       ) > 0:
  																					yield batch_idx
  																					num_remaining -= 1
  									assert num_remaining == 0
  
  
  
  			def __len__(					self       )			->		Any:
  
  
  
  
  									'''simple docstring'''
  
  
  
  									return (len(self.sampler       ) + self.batch_size - 1) // self.batch_size
  
  
  
  
  
  
  