

import unittest

from transformers import (
    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    SummarizationPipeline,
    TFPreTrainedModel,
    pipeline,
)
from transformers.testing_utils import get_gpu_count, is_pipeline_test, require_tf, require_torch, slow, torch_device
from transformers.tokenization_utils import TruncationStrategy

from .test_pipelines_common import ANY


lowerCAmelCase__							=			-1 if torch_device == "cpu" else 0






@is_pipeline_test
class     __magic_name__     (							unittest.TestCase     ):
 UpperCAmelCase				     =    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
 UpperCAmelCase				     =    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING


 def _UpperCamelCase						(    self		:			Any      ,    lowerCAmelCase__		:			int      ,    lowerCAmelCase__		:			Union[str, Any]      ,    lowerCAmelCase__		:			Dict     )     ->   Optional[Any]:
   UpperCAmelCase          =	SummarizationPipeline(model=lowerCAmelCase__      ,    tokenizer=lowerCAmelCase__     )
   return summarizer, ["(CNN)The Palestinian Authority officially became", "Some other text"]


 def _UpperCamelCase						(    self		:			List[str]      ,    lowerCAmelCase__		:			Optional[Any]      ,    lowerCAmelCase__		:			int     )     ->   Optional[int]:
   UpperCAmelCase          =	summarizer.model

   UpperCAmelCase          =	summarizer("(CNN)The Palestinian Authority officially became"     )
   self.assertEqual(lowerCAmelCase__      ,    [{"summary_text": ANY(lowerCAmelCase__     )}]     )

   UpperCAmelCase          =	summarizer(
       "(CNN)The Palestinian Authority officially became "      ,    num_beams=2      ,    min_length=2      ,    max_length=5      ,    )
   self.assertEqual(lowerCAmelCase__      ,    [{"summary_text": ANY(lowerCAmelCase__     )}]     )

   # Some models (Switch Transformers, LED, T5, LongT5, etc) can handle long sequences.
   UpperCAmelCase          =	[
       "SwitchTransformersConfig",
       "T5Config",
       "LongT5Config",
       "LEDConfig",
       "PegasusXConfig",
       "FSMTConfig",
       "M2M100Config",
       "ProphetNetConfig",  # positional embeddings up to a fixed maximum size (otherwise clamping the values)
   ]
   if model.config.__class__.__name__ not in model_can_handle_longer_seq:
     # Too long and exception is expected.
     # For TF models, if the weights are initialized in GPU context, we won't get expected index error from
     # the embedding layer.
     if not (
         isinstance(lowerCAmelCase__      ,    lowerCAmelCase__     )
         and get_gpu_count() > 0
         and len(summarizer.model.trainable_weights     ) > 0
     ):
       with self.assertRaises(lowerCAmelCase__     ):
         UpperCAmelCase          =	summarizer("This " * 1_0_0_0     )
   UpperCAmelCase          =	summarizer("This " * 1_0_0_0      ,    truncation=TruncationStrategy.ONLY_FIRST     )


 @require_torch
 def _UpperCamelCase						(    self		:			Optional[int]     )     ->   Optional[int]:
   UpperCAmelCase          =	pipeline(task="summarization"      ,    model="sshleifer/tiny-mbart"      ,    framework="pt"     )
   UpperCAmelCase          =	summarizer("This is a small test"     )
   self.assertEqual(
       lowerCAmelCase__      ,    [
           {
               "summary_text": "เข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไป"
           }
       ]      ,    )


 @require_tf
 def _UpperCamelCase						(    self		:			str     )     ->   Union[str, Any]:
   UpperCAmelCase          =	pipeline(task="summarization"      ,    model="sshleifer/tiny-mbart"      ,    framework="tf"     )
   UpperCAmelCase          =	summarizer("This is a small test"     )
   self.assertEqual(
       lowerCAmelCase__      ,    [
           {
               "summary_text": "เข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไปเข้าไป"
           }
       ]      ,    )


 @require_torch
 @slow
 def _UpperCamelCase						(    self		:			Optional[Any]     )     ->   int:
   UpperCAmelCase          =	pipeline(task="summarization"      ,    device=lowerCAmelCase__     )
   UpperCAmelCase          =	(
       " (CNN)The Palestinian Authority officially became the 123rd member of the International Criminal Court on"
       " Wednesday, a step that gives the court jurisdiction over alleged crimes in Palestinian territories. The"
       " formal accession was marked with a ceremony at The Hague, in the Netherlands, where the court is based."
       " The Palestinians signed the ICC's founding Rome Statute in January, when they also accepted its"
       " jurisdiction over alleged crimes committed \"in the occupied Palestinian territory, including East"
       " Jerusalem, since June 13, 2014.\" Later that month, the ICC opened a preliminary examination into the"
       " situation in Palestinian territories, paving the way for possible war crimes investigations against"
       " Israelis. As members of the court, Palestinians may be subject to counter-charges as well. Israel and"
       " the United States, neither of which is an ICC member, opposed the Palestinians' efforts to join the"
       " body. But Palestinian Foreign Minister Riad al-Malki, speaking at Wednesday's ceremony, said it was a"
       " move toward greater justice. \"As Palestine formally becomes a State Party to the Rome Statute today, the"
       " world is also a step closer to ending a long era of impunity and injustice,\" he said, according to an"
       " ICC news release. \"Indeed, today brings us closer to our shared goals of justice and peace.\" Judge"
       " Kuniko Ozaki, a vice president of the ICC, said acceding to the treaty was just the first step for the"
       " Palestinians. \"As the Rome Statute today enters into force for the State of Palestine, Palestine"
       " acquires all the rights as well as responsibilities that come with being a State Party to the Statute."
       " These are substantive commitments, which cannot be taken lightly,\" she said. Rights group Human Rights"
       " Watch welcomed the development. \"Governments seeking to penalize Palestine for joining the ICC should"
       " immediately end their pressure, and countries that support universal acceptance of the court's treaty"
       " should speak out to welcome its membership,\" said Balkees Jarrah, international justice counsel for the"
       " group. \"What's objectionable is the attempts to undermine international justice, not Palestine's"
       " decision to join a treaty to which over 100 countries around the world are members.\" In January, when"
       " the preliminary ICC examination was opened, Israeli Prime Minister Benjamin Netanyahu described it as an"
       " outrage, saying the court was overstepping its boundaries. The United States also said it \"strongly\""
       " disagreed with the court's decision. \"As we have said repeatedly, we do not believe that Palestine is a"
       " state and therefore we do not believe that it is eligible to join the ICC,\" the State Department said in"
       " a statement. It urged the warring sides to resolve their differences through direct negotiations. \"We"
       " will continue to oppose actions against Israel at the ICC as counterproductive to the cause of peace,\""
       " it said. But the ICC begs to differ with the definition of a state for its purposes and refers to the"
       " territories as \"Palestine.\" While a preliminary examination is not a formal investigation, it allows the"
       " court to review evidence and determine whether to investigate suspects on both sides. Prosecutor Fatou"
       " Bensouda said her office would \"conduct its analysis in full independence and impartiality.\" The war"
       " between Israel and Hamas militants in Gaza last summer left more than 2,000 people dead. The inquiry"
       " will include alleged war crimes committed since June. The International Criminal Court was set up in"
       " 2002 to prosecute genocide, crimes against humanity and war crimes. CNN's Vasco Cotovio, Kareem Khadder"
       " and Faith Karimi contributed to this report."
   )
   UpperCAmelCase          =	(
       " The Palestinian Authority becomes the 123rd member of the International Criminal Court . The move gives"
       " the court jurisdiction over alleged crimes in Palestinian territories . Israel and the United States"
       " opposed the Palestinians' efforts to join the court . Rights group Human Rights Watch welcomes the move,"
       " says governments seeking to penalize Palestine should end pressure ."
   )
   UpperCAmelCase          =	summarizer(lowerCAmelCase__     )
   self.assertEqual(result[0]["summary_text"]      ,    lowerCAmelCase__     )






