


import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device


if is_torch_available():
 import torch

 from transformers import XLMProphetNetForConditionalGeneration, XLMProphetNetTokenizer




@require_torch
class A						(     unittest.TestCase  ):






      @slow
      def  lowerCamelCase (      self		:  int				)      ->		Tuple:
             """simple docstring"""




             _lowerCamelCase :	Optional[int]						=XLMProphetNetForConditionalGeneration.from_pretrained('microsoft/xprophetnet-large-wiki100-cased'				)
             model.to(lowercase_				)

             # encoder-decoder outputs
             _lowerCamelCase :	str						=torch.tensor([[17, 9_6208, 10_3471, 2]]				).to(lowercase_				)
             _lowerCamelCase :	str						=torch.tensor(
                 [[2, 250, 9953, 34, 6_9489, 1620, 32, 11_8424, 624, 210, 105, 2913, 1032, 351]]				).to(lowercase_				)
             _lowerCamelCase :	Tuple						=model(
                 input_ids=lowercase_    ,     attention_mask=lowercase_    ,     encoder_outputs=lowercase_    ,     decoder_input_ids=lowercase_				)
             _lowerCamelCase :	str						=output[0]
             _lowerCamelCase :	Union[str, Any]						=torch.Size((1, 14, 25_0012)				)
             self.assertEqual(output_predited_logis.shape    ,     lowercase_				)
             _lowerCamelCase :	Dict						=torch.tensor(
                 [[[-6.3986, -8.2391, 12.5189], [-6.3289, -8.0864, 12.6211], [-6.2418, -8.0445, 12.7968]]]				).to(lowercase_				)
             self.assertTrue(torch.allclose(output_predited_logis[:, :3, :3]    ,     lowercase_    ,     atol=1E-4				)				)

             # encoder outputs
             _lowerCamelCase :	str						=model.prophetnet.encoder(lowercase_				)[0]
             _lowerCamelCase :	Optional[Any]						=torch.tensor(
                 [[[-1.4260, -0.7628, 0.8453], [-1.4719, -0.1391, 0.7807], [-1.7678, 0.0114, 0.4646]]]				).to(lowercase_				)
             _lowerCamelCase :	List[str]						=torch.Size((1, 4, 1024)				)
             self.assertEqual(encoder_outputs.shape    ,     lowercase_				)
             self.assertTrue(torch.allclose(encoder_outputs[:, :3, :3]    ,     lowercase_    ,     atol=1E-4				)				)

             # decoder outputs
             _lowerCamelCase :	Tuple						=model.prophetnet.decoder(
                 lowercase_    ,     encoder_hidden_states=lowercase_    ,     )
             _lowerCamelCase :	Optional[Any]						=decoder_outputs[1].view(1    ,     model.config.ngram    ,     14    ,     -1				)
             _lowerCamelCase :	Tuple						=model.lm_head(lowercase_				)
             _lowerCamelCase :	Optional[int]						=predicting_streams_logits[:, 0]
             self.assertTrue(torch.allclose(next_first_stream_logits[:, :3, :3]    ,     lowercase_    ,     atol=1E-4				)				)






      @slow
      def  lowerCamelCase (      self		:  Any				)      ->		List[str]:
             """simple docstring"""




             _lowerCamelCase :	List[Any]						=XLMProphetNetForConditionalGeneration.from_pretrained(
                 'microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'				)
             model.to(lowercase_				)

             _lowerCamelCase :	Optional[int]						=torch.tensor([[17, 9_6208, 10_3471, 2]]				).to(lowercase_				)
             _lowerCamelCase :	Any						=torch.tensor(
                 [[2, 250, 9953, 34, 6_9489, 1620, 32, 11_8424, 624, 210, 105, 2913, 1032, 351]]				).to(lowercase_				)
             _lowerCamelCase :	str						=model(
                 input_ids=lowercase_    ,     attention_mask=lowercase_    ,     encoder_outputs=lowercase_    ,     decoder_input_ids=lowercase_				)
             _lowerCamelCase :	Dict						=output[0]
             _lowerCamelCase :	List[Any]						=torch.Size((1, 14, 25_0012)				)
             self.assertEqual(output_predited_logis.shape    ,     lowercase_				)
             # compare the actual values for a slice.
             _lowerCamelCase :	Optional[Any]						=torch.tensor(
                 [[[-9.2253, -9.7173, -6.3529], [-7.6701, -9.0145, -1.9382], [-8.0195, -7.0004, -0.1523]]]				).to(lowercase_				)

             self.assertTrue(torch.allclose(output_predited_logis[:, :3, :3]    ,     lowercase_    ,     atol=1E-4				)				)






      @slow
      def  lowerCamelCase (      self		:  Optional[int]				)      ->		Optional[Any]:
             """simple docstring"""




             _lowerCamelCase :	Tuple						=XLMProphetNetForConditionalGeneration.from_pretrained(
                 'microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'				)
             model.to(lowercase_				)
             _lowerCamelCase :	Union[str, Any]						=512

             _lowerCamelCase :	int						=XLMProphetNetTokenizer.from_pretrained('microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'				)

             _lowerCamelCase :	List[Any]						=(
                 'Microsoft Corporation intends to officially end free support for the Windows 7 operating system after'
                 ' January 14, 2020, according to the official portal of the organization. From that day, users of this'
                 ' system will not be able to receive security updates, which could make their computers vulnerable to'
                 ' cyber attacks.'
             )
             _lowerCamelCase :	Dict						=(
                 'орпорация Microsoft намерена официально прекратить бесплатную поддержку операционной системы Windows 7'
                 ' после 14 января 2020 года, сообщается на официальном портале организации . С указанного дня пользователи'
                 ' этой системы не смогут получать обновления безопасности, из-за чего их компьютеры могут стать уязвимыми'
                 ' к кибератакам.'
             )
             _lowerCamelCase :	List[str]						=(
                 '根据该组织的官方门户网站，微软公司打算在2020年1月14日之后正式终止对Windows 7操作系统的免费支持。从那时起，该系统的用户将无法接收安全更新，这可能会使他们的计算机容易受到网络攻击。'
             )

             _lowerCamelCase :	List[str]						=tokenizer(
                 [EN_SENTENCE, RU_SENTENCE, ZH_SENTENCE]    ,     padding=lowercase_    ,     max_length=255    ,     return_tensors='pt'				).input_ids
             _lowerCamelCase :	Optional[Any]						=input_ids.to(lowercase_				)

             _lowerCamelCase :	Optional[int]						=model.generate(
                 lowercase_    ,     num_beams=10    ,     length_penalty=1.0    ,     no_repeat_ngram_size=3    ,     early_stopping=lowercase_				)
             _lowerCamelCase :	Optional[Any]						=[tokenizer.decode(lowercase_    ,     skip_special_tokens=lowercase_				) for g in summary_ids]
             _lowerCamelCase :	Union[str, Any]						='Microsoft to end Windows 7 free support after January 14, 2020'
             _lowerCamelCase :	Optional[int]						='Microsoft намерена прекратить бесплатную поддержку Windows 7 после 14 января 2020 года'
             _lowerCamelCase :	str						='微软打算终止对Windows 7操作系统的免费支持'
             self.assertListEqual(
                 [EXPECTED_TITLE_EN, EXPECTED_TITLE_RU, EXPECTED_TITLE_ZH]    ,     lowercase_    ,     )

             _lowerCamelCase :	Optional[int]						=model.generate(
                 lowercase_    ,     num_beams=1    ,     length_penalty=1.0    ,     no_repeat_ngram_size=3    ,     early_stopping=lowercase_				)
             _lowerCamelCase :	str						=[
                 tokenizer.convert_ids_to_tokens(lowercase_    ,     skip_special_tokens=lowercase_				) for g in summary_ids_beama
             ]
             _lowerCamelCase :	List[Any]						='▁Microsoft ▁to ▁end ▁free ▁support ▁for ▁Windows ▁7'.split(' '				)
             _lowerCamelCase :	int						='▁Microsoft ▁намерен а ▁прекрати ть ▁бес плат ную ▁поддержку ▁Windows ▁7 ▁после ▁14 ▁января ▁2020 ▁года'.split(
                 ' '				)
             _lowerCamelCase :	str						='微软 公司 打算 终止 对 Windows ▁7 操作 系统的 免费 支持'.split(' '				)
             self.assertListEqual(
                 [EXPECTED_TITLE_EN_BEAM1_TOK, EXPECTED_TITLE_RU_BEAM1_TOK, EXPECTED_TITLE_ZH_BEAM1_TOK]    ,     lowercase_    ,     )






import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin




class A						(     UpperCamelCase_  ):
      UpperCamelCase__							:						Optional[Any]   ='AutoFeatureExtractor'
      UpperCamelCase__							:						List[str]   ='Speech2Text2Tokenizer'






      def __init__(      self		:  str    ,     lowercase_		:  Dict    ,     lowercase_		:  Optional[int]				)      ->		str:
             """simple docstring"""




             super().__init__(lowercase_    ,     lowercase_				)
             _lowerCamelCase :	Optional[Any]						=self.feature_extractor
             _lowerCamelCase :	Tuple						=False






      def __call__(      self		:  Tuple    ,     *lowercase_		:  str    ,     **lowercase_		:  List[Any]				)      ->		List[str]:
             """simple docstring"""




             if self._in_target_context_manager:
                    return self.current_processor(*lowercase_    ,     **lowercase_				)

             if "raw_speech" in kwargs:
                    warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'				)
                    _lowerCamelCase :	List[str]						=kwargs.pop('raw_speech'				)
             else:
                    _lowerCamelCase :	str						=kwargs.pop('audio'    ,     lowercase_				)
             _lowerCamelCase :	Optional[Any]						=kwargs.pop('sampling_rate'    ,     lowercase_				)
             _lowerCamelCase :	List[str]						=kwargs.pop('text'    ,     lowercase_				)
             if len(lowercase_				) > 0:
                    _lowerCamelCase :	Dict						=args[0]
                    _lowerCamelCase :	Optional[Any]						=args[1:]

             if audio is None and text is None:
                    raise ValueError('You need to specify either an `audio` or `text` input to process.'				)

             if audio is not None:
                    _lowerCamelCase :	List[Any]						=self.feature_extractor(lowercase_    ,     *lowercase_    ,     sampling_rate=lowercase_    ,     **lowercase_				)
             if text is not None:
                    _lowerCamelCase :	Tuple						=self.tokenizer(lowercase_    ,     **lowercase_				)

             if text is None:
                    return inputs
             elif audio is None:
                    return encodings
             else:
                    _lowerCamelCase :	Dict						=encodings['input_ids']
                    return inputs






      def  lowerCamelCase (      self		:  str    ,     *lowercase_		:  List[Any]    ,     **lowercase_		:  Any				)      ->		Union[str, Any]:
             """simple docstring"""




             return self.tokenizer.batch_decode(*lowercase_    ,     **lowercase_				)






      def  lowerCamelCase (      self		:  Optional[int]    ,     *lowercase_		:  Dict    ,     **lowercase_		:  Optional[int]				)      ->		str:
             """simple docstring"""




             return self.tokenizer.decode(*lowercase_    ,     **lowercase_				)






      @contextmanager
      def  lowerCamelCase (      self		:  Optional[Any]				)      ->		Tuple:
             """simple docstring"""




             warnings.warn(
                 '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
                 'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
                 'your audio inputs, or in a separate call.'				)
             _lowerCamelCase :	Optional[Any]						=True
             _lowerCamelCase :	List[Any]						=self.tokenizer
             yield
             _lowerCamelCase :	Optional[int]						=self.feature_extractor
             _lowerCamelCase :	List[str]						=False