import sys
from collections.abc import Mapping

import numpy as np
import pyarrow as pa

from .. import config
from ..utils.py_utils import map_nested
from .formatting import TensorFormatter






class     __magic_name__     (							TensorFormatter[Mapping, np.ndarray, Mapping]     ):


 def __init__(    self		:			Optional[int]      ,    lowerCAmelCase__		:			str=None      ,    **lowerCAmelCase__		:			int     )     ->   Optional[Any]:
   super().__init__(features=lowerCAmelCase__     )
   UpperCAmelCase          =	np_array_kwargs


 def _UpperCamelCase						(    self		:			Any      ,    lowerCAmelCase__		:			Dict     )     ->   Union[str, Any]:
   if isinstance(lowerCAmelCase__      ,    lowerCAmelCase__     ):
     if column and all(
         isinstance(lowerCAmelCase__      ,    np.ndarray     ) and x.shape == column[0].shape and x.dtype == column[0].dtype for x in column     ):
       return np.stack(lowerCAmelCase__     )
     else:
       # don't use np.array(column, dtype=object)
       # since it fails in certain cases
       # see https://stackoverflow.com/q/51005699
       UpperCAmelCase          =	np.empty(len(lowerCAmelCase__     )      ,    dtype=lowerCAmelCase__     )
       UpperCAmelCase          =	column
       return out
   return column


 def _UpperCamelCase						(    self		:			Optional[Any]      ,    lowerCAmelCase__		:			Union[str, Any]     )     ->   List[Any]:
   if isinstance(lowerCAmelCase__      ,    (str, bytes, type(lowerCAmelCase__     ))     ):
     return value
   elif isinstance(lowerCAmelCase__      ,    (np.character, np.ndarray)     ) and np.issubdtype(value.dtype      ,    np.character     ):
     return value
   elif isinstance(lowerCAmelCase__      ,    np.number     ):
     return value

   UpperCAmelCase          =	{}

   if isinstance(lowerCAmelCase__      ,    np.ndarray     ) and np.issubdtype(value.dtype      ,    np.integer     ):
     UpperCAmelCase          =	{"dtype": np.intaa}
   elif isinstance(lowerCAmelCase__      ,    np.ndarray     ) and np.issubdtype(value.dtype      ,    np.floating     ):
     UpperCAmelCase          =	{"dtype": np.floataa}
   elif config.PIL_AVAILABLE and "PIL" in sys.modules:
     import PIL.Image

     if isinstance(lowerCAmelCase__      ,    PIL.Image.Image     ):
       return np.asarray(lowerCAmelCase__      ,    **self.np_array_kwargs     )

   return np.asarray(lowerCAmelCase__      ,    **{**default_dtype, **self.np_array_kwargs}     )


 def _UpperCamelCase						(    self		:			List[Any]      ,    lowerCAmelCase__		:			str     )     ->   Optional[int]:
   # support for torch, tf, jax etc.
   if config.TORCH_AVAILABLE and "torch" in sys.modules:
     import torch

     if isinstance(lowerCAmelCase__      ,    torch.Tensor     ):
       return self._tensorize(data_struct.detach().cpu().numpy()[()]     )
   if hasattr(lowerCAmelCase__      ,    "__array__"     ) and not isinstance(lowerCAmelCase__      ,    (np.ndarray, np.character, np.number)     ):
     UpperCAmelCase          =	data_struct.__array__()
   # support for nested types like struct of list of struct
   if isinstance(lowerCAmelCase__      ,    np.ndarray     ):
     if data_struct.dtype == object:
       return self._consolidate([self.recursive_tensorize(lowerCAmelCase__     ) for substruct in data_struct]     )
   if isinstance(lowerCAmelCase__      ,    (list, tuple)     ):
     return self._consolidate([self.recursive_tensorize(lowerCAmelCase__     ) for substruct in data_struct]     )
   return self._tensorize(lowerCAmelCase__     )


 def _UpperCamelCase						(    self		:			Union[str, Any]      ,    lowerCAmelCase__		:			dict     )     ->   Union[str, Any]:
   return map_nested(self._recursive_tensorize      ,    lowerCAmelCase__      ,    map_list=lowerCAmelCase__     )


 def _UpperCamelCase						(    self		:			int      ,    lowerCAmelCase__		:			pa.Table     )     ->   Mapping:
   UpperCAmelCase          =	self.numpy_arrow_extractor().extract_row(lowerCAmelCase__     )
   UpperCAmelCase          =	self.python_features_decoder.decode_row(lowerCAmelCase__     )
   return self.recursive_tensorize(lowerCAmelCase__     )


 def _UpperCamelCase						(    self		:			List[str]      ,    lowerCAmelCase__		:			pa.Table     )     ->   np.ndarray:
   UpperCAmelCase          =	self.numpy_arrow_extractor().extract_column(lowerCAmelCase__     )
   UpperCAmelCase          =	self.python_features_decoder.decode_column(lowerCAmelCase__      ,    pa_table.column_names[0]     )
   UpperCAmelCase          =	self.recursive_tensorize(lowerCAmelCase__     )
   UpperCAmelCase          =	self._consolidate(lowerCAmelCase__     )
   return column


 def _UpperCamelCase						(    self		:			List[Any]      ,    lowerCAmelCase__		:			pa.Table     )     ->   Mapping:
   UpperCAmelCase          =	self.numpy_arrow_extractor().extract_batch(lowerCAmelCase__     )
   UpperCAmelCase          =	self.python_features_decoder.decode_batch(lowerCAmelCase__     )
   UpperCAmelCase          =	self.recursive_tensorize(lowerCAmelCase__     )
   for column_name in batch:
     UpperCAmelCase          =	self._consolidate(batch[column_name]     )
   return batch



